Merge pull request #51 from lucasrguerra/release/1.3.1

release: 1.3.1

.githooks/pre-push

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Antes de cada push: a verificação rápida. Ignore com `git push --no-verify` (use com parcimônia).
+exec "$(git rev-parse --show-toplevel)/scripts/verificar.sh"

.github/dependabot.yml

@@ -1,24 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: cargo
-    directory: /
-    schedule: { interval: weekly }
-    groups:
-      rustcrypto:
-        patterns:
-          - sha2
-          - sha1
-          - md-5
-          - hmac
-          - pbkdf2
-          - ripemd
-          - aes
-          - argon2
-          - cipher
-          - digest
-  - package-ecosystem: cargo
-    directory: /apps/gui/src-tauri
-    schedule: { interval: weekly }
-  - package-ecosystem: github-actions
-    directory: /
-    schedule: { interval: weekly }

.github/workflows/ci.yml

@@ -1,9 +1,12 @@
 name: CI
 
 on:
+  # Mudança só de documentação não precisa de 6 jobs em 3 sistemas.
   push:
     branches: [main]
+    paths-ignore: ['**.md', 'docs/**', 'LICENSE*', '.gitignore', '.githooks/**']
   pull_request:
+    paths-ignore: ['**.md', 'docs/**', 'LICENSE*', '.gitignore', '.githooks/**']
 
 concurrency:
   group: ci-${{ github.ref }}
@@ -28,6 +31,8 @@ jobs:
           node-version: 22
       - name: Cobertura da tradução da interface
         run: node scripts/check-ui-i18n.mjs
+      - name: Script do latest.json do atualizador
+        run: python3 scripts/test_make_latest_json.py
       - run: cargo fmt --all -- --check
       - run: cargo clippy --workspace --all-targets
 
@@ -42,12 +47,28 @@ jobs:
       - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
+      - name: Cache dos pacotes das ferramentas de teste (.deb)
+        if: runner.os == 'Linux'
+        uses: actions/cache@v6
+        with:
+          path: ~/apt-cache-tools
+          key: apt-tools-${{ runner.os }}-${{ runner.arch }}-${{ env.ImageVersion }}-${{ hashFiles('scripts/apt-install.sh') }}
       - name: Ferramentas para imagens de teste (Linux)
         if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y mtools dosfstools exfatprogs ntfs-3g e2fsprogs imagemagick zip
-      - name: Testes (com imagens reais FAT32/NTFS/ext4 no Linux)
+        timeout-minutes: 25
+        run: scripts/apt-install.sh ~/apt-cache-tools mtools dosfstools exfatprogs ntfs-3g e2fsprogs xfsprogs imagemagick zip
+      - name: Cache das imagens de referência
+        uses: actions/cache@v6
+        with:
+          path: target/testdata
+          key: testdata-${{ runner.os }}-${{ hashFiles('scripts/fetch-testdata.sh') }}
+      - name: Imagens de referência (BitLocker, FileVault 2, dfvfs, AFF4)
+        shell: bash
+        run: scripts/fetch-testdata.sh
+      - name: Imagem XFS com exclusão feita pelo kernel (Linux)
+        if: runner.os == 'Linux'
+        run: sudo scripts/make-xfs-real-deletion.sh
+      - name: Testes (imagens de referência nos três sistemas; FAT32, NTFS e ext4 gerados no Linux)
         shell: bash
         run: |
           if [ "$RUNNER_OS" = "Linux" ]; then export GUARA_REQUIRE_FIXTURES=1; fi
@@ -74,10 +95,14 @@ jobs:
       - uses: actions/setup-node@v7
         with:
           node-version: 22
+      - name: Cache dos pacotes do Tauri (.deb)
+        uses: actions/cache@v6
+        with:
+          path: ~/apt-cache
+          key: apt-tauri-${{ runner.os }}-${{ runner.arch }}-${{ env.ImageVersion }}-${{ hashFiles('scripts/apt-install.sh') }}
       - name: Dependências do Tauri
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+        timeout-minutes: 25
+        run: scripts/apt-install.sh ~/apt-cache libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
       - name: Gera os ícones
         run: npx --yes @tauri-apps/cli@2 icon apps/gui/src-tauri/icons/source.png -o apps/gui/src-tauri/icons
       - run: cargo check --manifest-path apps/gui/src-tauri/Cargo.toml

.github/workflows/release.yml

@@ -87,6 +87,8 @@ jobs:
     name: App desktop (${{ matrix.name }})
     needs: create-release
     runs-on: ${{ matrix.os }}
+    # Os segredos de assinatura do atualizador ficam no ambiente "release", que só aceita tags v*.
+    environment: release
     strategy:
       fail-fast: false
       matrix:
@@ -106,20 +108,31 @@ jobs:
       - uses: actions/setup-node@v7
         with:
           node-version: 22
+      - name: Cache dos pacotes do Tauri (.deb)
+        if: runner.os == 'Linux'
+        uses: actions/cache@v6
+        with:
+          path: ~/apt-cache
+          key: apt-tauri-${{ runner.os }}-${{ runner.arch }}-${{ env.ImageVersion }}-${{ hashFiles('scripts/apt-install.sh') }}
       - name: Dependências do Tauri (Linux)
         if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
+        timeout-minutes: 25
+        run: scripts/apt-install.sh ~/apt-cache libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf
       - name: Gera os ícones
         run: npx --yes @tauri-apps/cli@2 icon apps/gui/src-tauri/icons/source.png -o apps/gui/src-tauri/icons
+      # A chave privada de atualização fica só nos segredos do repositório. Ela assina os pacotes
+      # que o app baixa sozinho; a chave pública correspondente está em tauri.conf.json.
       - uses: tauri-apps/tauri-action@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
         with:
           projectPath: apps/gui/src-tauri
           releaseId: ${{ needs.create-release.outputs.release_id }}
           args: ${{ matrix.args }}
+          # o latest.json é montado no job de publicação, de uma vez só (scripts/make-latest-json.py)
+          uploadUpdaterJson: false
 
   publish:
     name: Publica a release
@@ -144,3 +157,11 @@ jobs:
               body: fs.readFileSync('notes.md', 'utf8'),
               draft: false,
             });
+      # Depois de publicada (rascunho não é visível por tag), monta e sobe o latest.json.
+      - name: latest.json do atualizador do app
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+        run: |
+          python3 scripts/make-latest-json.py "$GITHUB_REF_NAME" notes.md latest.json
+          gh release upload "$GITHUB_REF_NAME" latest.json --clobber

.gitignore

@@ -4,6 +4,7 @@
 # Estado de ferramentas locais
 .wolf/
 .claude/
+.superset/
 CLAUDE.md
 
 # Variáveis de ambiente locais (o setup do Superset copia da raiz)

.superset/config.json

@@ -1,5 +0,0 @@
-{
-  "setup": ["./.superset/setup.sh"],
-  "teardown": ["./.superset/teardown.sh"],
-  "run": ["cargo run -p guara-cli -- ui --no-open"]
-}

.superset/setup.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-# Runs once when a Superset workspace (git worktree) is created. Safe to run again.
-set -euo pipefail
-
-# Local files that are not tracked by git but that a new worktree needs.
-# Nothing is overwritten if it already exists in the workspace.
-if [ -n "${SUPERSET_ROOT_PATH:-}" ] && [ -d "$SUPERSET_ROOT_PATH" ]; then
-  for f in "$SUPERSET_ROOT_PATH"/.env "$SUPERSET_ROOT_PATH"/.env.* "$SUPERSET_ROOT_PATH"/CLAUDE.md; do
-    [ -f "$f" ] || continue
-    dest="./$(basename "$f")"
-    [ -e "$dest" ] || cp "$f" "$dest"
-  done
-fi
-
-# Download the crates now so the first build and the first test run do not wait on the network.
-cargo fetch --locked

.superset/teardown.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-# Runs when a Superset workspace is deleted.
-# Setup starts no background service. The only long-running process is the Run command
-# (`guara ui`), which this workspace builds into its own target/ directory, so stop any
-# copy that is still alive before the worktree is removed.
-set -uo pipefail
-
-pkill -f -- "$PWD/target/.*/guara ui" 2>/dev/null || true
-exit 0

CHANGELOG.md

@@ -4,6 +4,55 @@
 
 Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow SemVer.
 
+## [1.3.1] - 2026-10-23
+
+### Changed
+- **New official logo:** the maned wolf (guará) inside the orange ring, drawn by the project's author, with a transparent background so the same art works in the light and dark themes. It replaces the old track-disc logo in the app (sidebar, top bar and home screen), the favicon, the desktop app icons and the README.
+- `guara ui` serves the new `guara.png` and `guara-s.png`; `scripts/gerar-logo.py` derives the small logo and the app icon from the official art.
+- Development: `scripts/verificar.sh` runs locally what the CI runs, with an optional pre-push hook (`scripts/instalar-hooks.sh`), and the CI no longer runs on documentation-only changes.
+
+### Notes
+- No change to scanning, recovery, signing or any other behavior. This is the first release after the in-app updater: an app on 1.3.0 should offer **Update now**.
+- The screenshots in `docs/img/` still show the old logo and will be redone.
+
+## [1.3.0] - 2026-10-23
+
+### Added
+- **Update from inside the desktop app.** On startup the app asks GitHub for the release's `latest.json`; if there is a newer version, a card offers **Update now**. It downloads the package, verifies its minisign signature against the public key built into the app, installs and reopens (the AppImage is replaced in place; Windows and macOS use the installer). Installs from `.deb` or `.rpm` only show the notice. **Settings** can turn the startup check off and has a **Check now** button. The check is one HTTP request and sends nothing of yours.
+- **Digital signatures (Ed25519):** `guara sign keygen | file | verify | recovery`. With a key configured, `recover` and `report` sign the manifest and the report by themselves. `guara sign recovery` checks the manifest signature and the hash of every recovered file (and refuses manifest paths that leave the folder). The signature is plain Ed25519 over a documented message, so `openssl` verifies it too. Comparing the key fingerprint (`--trust`) says whose key it is; the signed time is the local clock, not a third-party timestamp.
+- **Virtual disks:** QCOW2 with a backing file, VMDK snapshots (parent by name or, in VirtualBox, by UUID; the child is refused if the parent's CID changed) and DMG with LZFSE chunks.
+- **CI with real reference images** on Linux, macOS and Windows (they were skipped before), and an XFS image deleted by the real kernel generated with `sudo` on the Linux runner.
+- Release pipeline: update packages are signed with a key kept in the repository's `release` environment (tags `v*` only), and `latest.json` is built in one step by `scripts/make-latest-json.py`.
+
+### Changed
+- **XFS is now 🟡.** On a real XFS (v5, kernel deletion) the inode and extent list are wiped, so the metadata path finds nothing; the content of files with a recognizable structure comes back by carving, without name or folder. The earlier path only worked on simulated deletions. The name-and-folder test is kept `ignore`d until the journal is read.
+- CI `apt` steps use cached `.deb`s, a time limit per attempt and retries (they took up to 28 minutes on a slow mirror day).
+- Dependencies: `ctutils` 0.4.5 (RUSTSEC-2026-0385); new `ed25519-compact`, `lzfse_rust`, `tauri-plugin-updater`.
+- The README and ROADMAP now say the update check is the only network use by default.
+
+### Notes
+- Versions before 1.3.0 do not have the updater: from 1.2.0, replace the AppImage by hand one last time. The first update inside the app is 1.3.0 to the next release.
+- Still missing: password-protected DMG, an identity check for VHD, VHDX and QCOW2 parents, third-party timestamps (RFC 3161), XFS journal reading, and APFS validation with real deletion (needs an image from a real Mac).
+- CLI output remains in Portuguese.
+
+## [1.2.0] - 2026-10-22
+
+### Added
+- **Virtual disk containers (read-only):** QCOW2 (v2 and v3, compressed clusters with deflate or zstd), VMDK (sparse, `streamOptimized`, and text descriptors with flat and zero extents), VHD and VHDX (fixed, dynamic and differencing, following the parent chain) and DMG (UDIF with zero, raw, ADC, zlib and bzip2 chunks). They open through the same path as E01 and AFF4, so partitions, file systems and encrypted volumes work inside them. Images that would read wrong are refused with the reason: QCOW2 with a backing file or encryption, VMDK with a parent or in SEsparse, password-protected DMG, DMG with LZFSE chunks. The VHDX log is not replayed.
+- **Audit trail** (`auditoria.jsonl`, `guara audit`): every action on evidence (`inspect`, `scan`, `recover`, `image`, `hash`, `search`, `verify`, exports and sessions) is recorded with UTC time, system user, host, version and details, chained by SHA-256. `guara audit --verify` reports the entry where the chain breaks. Set `GUARA_EXAMINER` to record the examiner; passwords and keys are never written.
+- **PDF report:** `guara report out.pdf` (and the interface's report button, by file extension) writes an A4 PDF with the same sections as the HTML, using a built-in writer with the standard fonts and no new dependency. Both formats now show the audit trail status and the hash of its last entry.
+- **APFS free-space map:** the container's space manager (spaceman), chunk-info blocks and bitmaps are read, so deep scans of an APFS volume cover only unallocated blocks. Containers that use chunk-info address blocks fall back to the whole volume, with a warning.
+- `scripts/fetch-testdata.sh` also downloads the dfvfs virtual disk images used by the container tests.
+
+### Changed
+- The APFS partition warning no longer says metadata is unsupported; it says the free-space map is read and that encrypted (FileVault) volumes need the key.
+- The interface's report dialog explains that the file extension chooses PDF or HTML.
+
+### Notes
+- Containers were checked by hash against an independent reader (7-Zip) on real images from dfvfs and VirtualBox, including differencing VHD and VHDX; the small fixtures in `tests/fixtures/vdisk` run in CI.
+- APFS deletion is still tested only in simulation, so APFS stays 🟡 in the roadmap.
+- CLI output remains in Portuguese.
+
 ## [1.1.0] - 2026-10-20
 
 ### Added

CHANGELOG.pt-BR.md

@@ -4,6 +4,55 @@
 
 Formato baseado em [Keep a Changelog](https://keepachangelog.com/pt-BR/1.1.0/); versões seguem SemVer.
 
+## [1.3.1] - 2026-10-23
+
+### Alterado
+- **Logo oficial nova:** o guará dentro do anel laranja, desenhado pelo autor do projeto, com fundo transparente para a mesma arte servir aos temas claro e escuro. Ela substitui a logo antiga das trilhas de disco no app (barra lateral, topo e tela inicial), no favicon, nos ícones do app desktop e no README.
+- O `guara ui` serve os novos `guara.png` e `guara-s.png`; o `scripts/gerar-logo.py` deriva a logo pequena e o ícone do app da arte oficial.
+- Desenvolvimento: o `scripts/verificar.sh` roda localmente o que o CI roda, com um hook opcional de pre-push (`scripts/instalar-hooks.sh`), e o CI deixa de rodar em mudanças só de documentação.
+
+### Notas
+- Nenhuma mudança na varredura, na recuperação, na assinatura ou em qualquer outro comportamento. É a primeira versão depois do atualizador do app: um app na 1.3.0 deve oferecer **Atualizar agora**.
+- Os screenshots em `docs/img/` ainda mostram a logo antiga e serão refeitos.
+
+## [1.3.0] - 2026-10-23
+
+### Adicionado
+- **Atualização dentro do app desktop.** Ao abrir, o app pede ao GitHub o `latest.json` da release; havendo versão nova, um cartão oferece **Atualizar agora**. Ele baixa o pacote, confere a assinatura minisign com a chave pública embutida no app, instala e reabre (o AppImage é substituído no lugar; Windows e macOS usam o instalador). Instalações por `.deb` ou `.rpm` só mostram o aviso. **Configurações** desliga a consulta ao abrir e tem o botão **Verificar agora**. A consulta é uma requisição HTTP e não envia nada seu.
+- **Assinatura digital (Ed25519):** `guara sign keygen | file | verify | recovery`. Com uma chave configurada, `recover` e `report` assinam sozinhos o manifesto e o relatório. `guara sign recovery` confere a assinatura do manifesto e o hash de cada arquivo recuperado (e recusa caminhos do manifesto que saem da pasta). É Ed25519 comum sobre uma mensagem documentada, então o `openssl` também confere. Comparar a impressão digital da chave (`--trust`) diz de quem ela é; a hora assinada é a do relógio local, não um carimbo de terceiros.
+- **Discos virtuais:** QCOW2 com arquivo de apoio, snapshots de VMDK (pai por nome ou, no VirtualBox, por UUID; o filho é recusado se o CID do pai mudou) e DMG com chunks LZFSE.
+- **CI com imagens de referência reais** em Linux, macOS e Windows (antes eram puladas) e uma imagem XFS apagada pelo kernel de verdade, gerada com `sudo` no runner Linux.
+- Pipeline de release: os pacotes de atualização são assinados com uma chave guardada no ambiente `release` do repositório (só tags `v*`), e o `latest.json` é montado de uma vez por `scripts/make-latest-json.py`.
+
+### Alterado
+- **O XFS passa a 🟡.** Num XFS real (v5, exclusão do kernel) o inode e a lista de extensões são zerados, então o caminho por metadados não acha nada; o conteúdo de arquivos com estrutura reconhecível volta por carving, sem nome nem pasta. O caminho anterior só funcionava na exclusão simulada. O teste de nome e pasta fica `ignore`d até o diário ser lido.
+- Os passos de `apt` do CI usam `.deb` em cache, tempo limite por tentativa e nova tentativa (levavam até 28 minutos num dia de espelho lento).
+- Dependências: `ctutils` 0.4.5 (RUSTSEC-2026-0385); novas `ed25519-compact`, `lzfse_rust` e `tauri-plugin-updater`.
+- O README e o ROADMAP passam a dizer que a verificação de atualização é o único uso da rede por padrão.
+
+### Notas
+- As versões anteriores à 1.3.0 não têm o atualizador: da 1.2.0, troque o AppImage à mão uma última vez. A primeira atualização dentro do app é da 1.3.0 para a próxima versão.
+- Ainda faltam: DMG com senha, conferência da identidade do pai em VHD, VHDX e QCOW2, carimbo de tempo de terceiros (RFC 3161), leitura do diário do XFS e validação de APFS com exclusão real (precisa de imagem de um Mac de verdade).
+- A saída da CLI continua em português.
+
+## [1.2.0] - 2026-10-22
+
+### Adicionado
+- **Contêineres de disco virtual (somente leitura):** QCOW2 (v2 e v3, clusters comprimidos com deflate ou zstd), VMDK (esparso, `streamOptimized` e descritores de texto com extensões flat e zero), VHD e VHDX (fixo, dinâmico e diferencial, seguindo a cadeia de pais) e DMG (UDIF com chunks zerados, brutos, ADC, zlib e bzip2). Abrem pelo mesmo caminho do E01 e do AFF4, então partições, sistemas de arquivos e volumes cifrados funcionam dentro deles. Imagens que seriam lidas errado são recusadas com o motivo: QCOW2 com arquivo de apoio ou cifrado, VMDK com pai ou em SEsparse, DMG protegido por senha, DMG com chunks LZFSE. O log do VHDX não é reproduzido.
+- **Trilha de auditoria** (`auditoria.jsonl`, `guara audit`): toda ação sobre a evidência (`inspect`, `scan`, `recover`, `image`, `hash`, `search`, `verify`, exportações e sessões) é registrada com hora UTC, usuário do sistema, máquina, versão e detalhes, encadeada por SHA-256. `guara audit --verify` aponta a entrada onde a cadeia quebra. Defina `GUARA_EXAMINER` para registrar o perito; senhas e chaves nunca são gravadas.
+- **Relatório em PDF:** `guara report saida.pdf` (e o botão de relatório da interface, pela extensão do arquivo) gera um PDF A4 com as mesmas seções do HTML, com gerador próprio, fontes padrão e nenhuma dependência nova. Os dois formatos passam a mostrar a situação da trilha de auditoria e o hash da última entrada.
+- **Mapa de espaço livre do APFS:** o gerenciador de espaço do contêiner (spaceman), os chunk-info blocks e os bitmaps são lidos, e a varredura profunda de um volume APFS cobre só os blocos não alocados. Contêineres que usam blocos de endereço de chunk-info voltam a varrer o volume todo, com aviso.
+- `scripts/fetch-testdata.sh` também baixa as imagens de disco virtual do dfvfs usadas nos testes dos contêineres.
+
+### Alterado
+- O aviso da partição APFS deixa de dizer que não há suporte a metadados; informa que o mapa de espaço livre é lido e que volumes cifrados (FileVault) precisam da chave.
+- O diálogo de relatório da interface explica que a extensão do arquivo escolhe PDF ou HTML.
+
+### Notas
+- Os contêineres foram conferidos por hash contra um leitor independente (7-Zip) em imagens reais do dfvfs e do VirtualBox, inclusive VHD e VHDX diferenciais; os fixtures pequenos de `tests/fixtures/vdisk` rodam no CI.
+- A exclusão no APFS continua testada só em simulação, por isso o APFS segue 🟡 no roadmap.
+- A saída da CLI continua em português.
+
 ## [1.1.0] - 2026-10-20
 
 ### Adicionado

CONTRIBUTING.md

@@ -11,15 +11,19 @@ Thanks for helping! Golden rules:
 ## Workflow
 
 ```bash
-cargo fmt --all
-cargo clippy --workspace --all-targets
-cargo test --workspace
+scripts/instalar-hooks.sh        # uma vez: roda a verificação rápida antes de cada push
+scripts/verificar.sh             # rápido (segundos): fmt, clippy como no CI, tradução, scripts, workflows
+scripts/verificar.sh --completo  # inclui cargo test --workspace e cargo audit
 ```
 
+The CI takes 5 to 30 minutes on three systems, so run the check before pushing: almost everything that makes the CI fail shows up locally in seconds. Documentation-only changes (`*.md`, `docs/`) skip the CI.
+
 On Linux the tests build images with `mtools`, `ntfs-3g`, `e2fsprogs`, `exfatprogs`, `imagemagick`, `zip` and `python3`. Without these tools the image tests are skipped (set `GUARA_REQUIRE_FIXTURES=1` to make them fail).
 
 For the external reference images (BitLocker, FileVault 2, dfvfs, AFF4), run `scripts/fetch-testdata.sh`; without them those tests are skipped. The BitLocker test takes about 75 s.
 
+The desktop app signs its update packages: `tauri.conf.json` has `createUpdaterArtifacts` on, so a local `tauri build` needs `TAURI_SIGNING_PRIVATE_KEY` (any key made with `tauri signer generate`; the release key lives only in the repository secrets). For a quick local bundle, pass `--config '{"bundle":{"createUpdaterArtifacts":false}}'`.
+
 ## Where to make changes
 
 A map of the modules is in [docs/architecture.md](docs/architecture.md). What is missing and what is welcome is in the [ROADMAP](ROADMAP.md).

CONTRIBUTING.pt-BR.md

@@ -11,15 +11,19 @@ Obrigado por ajudar! Regras de ouro:
 ## Fluxo
 
 ```bash
-cargo fmt --all
-cargo clippy --workspace --all-targets
-cargo test --workspace
+scripts/instalar-hooks.sh        # uma vez: roda a verificação rápida antes de cada push
+scripts/verificar.sh             # rápido (segundos): fmt, clippy como no CI, tradução, scripts, workflows
+scripts/verificar.sh --completo  # inclui cargo test --workspace e cargo audit
 ```
 
+O CI leva de 5 a 30 minutos em três sistemas, então rode a verificação antes do push: quase tudo que faz o CI falhar aparece aqui em segundos. Mudanças só de documentação (`*.md`, `docs/`) pulam o CI.
+
 No Linux os testes geram imagens com `mtools`, `ntfs-3g`, `e2fsprogs`, `exfatprogs`, `imagemagick`, `zip` e `python3`. Sem essas ferramentas os testes com imagem são ignorados (defina `GUARA_REQUIRE_FIXTURES=1` para falhar).
 
 Para as imagens de referência externas (BitLocker, FileVault 2, dfvfs, AFF4), rode `scripts/fetch-testdata.sh`; sem elas esses testes são pulados. O teste de BitLocker leva cerca de 75 s.
 
+O app desktop assina os pacotes de atualização: o `tauri.conf.json` tem `createUpdaterArtifacts` ligado, então um `tauri build` local precisa de `TAURI_SIGNING_PRIVATE_KEY` (qualquer chave feita com `tauri signer generate`; a chave da release fica só nos segredos do repositório). Para um pacote local rápido, passe `--config '{"bundle":{"createUpdaterArtifacts":false}}'`.
+
 ## Onde mexer
 
 Mapa dos módulos em [docs/pt-BR/arquitetura.md](docs/pt-BR/arquitetura.md). O que falta e o que é bem-vindo está no [ROADMAP](ROADMAP.pt-BR.md).

Cargo.lock

@@ -309,9 +309,9 @@ dependencies = [
 
 [[package]]
 name = "ctutils"
-version = "0.4.3"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03bb0e1cc970d482d121d9a1744999169b69a07470b3d644a7894e53fcaf4574"
+checksum = "38d28fb6aa7dd680b3ffd1a3e64e115c177bdba63c0ae7f9cd48129ff05c4fa0"
 dependencies = [
  "cmov",
 ]
@@ -340,6 +340,15 @@ dependencies = [
  "objc2",
 ]
 
+[[package]]
+name = "ed25519-compact"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1454db4f2edb7f0e8fe0c5b375b0c978fc63244cc9f010d160e417eb10139aa8"
+dependencies = [
+ "getrandom",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.3"
@@ -389,8 +398,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -405,7 +416,7 @@ dependencies = [
 
 [[package]]
 name = "guara-cli"
-version = "1.1.0"
+version = "1.3.1"
 dependencies = [
  "clap",
  "ctrlc",
@@ -418,11 +429,12 @@ dependencies = [
 
 [[package]]
 name = "guara-core"
-version = "1.1.0"
+version = "1.3.1"
 dependencies = [
  "aes",
  "argon2",
  "bzip2",
+ "ed25519-compact",
  "flate2",
  "hmac",
  "image",
@@ -430,6 +442,7 @@ dependencies = [
  "jpeg-encoder",
  "libc",
  "lz4_flex",
+ "lzfse_rust",
  "md-5",
  "mp4",
  "pbkdf2",
@@ -548,9 +561,19 @@ checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"
 
 [[package]]
 name = "jpeg-encoder"
-version = "0.6.1"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b454d911ac55068f53495488d8ccd0646eaa540c033a28ee15b07838afafb01f"
+checksum = "a0370574b86f7eca156b9f298392b5e69a23f8c86f3f865add60bbc2e79467a6"
+
+[[package]]
+name = "js-sys"
+version = "0.3.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen",
+]
 
 [[package]]
 name = "libbz2-rs-sys"
@@ -578,9 +601,15 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.6"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "373f5eceeeab7925e0c1098212f2fbc4d416adec9d35051a6ab251e824c1854a"
+checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226"
+
+[[package]]
+name = "lzfse_rust"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5edeac3ec657925dececc672bdd58fa2212291886ddcb3e08aa46924c78340c6"
 
 [[package]]
 name = "md-5"
@@ -844,6 +873,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
 [[package]]
 name = "ruzstd"
 version = "0.9.1"
@@ -1053,6 +1088,51 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.9",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.129"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
+dependencies = [
+ "unicode-ident",
+]
+
 [[package]]
 name = "weezl"
 version = "0.1.12"

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/guara-core", "crates/guara-cli"]
 
 [workspace.package]
-version = "1.1.0"
+version = "1.3.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/lucasrguerra/guara"

README.md

@@ -1,4 +1,4 @@
-<p align="center"><img src="apps/gui/ui/guara-logo.svg" width="360" alt="Guará"></p>
+<p align="center"><img src="apps/gui/ui/guara.png" width="300" alt="Guará"></p>
 <h1 align="center">Guará</h1>
 <p align="center">Free file recovery for hard drives, SSDs and USB sticks.<br>Terminal and graphical interface · Windows, Linux and macOS · read-only on the source.</p>
 
@@ -12,12 +12,12 @@
 
 In a single scan, Guará does what tools like Recuva, PhotoRec, TestDisk and Disk Drill do separately:
 
-- **File system metadata:** finds deleted files **with name, folder and date** on NTFS, FAT12/16/32, exFAT, ext2/3/4, HFS+, Btrfs, XFS and APFS.
+- **File system metadata:** finds deleted files **with name, folder and date** on NTFS, FAT12/16/32, exFAT, ext2/3/4, HFS+, Btrfs and APFS (on XFS only the content comes back, by carving, see below).
 - **Structure-aware carving** in free space, damaged partitions and unpartitioned space. The detectors read the real structure of dozens of formats to learn the **exact size** and a **confidence** level.
 - **Encrypted volumes:** opens BitLocker, LUKS and FileVault 2 with your password or key and scans inside.
 - **RAID and LVM:** reassembles arrays from loose disks (RAID 0, 1, 4, 5, 6, 10, LVM2), working out level, stripe size and order by itself when there is no metadata.
 - **Fragmented files:** reassembles JPEGs stored in pieces and rebuilds the index of MP4/MOV videos that lost their `moov`.
-- **Forensic images:** reads and writes raw images, **E01/Ex01** and **AFF4**.
+- **Forensic images:** reads and writes raw images, **E01/Ex01** and **AFF4**, and reads **QCOW2, VMDK, VHD, VHDX** and **DMG** virtual disks.
 - **Lost partitions:** reads MBR/GPT and searches for volumes by signature where the table failed.
 - **Merge without duplicates:** a file found by more than one method appears once, with the best evidence.
 - **Per-file confidence** (high, medium, low): intact structure, reused clusters, zeroed content (TRIM) or content that does not match the extension.
@@ -44,6 +44,8 @@ Download the package for your system from **[Releases](../../releases)**:
 
 Every file has a `.sha256` next to it. To build from source: `cargo build --release -p guara-cli` (Rust 1.80+).
 
+**Updates:** the desktop app (AppImage, Windows and macOS) checks GitHub for a newer version when it opens; if there is one, a card offers **Update now**: it downloads, verifies the package signature, installs and reopens, so you no longer swap the AppImage by hand. The check is a single request for the release's `latest.json` and nothing of yours is sent; turn it off in **Settings**. Installs from `.deb`/`.rpm` only show the notice, because the package manager owns those files.
+
 > The binaries are **not signed yet**: Windows SmartScreen and macOS Gatekeeper will warn you. Check the SHA-256.
 
 Reading raw disks requires privileges: **administrator** (Windows), `sudo` (Linux and macOS). Even as root, Guará writes sessions, reports and recovered files with the owner and permissions of the user who launched it.
@@ -91,14 +93,14 @@ A desktop app (Tauri) in the style of a file manager, designed for when Guará f
 - **Automatic sessions** and reconnection: Guará recognizes the same disk coming back under another name.
 - **Duplicate detection** by content signature.
 
-> **Warning:** Guará has **not been externally validated** yet (for example, in the NIST CFTT tests) and has no audit log or signed report. It is well suited to recovery and triage; for use in court, check the results by other means. The path to get there is in the [ROADMAP](ROADMAP.md).
+> **Warning:** Guará has **not been externally validated** yet (for example, in the NIST CFTT tests) and has no trusted timestamp (RFC 3161) on its signatures. It is well suited to recovery and triage; for use in court, check the results by other means. The path to get there is in the [ROADMAP](ROADMAP.md).
 
 ## Known limits
 
 - **Overwritten data does not come back.** On an SSD with TRIM the disk may zero deleted blocks; Guará warns you, but it cannot work miracles.
 - **Fragments:** only JPEG (up to three pieces) and MP4 without an index are reassembled. Other formats, if fragmented, come out truncated with low confidence.
 - **ReFS and Storage Spaces** are not supported (ReFS is only detected).
-- **APFS:** no free-space map. **XFS and APFS:** deletion recovery tested only in simulation.
+- **XFS:** on a real XFS (v5, kernel deletion) the inode and its extent list are wiped, so Guará recovers the **content** of files with a recognizable structure by carving, but not their name or folder; reading names needs the file system journal, which is not implemented. The old inode-based path only works on simulated deletions. **APFS:** deletion recovery tested only in simulation.
 - **NTFS:** compressed files, EFS and heavily fragmented records are skipped or marked as incomplete.
 - **exFAT:** validated with a synthetic image; real media are still missing.
 - **Phones:** Guará works with storage media and does **not** unlock devices or bypass passwords.
@@ -111,8 +113,8 @@ Summary of the [ROADMAP](ROADMAP.md):
 
 | | |
 |---|---|
-| **Done** | Metadata from 8 file systems, BitLocker, LUKS, FileVault 2, RAID, LVM, E01, Ex01, AFF4, fragmented JPEG, MP4 without an index, SQLite reader, SMART |
-| **Next** | Audit log, signed and PDF report, APFS free map, tests on Windows and macOS |
+| **Done** | Metadata from 8 file systems, BitLocker, LUKS, FileVault 2, RAID, LVM, E01, Ex01, AFF4, fragmented JPEG, MP4 without an index, SQLite reader, SMART, QCOW2/VMDK/VHD/VHDX/DMG, hash-chained audit trail, PDF report, Ed25519 signatures, APFS free map |
+| **Next** | Trusted timestamps (RFC 3161), tests on Windows and macOS |
 | **Later** | NSRL and hash lists, content search, unified timeline, browser interpretation, Windows registry and messaging apps, dictionary and brute-force attacks on encrypted volumes |
 | **No reference image** | ReFS and Storage Spaces: they only land with validation |
 | **Long term** | iOS and Android backups (iTunes, ADB), OCR, NIST CFTT validation, physical phone access through bootloader/chip exploits |

README.pt-BR.md

@@ -1,4 +1,4 @@
-<p align="center"><img src="apps/gui/ui/guara-logo.svg" width="360" alt="Guará"></p>
+<p align="center"><img src="apps/gui/ui/guara.png" width="300" alt="Guará"></p>
 <h1 align="center">Guará</h1>
 <p align="center">Recuperação de arquivos livre e gratuita para HD, SSD e pendrive.<br>Terminal e interface gráfica · Windows, Linux e macOS · somente leitura na origem.</p>
 
@@ -17,7 +17,7 @@ O Guará junta, numa única varredura, o que ferramentas como Recuva, PhotoRec,
 - **Volumes cifrados:** abre BitLocker, LUKS e FileVault 2 com a sua senha ou chave e varre por dentro.
 - **RAID e LVM:** remonta arrays a partir de discos soltos (RAID 0, 1, 4, 5, 6, 10, LVM2), descobrindo nível, faixa e ordem sozinho quando não há metadados.
 - **Arquivos fragmentados:** remonta JPEG em pedaços e refaz o índice de vídeos MP4/MOV sem `moov`.
-- **Imagens forenses:** lê e grava imagem bruta, **E01/Ex01** e **AFF4**.
+- **Imagens forenses:** lê e grava imagem bruta, **E01/Ex01** e **AFF4**, e lê discos virtuais **QCOW2, VMDK, VHD, VHDX** e **DMG**.
 - **Partições perdidas:** lê MBR/GPT e procura volumes por assinatura onde a tabela falhou.
 - **Fusão sem duplicatas:** um arquivo achado por mais de um método aparece uma vez, com a melhor evidência.
 - **Confiança por arquivo** (alta, média, baixa): estrutura íntegra, clusters reutilizados, conteúdo zerado (TRIM) ou que não confere com a extensão.
@@ -44,6 +44,8 @@ Baixe o pacote do seu sistema em **[Releases](../../releases)**:
 
 Cada arquivo tem um `.sha256` ao lado. Compilar do código: `cargo build --release -p guara-cli` (Rust 1.80+).
 
+**Atualizações:** o app desktop (AppImage, Windows e macOS) consulta o GitHub ao abrir; havendo versão nova, um cartão oferece **Atualizar agora**: ele baixa, confere a assinatura do pacote, instala e reabre, e você deixa de trocar o AppImage na mão. A consulta é uma única requisição ao `latest.json` da release e nada seu é enviado; desligue em **Configurações**. Instalações por `.deb`/`.rpm` só mostram o aviso, porque quem manda nesses arquivos é o gerenciador de pacotes.
+
 > Os binários ainda **não são assinados**: o Windows SmartScreen e o Gatekeeper do macOS vão avisar. Confira o SHA-256.
 
 Ler discos brutos exige privilégios: **administrador** (Windows), `sudo` (Linux e macOS). Mesmo como root, o Guará grava sessões, relatórios e arquivos recuperados com o dono e as permissões do usuário que o abriu.
@@ -91,7 +93,7 @@ App desktop (Tauri) no estilo de um gerenciador de arquivos, pensado para quando
 - **Sessões automáticas** e reconexão: o Guará reconhece o mesmo disco que volta com outro nome.
 - **Detecção de duplicadas** por assinatura de conteúdo.
 
-> **Atenção:** o Guará ainda **não foi validado externamente** (por exemplo, nos testes do NIST CFTT) e não tem registro de auditoria nem relatório assinado. Serve bem para recuperação e triagem; para uso em juízo, confira os resultados por outro meio. O caminho para isso está no [ROADMAP](ROADMAP.pt-BR.md).
+> **Atenção:** o Guará ainda **não foi validado externamente** (por exemplo, nos testes do NIST CFTT) e suas assinaturas não têm carimbo de tempo de terceiros (RFC 3161). Serve bem para recuperação e triagem; para uso em juízo, confira os resultados por outro meio. O caminho para isso está no [ROADMAP](ROADMAP.pt-BR.md).
 
 ## Limites conhecidos
 
@@ -111,8 +113,8 @@ Resumo do [ROADMAP](ROADMAP.pt-BR.md):
 
 | | |
 |---|---|
-| **Feito** | Metadados de 8 sistemas de arquivos, BitLocker, LUKS, FileVault 2, RAID, LVM, E01, Ex01, AFF4, JPEG fragmentado, MP4 sem índice, leitor de SQLite, SMART |
-| **Próximo** | Registro de auditoria, relatório assinado e em PDF, mapa livre do APFS, testes em Windows e macOS |
+| **Feito** | Metadados de 8 sistemas de arquivos, BitLocker, LUKS, FileVault 2, RAID, LVM, E01, Ex01, AFF4, JPEG fragmentado, MP4 sem índice, leitor de SQLite, SMART, QCOW2/VMDK/VHD/VHDX/DMG, trilha de auditoria encadeada por hash, relatório em PDF, assinaturas Ed25519, mapa livre do APFS |
+| **Próximo** | Carimbo de tempo de terceiros (RFC 3161), testes em Windows e macOS |
 | **Depois** | NSRL e listas de hashes, busca em conteúdo, linha do tempo unificada, interpretação de navegadores, registro do Windows e apps de mensagem, ataque de dicionário e força bruta a volumes cifrados |
 | **Sem imagem de referência** | ReFS e Storage Spaces: só entram com validação |
 | **Longo prazo** | Backups de iOS e Android (iTunes, ADB), OCR, validação NIST CFTT, acesso físico a celulares por exploit de bootloader/chip |

ROADMAP.md

@@ -11,7 +11,7 @@ Legend: ✅ done · 🟡 partial · 🔜 planned · 🔭 long-term idea · ⛔ o
 1. **The source is read-only.** Nothing in the core writes to the device being recovered.
 2. **Do not ship without validating.** A feature only lands with a test against a real or reference image. That is why ReFS and Storage Spaces do not exist yet: there is no reference image to check against.
 3. **Honest confidence.** If the content could not be checked, confidence is low or medium, never high.
-4. **Free and auditable.** Open source (MIT or Apache-2.0), no telemetry, and every result can be reproduced.
+4. **Free and auditable.** Open source (MIT or Apache-2.0), no telemetry (the only thing that touches the network by default is the update check, a single request you can turn off), and every result can be reproduced.
 
 ## History
 
@@ -26,10 +26,13 @@ Legend: ✅ done · 🟡 partial · 🔜 planned · 🔭 long-term idea · ⛔ o
 | 1.0.0 | 2026-10-19 | ext4, HFS+, Btrfs, XFS, APFS; BitLocker, LUKS, FileVault 2; RAID and LVM; E01, Ex01, AFF4; fragmented JPEG; MP4 without moov |
 | 1.0.1 | 2026-10-20 | Documentation in English with Portuguese translations, complete English interface, screenshots, Docker image of the CLI |
 | 1.1.0 | 2026-10-20 | Core messages and dates in English, automated translation check, RustCrypto on digest 0.11, verified Docker device access and Superset workspaces |
+| 1.2.0 | 2026-10-22 | QCOW2, VMDK, VHD, VHDX and DMG virtual disks, hash-chained audit trail, PDF report, APFS free-space map |
+| 1.3.0 | 2026-10-23 | Update from inside the app, Ed25519 signatures, differencing QCOW2/VMDK and LZFSE DMG, reference images tested on Linux, macOS and Windows, XFS real-deletion test |
+| 1.3.1 | 2026-10-23 | New official logo |
 
 Details of each version in the [CHANGELOG](CHANGELOG.md).
 
-## Current status (1.1.0) against what is expected from a forensic suite
+## Current status (1.3.1) against what is expected from a forensic suite
 
 ### 1. File systems with metadata
 
@@ -39,12 +42,13 @@ Details of each version in the [CHANGELOG](CHANGELOG.md).
 | ext2/3/4 | ✅ | Deleted inodes and old copies in the journal |
 | HFS+ | ✅ | Tree node leftovers and journal |
 | Btrfs | ✅ | Old versions of the trees; zlib, zstd and lzo extents |
-| XFS | ✅ | Freed inodes and names of freed entries. Tested only with simulated deletion |
-| APFS | 🟡 | Container, object map, snapshots and old nodes. **Free-space map is missing**; deletion tested only in simulation |
+| XFS | 🟡 | Freed inodes and names of freed entries work on simulated deletion only. With real kernel deletion (tested in CI) the metadata is wiped: content comes back by carving, names do not. **Journal reading is missing** |
+| APFS | 🟡 | Container, object map, free-space map (spaceman and bitmaps), snapshots and old nodes. Deletion tested only in simulation; containers with chunk-info address blocks (large ones) fall back to scanning the whole volume |
 | ReFS | 🔜 | Only detected today; recovery depends on carving. Reference image missing |
 | Storage Spaces | 🔜 | Not done. Reference image missing |
 | NTFS: compressed attributes, EFS, attribute list | 🔜 | Marked as incomplete today |
-| XFS and APFS validation with real deletion | 🔜 | Replace the simulation with images from real devices |
+| XFS: names and folders after real deletion (read the journal) | 🔜 | The CI test exists and is ignored until this lands |
+| APFS validation with real deletion | 🔜 | Needs an image from a real Mac |
 
 ### 2. Encrypted volumes
 
@@ -66,7 +70,9 @@ Today Guará opens volumes when you **already have** the password or key. Passwo
 | Raw image (dd) tolerant of bad sectors, with an error map | ✅ |
 | E01 and Ex01: read, write and `guara verify` | ✅ |
 | AFF4: read and write | ✅ |
-| Other containers (VMDK, VHD/VHDX, QCOW2, DMG) | 🔜 |
+| Virtual disk containers: QCOW2, VMDK, VHD, VHDX and DMG (read) | ✅ |
+| QCOW2 with a backing file, VMDK snapshots (by name or VirtualBox UUID), DMG with LZFSE | ✅ |
+| Password-protected DMG, parent identity check for VHD, VHDX and QCOW2 | 🔜 |
 | Mobile device image (see item 7) | 🔭 |
 
 ### 4. Assembling loose disks
@@ -126,10 +132,11 @@ Physical access is the differentiator of commercial tools like Cellebrite. It de
 | `guara-manifesto.json` manifest in every recovery | ✅ |
 | HTML report with case, examiner, source, partitions, summary and hashes | ✅ |
 | Verification of an E01/Ex01 image against the stored hash | ✅ |
-| **Audit log** of every examiner action (who, when, what) | 🔜 |
-| **Digitally signed reports** and a timestamped manifest | 🔜 |
+| **Audit trail** of every examiner action (who, when, what), chained by hash, with `guara audit --verify` | ✅ |
+| **Digital signatures** (Ed25519) of manifests, reports and any file; `guara sign recovery` checks a whole recovery folder | ✅ |
+| Trusted timestamp (RFC 3161) on signatures | 🔜 |
 | **Reproducibility:** replay the recorded procedure and get the same result | 🔜 |
-| PDF report | 🔜 |
+| PDF report (A4, built in) | ✅ |
 | **External validation:** NIST CFTT (Computer Forensic Tool Testing) tests and publication of the results | 🔭 |
 | Signed binaries (Windows and macOS) | 🔜 |
 
@@ -153,7 +160,8 @@ External validation is what makes a report accepted. Without it, Guará is good
 |---|---|
 | CLI and interface for Windows, Linux and macOS | ✅ |
 | CI on three systems, automatic release by tag | ✅ |
-| Tests with real images on Windows and macOS (Linux only today) | 🔜 |
+| Tests with real reference images on Linux, macOS and Windows | ✅ |
+| Update from inside the desktop app (signed packages, one click) | ✅ |
 | GUI: privileged helper process instead of restarting the whole app as administrator | 🔜 |
 | Signed and notarized binaries | 🔜 |
 | Packages in package managers (winget, Homebrew, Flatpak) | 🔭 |
@@ -162,17 +170,17 @@ External validation is what makes a report accepted. Without it, Guará is good
 
 No dates, in the order that makes the most sense.
 
-**1.1: trust and custody**
-Audit log, PDF report, signed manifest, APFS free-space map, XFS and APFS validation with real deletions, tests with real images on Windows and macOS.
+**1.4: trust and custody**
+Trusted timestamps, XFS journal reading, APFS validation with real deletions.
 
-**1.2: analysis**
+**1.5: analysis**
 NSRL and hash lists, search in file content, unified timeline.
 
-**1.3: artifacts**
+**1.6: artifacts**
 Windows registry, browsers, EVTX and the most common messaging apps, built on the SQLite reader.
 
-**1.4: more structure**
-ReFS and Storage Spaces (once there is a reference image), other image containers (VMDK, VHD, QCOW2), expanded fragmented carving.
+**1.7: more structure**
+ReFS and Storage Spaces (once there is a reference image), password-protected DMG, identity check of VHD, VHDX and QCOW2 parents, expanded fragmented carving.
 
 **2.0: mobile devices and validation**
 iTunes backups, ADB and Android backups; submission to the NIST CFTT tests.

ROADMAP.pt-BR.md

@@ -11,7 +11,7 @@ Legenda: ✅ feito · 🟡 parcial · 🔜 planejado · 🔭 ideia a longo prazo
 1. **A origem é somente leitura.** Nada no núcleo escreve no dispositivo recuperado.
 2. **Não entregar sem validar.** Um recurso só entra com teste contra imagem real ou de referência. Por isso ReFS e Storage Spaces ainda não existem: não há imagem de referência para conferir.
 3. **Confiança honesta.** Se o conteúdo não pôde ser conferido, a confiança é baixa ou média, nunca alta.
-4. **Livre e auditável.** Código aberto (MIT ou Apache-2.0), sem telemetria, e cada resultado pode ser reproduzido.
+4. **Livre e auditável.** Código aberto (MIT ou Apache-2.0), sem telemetria (a única coisa que usa a rede por padrão é a verificação de atualização, uma requisição só que você pode desligar), e cada resultado pode ser reproduzido.
 
 ## Histórico
 
@@ -26,10 +26,13 @@ Legenda: ✅ feito · 🟡 parcial · 🔜 planejado · 🔭 ideia a longo prazo
 | 1.0.0 | 2026-10-19 | ext4, HFS+, Btrfs, XFS, APFS; BitLocker, LUKS, FileVault 2; RAID e LVM; E01, Ex01, AFF4; JPEG fragmentado; MP4 sem moov |
 | 1.0.1 | 2026-10-20 | Documentação em inglês com tradução em português, interface completa em inglês, telas, imagem Docker do terminal |
 | 1.1.0 | 2026-10-20 | Mensagens do núcleo e datas em inglês, verificação automática da tradução, RustCrypto em digest 0.11, acesso a dispositivo no Docker e workspaces do Superset verificados |
+| 1.2.0 | 2026-10-22 | Discos virtuais QCOW2, VMDK, VHD, VHDX e DMG, trilha de auditoria encadeada por hash, relatório em PDF, mapa de espaço livre do APFS |
+| 1.3.0 | 2026-10-23 | Atualização pelo próprio app, assinaturas Ed25519, QCOW2/VMDK diferenciais e DMG com LZFSE, imagens de referência testadas em Linux, macOS e Windows, teste de exclusão real do XFS |
+| 1.3.1 | 2026-10-23 | Nova logo oficial |
 
 Detalhes de cada versão no [CHANGELOG](CHANGELOG.pt-BR.md).
 
-## Situação atual (1.1.0) contra o que se espera de uma suíte forense
+## Situação atual (1.3.1) contra o que se espera de uma suíte forense
 
 ### 1. Sistemas de arquivos com metadados
 
@@ -39,12 +42,13 @@ Detalhes de cada versão no [CHANGELOG](CHANGELOG.pt-BR.md).
 | ext2/3/4 | ✅ | Inodes apagados e cópias antigas no diário |
 | HFS+ | ✅ | Sobras de nós da árvore e diário |
 | Btrfs | ✅ | Versões antigas das árvores; extensões zlib, zstd e lzo |
-| XFS | ✅ | Inodes liberados e nomes de entradas liberadas. Testado só com exclusão simulada |
-| APFS | 🟡 | Contêiner, mapa de objetos, instantâneos e nós antigos. **Falta o mapa de espaço livre**; exclusão testada só em simulação |
+| XFS | 🟡 | Inodes liberados e nomes de entradas liberadas só funcionam na exclusão simulada. Com exclusão real do kernel (testada no CI) os metadados são zerados: o conteúdo volta por carving, o nome não. **Falta ler o diário** |
+| APFS | 🟡 | Contêiner, mapa de objetos, mapa de espaço livre (spaceman e bitmaps), instantâneos e nós antigos. Exclusão testada só em simulação; contêineres com blocos de endereço de chunk-info (grandes) voltam a varrer o volume inteiro |
 | ReFS | 🔜 | Hoje só é detectado; a recuperação depende do carving. Falta imagem de referência |
 | Storage Spaces | 🔜 | Não feito. Falta imagem de referência |
 | NTFS: atributos comprimidos, EFS, lista de atributos | 🔜 | Hoje marcados como incompletos |
-| Validação de XFS e APFS com exclusão real | 🔜 | Trocar a simulação por imagens de dispositivos reais |
+| XFS: nomes e pastas após exclusão real (ler o diário) | 🔜 | O teste no CI existe e fica ignorado até isso entrar |
+| Validação de APFS com exclusão real | 🔜 | Precisa de imagem de um Mac de verdade |
 
 ### 2. Volumes cifrados
 
@@ -66,7 +70,9 @@ Hoje o Guará abre volumes quando você **já tem** a senha ou a chave. Recupera
 | Imagem bruta (dd) tolerante a setores ruins, com mapa de erros | ✅ |
 | E01 e Ex01: leitura, gravação e `guara verify` | ✅ |
 | AFF4: leitura e gravação | ✅ |
-| Outros contêineres (VMDK, VHD/VHDX, QCOW2, DMG) | 🔜 |
+| Contêineres de disco virtual: QCOW2, VMDK, VHD, VHDX e DMG (leitura) | ✅ |
+| QCOW2 com arquivo de apoio, snapshots de VMDK (por nome ou UUID do VirtualBox), DMG com LZFSE | ✅ |
+| DMG com senha, conferência da identidade do pai em VHD, VHDX e QCOW2 | 🔜 |
 | Imagem de dispositivo móvel (ver item 7) | 🔭 |
 
 ### 4. Montagem de discos soltos
@@ -126,10 +132,11 @@ O acesso físico é o diferencial de ferramentas comerciais como a Cellebrite. D
 | Manifesto `guara-manifesto.json` em toda recuperação | ✅ |
 | Relatório HTML com caso, examinador, origem, partições, resumo e hashes | ✅ |
 | Verificação de imagem E01/Ex01 contra o hash gravado | ✅ |
-| **Registro de auditoria** de cada ação do perito (quem, quando, o quê) | 🔜 |
-| **Relatórios assinados** digitalmente e manifesto com carimbo de tempo | 🔜 |
+| **Trilha de auditoria** de cada ação do perito (quem, quando, o quê), encadeada por hash, com `guara audit --verify` | ✅ |
+| **Assinatura digital** (Ed25519) de manifestos, relatórios e qualquer arquivo; `guara sign recovery` confere uma pasta de recuperação inteira | ✅ |
+| Carimbo de tempo de terceiros (RFC 3161) nas assinaturas | 🔜 |
 | **Reprodutibilidade:** repetir o procedimento gravado e obter o mesmo resultado | 🔜 |
-| Relatório em PDF | 🔜 |
+| Relatório em PDF (A4, próprio) | ✅ |
 | **Validação externa:** testes do NIST CFTT (Computer Forensic Tool Testing) e publicação dos resultados | 🔭 |
 | Binários assinados (Windows e macOS) | 🔜 |
 
@@ -153,7 +160,8 @@ A validação externa é o que faz um laudo ser aceito. Sem ela, o Guará serve
 |---|---|
 | CLI e interface para Windows, Linux e macOS | ✅ |
 | CI em três sistemas, release automática por tag | ✅ |
-| Testes com imagens reais em Windows e macOS (hoje só Linux) | 🔜 |
+| Testes com imagens de referência reais em Linux, macOS e Windows | ✅ |
+| Atualização dentro do app desktop (pacotes assinados, um clique) | ✅ |
 | GUI: processo auxiliar privilegiado em vez de reiniciar o app inteiro como administrador | 🔜 |
 | Binários assinados e notarizados | 🔜 |
 | Pacotes em gerenciadores (winget, Homebrew, Flatpak) | 🔭 |
@@ -162,17 +170,17 @@ A validação externa é o que faz um laudo ser aceito. Sem ela, o Guará serve
 
 Sem datas, na ordem em que fazem mais sentido.
 
-**1.1: confiança e custódia**
-Registro de auditoria, relatório em PDF, manifesto assinado, mapa de espaço livre do APFS, validação de XFS e APFS com exclusões reais, testes com imagens reais no Windows e macOS.
+**1.4: confiança e custódia**
+Carimbo de tempo de terceiros, leitura do diário do XFS, validação de APFS com exclusões reais.
 
-**1.2: análise**
+**1.5: análise**
 NSRL e listas de hashes, busca em conteúdo de arquivos, linha do tempo unificada.
 
-**1.3: artefatos**
+**1.6: artefatos**
 Registro do Windows, navegadores, EVTX e os apps de mensagem mais comuns, apoiados no leitor de SQLite.
 
-**1.4: mais estrutura**
-ReFS e Storage Spaces (quando houver imagem de referência), outros contêineres de imagem (VMDK, VHD, QCOW2), carving fragmentado ampliado.
+**1.7: mais estrutura**
+ReFS e Storage Spaces (quando houver imagem de referência), DMG com senha, conferência da identidade do pai em VHD, VHDX e QCOW2, carving fragmentado ampliado.
 
 **2.0: dispositivos móveis e validação**
 Backups do iTunes, ADB e backups do Android; submissão aos testes do NIST CFTT.

apps/gui/src-tauri/Cargo.toml

@@ -3,7 +3,7 @@
 [package]
 name = "guara-gui"
 description = "Guará: interface gráfica de recuperação de arquivos"
-version = "1.1.0"
+version = "1.3.1"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/lucasrguerra/guara"
@@ -17,6 +17,8 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 tauri = { version = "2", features = [] }
 tauri-plugin-dialog = "2"
+tauri-plugin-updater = "2"
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 guara-core = { path = "../../../crates/guara-core" }
 

apps/gui/src-tauri/src/main.rs

@@ -15,6 +15,73 @@ async fn rpc(state: tauri::State<'_, State>, method: String, params: serde_json:
         .map_err(|e| e.to_string())?
 }
 
+/// Versão nova encontrada na release do GitHub.
+#[derive(serde::Serialize)]
+struct UpdateInfo {
+    current: String,
+    version: String,
+    notes: String,
+    /// O app consegue se atualizar sozinho (AppImage, Windows e macOS). Instalação por pacote
+    /// (.deb/.rpm) só avisa e leva à página da release.
+    auto: bool,
+    url: String,
+}
+
+fn self_update_possible() -> bool {
+    !cfg!(target_os = "linux") || std::env::var_os("APPIMAGE").is_some()
+}
+
+/// Procura uma versão mais nova. `None` = já está na última.
+#[tauri::command]
+async fn update_check(app: tauri::AppHandle) -> Result<Option<UpdateInfo>, String> {
+    use tauri_plugin_updater::UpdaterExt;
+    let found = app.updater().map_err(|e| e.to_string())?.check().await.map_err(|e| e.to_string())?;
+    Ok(found.map(|u| UpdateInfo {
+        current: u.current_version.clone(),
+        notes: u.body.clone().unwrap_or_default(),
+        url: format!("https://github.com/lucasrguerra/guara/releases/tag/v{}", u.version),
+        version: u.version,
+        auto: self_update_possible(),
+    }))
+}
+
+/// Baixa, confere a assinatura (chave pública embutida no app), instala e reabre o app.
+/// O progresso sai no evento `update-progress`.
+#[tauri::command]
+async fn update_install(app: tauri::AppHandle) -> Result<(), String> {
+    use tauri::Emitter;
+    use tauri_plugin_updater::UpdaterExt;
+    if !self_update_possible() {
+        return Err("Esta instalação não se atualiza sozinha (pacote do sistema). Baixe a versão nova na página da release.".into());
+    }
+    let update = app
+        .updater()
+        .map_err(|e| e.to_string())?
+        .check()
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or("Já está na versão mais recente.")?;
+    let (a, b) = (app.clone(), app.clone());
+    let mut got = 0u64;
+    update
+        .download_and_install(
+            move |chunk, total| {
+                got += chunk as u64;
+                let _ = a.emit("update-progress", serde_json::json!({ "downloaded": got, "total": total }));
+            },
+            move || {
+                let _ = b.emit("update-progress", serde_json::json!({ "installing": true }));
+            },
+        )
+        .await
+        .map_err(|e| format!("Não foi possível atualizar: {e}"))?;
+    // Rodando como administrador, o arquivo novo nasce do root: devolve ao usuário que abriu o app.
+    if let Some(p) = std::env::var_os("APPIMAGE") {
+        guara_core::owner::give_to_user(std::path::Path::new(&p));
+    }
+    app.restart()
+}
+
 /// Reabre o app com privilégios de administrador (Linux/macOS). No Windows o
 /// manifesto já exige elevação. O app novo encerra este quando abre; se a
 /// autorização falhar, a janela continua aqui e a interface mostra o motivo.
@@ -155,6 +222,7 @@ fn main() {
     let for_protocol = engine.clone();
     tauri::Builder::default()
         .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_updater::Builder::new().build())
         .manage(State(engine))
         .register_asynchronous_uri_scheme_protocol("guara", move |_ctx, request, responder| {
             let eng = for_protocol.clone();
@@ -176,7 +244,7 @@ fn main() {
             }
             Ok(())
         })
-        .invoke_handler(tauri::generate_handler![rpc, relaunch_elevated])
+        .invoke_handler(tauri::generate_handler![rpc, relaunch_elevated, update_check, update_install])
         .run(tauri::generate_context!())
         .expect("erro ao iniciar o Guará");
 }

apps/gui/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Guara",
-  "version": "1.1.0",
+  "version": "1.3.1",
   "identifier": "dev.guara.app",
   "build": {
     "frontendDist": "../ui"
@@ -34,6 +34,18 @@
       "icons/128x128@2x.png",
       "icons/icon.icns",
       "icons/icon.ico"
-    ]
+    ],
+    "createUpdaterArtifacts": true
+  },
+  "plugins": {
+    "updater": {
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDhENzRCRUU5NEI3QTAxQzgKUldUSUFYcEw2YjUwamFzMnpXM3ZKTEZPN1JIeXdLL3Q5SEF1M1FxQ284WFM0UWNsdlAyNUloWTEK",
+      "endpoints": [
+        "https://github.com/lucasrguerra/guara/releases/latest/download/latest.json"
+      ],
+      "windows": {
+        "installMode": "passive"
+      }
+    }
   }
 }

apps/gui/ui/app.css

@@ -332,7 +332,7 @@ dialog.lightbox[open] { display: grid; }
 .lb-head .ttl { flex: 1; min-width: 0; } .lb-head .ttl b { display: block; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } .lb-head .ttl small { color: var(--text-2); }
 .lb-body { padding: 12px; min-height: 0; }
 
-.hero-logo { width: min(440px, 80%); height: auto; display: block; margin: 0 0 22px -4px; }
+.hero-logo { width: min(340px, 70%); height: auto; margin: 0 0 14px -6px; }
 .pill.accent { background: var(--accent-soft); color: var(--accent); }
 
 /* ------------------------------------------------------------ explorador de arquivos */
@@ -516,5 +516,14 @@ dialog.lightbox[open] { display: grid; }
 .h-dot { display: inline-block; width: 9px; height: 9px; border-radius: 50%; background: var(--ok); }
 .h-dot.warning { background: var(--warn); } .h-dot.failing { background: var(--bad); }
 
-/* logo inline: segue o tema escolhido no app, não o do sistema */
-.logo .a { stroke: var(--accent); } .logo .b { stroke: var(--accent-2); } .logo .t { fill: var(--text); }
+/* logo: uma arte só (laranja sobre transparente) serve aos temas claro e escuro */
+.logo-img { display: block; flex: none; }
+
+/* atualização do app */
+.update-card { position: fixed; right: 18px; bottom: 18px; z-index: 60; width: min(400px, calc(100vw - 36px)); display: grid; gap: 10px; padding: 16px 18px; border-radius: 18px; background: var(--surface); box-shadow: var(--shadow); border: 1px solid color-mix(in srgb, var(--accent) 35%, transparent); }
+.update-card .upd-head { display: grid; gap: 2px; }
+.update-card .upd-ver { font-size: 12.5px; color: var(--text-2); }
+.update-card .upd-url { word-break: break-all; font-size: 12.5px; }
+.update-card .upd-actions { display: flex; gap: 8px; flex-wrap: wrap; }
+.update-card .sub { margin: 0; }
+pre.upd-notes { max-height: 50vh; overflow: auto; white-space: pre-wrap; font-size: 13px; }

apps/gui/ui/app.js

@@ -53,7 +53,7 @@ document.querySelectorAll('[data-theme-pick]').forEach((b) => (b.onclick = async
 
 // ------------------------------------------------------------------ configurações
 // (declarado antes do uso: `S` é definido mais abaixo, por isso o objeto fica aqui)
-const SETTINGS = { theme: 'auto', lang: 'auto', ui_lang: null, notify: true, maps: false };
+const SETTINGS = { theme: 'auto', lang: 'auto', ui_lang: null, notify: true, maps: false, updates: true };
 async function saveSettings(patch) {
   Object.assign(SETTINGS, patch);
   try { await rpc('settings_set', SETTINGS); } catch { /* segue só com o armazenamento local */ }
@@ -265,7 +265,7 @@ function renderHome() {
   S.device = null; S.job = null;
   renderSide();
   main.innerHTML = `<div class="page">
-    <section class="hero"><img class="hero-logo" src="guara-logo.svg" alt="Guará"><h1>Encontre o que você achou que tinha perdido.</h1>
+    <section class="hero"><img class="logo-img hero-logo" src="guara.png" alt="Guará"><h1>Encontre o que você achou que tinha perdido.</h1>
     <p>Escolha um disco, SSD ou pendrive ao lado. O Guará lê tudo: arquivos apagados, partições perdidas e espaço não particionado, sem escrever nada no disco de origem.</p></section>
     <div class="cards">
       <div class="card"><h3>Uma varredura, tudo junto</h3><p>Metadados do sistema de arquivos e busca por assinatura na mesma passada, sem duplicatas.</p></div>
@@ -667,7 +667,7 @@ async function onProgressClick(e) {
     const path = await ask({ title: 'Exportar para CSV', text: 'Grava os arquivos da vista atual (com os filtros aplicados). O arquivo abre direto no Excel.', value: (S.defaults.home || '') + (S.defaults.sep || '/') + 'guara-achados.csv', ok: 'Exportar' });
     if (path) { try { const r = await rpc('export_csv', { job: S.job, path, query: EX?.query() }); toast(`${r.rows.toLocaleString(LOC())} linhas gravadas`); } catch (err) { toast(err.message); } }
   } else if (act === 'report') {
-    const f = await askForm({ title: 'Relatório de recuperação', text: 'Gera um relatório HTML pronto para imprimir, com a origem examinada, os achados e os hashes dos arquivos recuperados.', ok: 'Gerar relatório', fields: [
+    const f = await askForm({ title: 'Relatório de recuperação', text: 'Gera um relatório pronto para imprimir, com a origem examinada, os achados e os hashes dos arquivos recuperados. Termine o nome em .pdf para gerar PDF; com .html sai uma página web.', ok: 'Gerar relatório', fields: [
       { name: 'path', label: 'Salvar em', value: (S.defaults.home || '') + (S.defaults.sep || '/') + 'guara-relatorio.html' },
       { name: 'case_id', label: 'Número do caso' }, { name: 'examiner', label: 'Responsável pelo exame' }, { name: 'organization', label: 'Organização' },
       { name: 'notes', label: 'Observações', multiline: true } ] });
@@ -745,11 +745,14 @@ $('#settingsBtn')?.addEventListener('click', () => {
     <label class="fld"><span>Idioma</span><select class="select" name="lang"><option value="auto">Auto</option><option value="pt">Português</option><option value="en">English</option></select></label>
     <label class="check"><input type="checkbox" name="notify" ${SETTINGS.notify ? 'checked' : ''}><span><b>Notificações</b><br><span class="sub">Avisar quando uma tarefa longa terminar</span></span></label>
     <label class="check"><input type="checkbox" name="maps" ${SETTINGS.maps ? 'checked' : ''}><span><b>Mapas online</b><br><span class="sub">Mostrar mapas das fotos com GPS (usa a internet: baixa blocos do OpenStreetMap)</span></span></label>
+    ${tauri?.core?.invoke ? `<label class="check"><input type="checkbox" name="updates" ${SETTINGS.updates ? 'checked' : ''}><span><b>Atualizações automáticas</b><br><span class="sub">Ao abrir, consulta o GitHub para ver se há versão nova (uma consulta, sem enviar dados seus)</span><br><button type="button" class="btn sm" id="updNow">Verificar agora</button></span></label>` : ''}
     <menu><button class="btn" value="cancel">Cancelar</button><button class="btn primary" value="ok">Salvar</button></menu></form>`;
   d.querySelector('[name=lang]').value = SETTINGS.lang;
+  d.querySelector('#updNow')?.addEventListener('click', (e) => { e.preventDefault(); checkUpdate(true); });
   d.onclose = () => {
     if (d.returnValue !== 'ok') return;
     const patch = { lang: d.querySelector('[name=lang]').value, notify: d.querySelector('[name=notify]').checked, maps: d.querySelector('[name=maps]').checked };
+    if (d.querySelector('[name=updates]')) patch.updates = d.querySelector('[name=updates]').checked;
     setLang(patch.lang);
     patch.ui_lang = currentLang();
     saveSettings(patch);
@@ -759,6 +762,64 @@ $('#settingsBtn')?.addEventListener('click', () => {
   d.showModal();
 });
 
+// ------------------------------------------------------------------ atualização do app
+// O núcleo do app (Tauri) consulta o `latest.json` da release no GitHub, confere a assinatura do
+// pacote com a chave pública embutida, instala e reabre. No navegador (`guara ui`) não há nada a fazer.
+let UPD = null;
+
+async function checkUpdate(manual) {
+  if (!tauri?.core?.invoke) return;
+  try {
+    UPD = await tauri.core.invoke('update_check');
+    renderUpdateCard();
+    if (manual) toast(UPD ? `Nova versão ${UPD.version} disponível` : 'Você já está na versão mais recente');
+  } catch (e) {
+    if (manual) toast(`Não foi possível verificar atualizações: ${e}`);
+  }
+}
+
+function renderUpdateCard(state) {
+  let el = $('#updateCard');
+  if (!UPD) { el?.remove(); return; }
+  if (!el) { el = document.createElement('div'); el.id = 'updateCard'; el.className = 'update-card'; el.setAttribute('role', 'status'); document.body.appendChild(el); }
+  if (state === 'busy') return;
+  el.innerHTML = `<div class="upd-head"><b>Nova versão do Guará disponível</b><span class="mono upd-ver">v${esc(UPD.current)} → v${esc(UPD.version)}</span></div>
+    ${UPD.auto ? '' : '<p class="sub">Esta instalação vem de um pacote do sistema e não se atualiza sozinha. Baixe a versão nova na página da release:</p><p class="mono upd-url">' + esc(UPD.url) + '</p>'}
+    <div class="upd-actions">
+      ${UPD.auto ? '<button class="btn primary sm" id="updGo">Atualizar agora</button>' : ''}
+      ${UPD.notes ? '<button class="btn sm" id="updNotes">Novidades</button>' : ''}
+      <button class="btn sm" id="updLater">Depois</button>
+    </div>`;
+  $('#updGo')?.addEventListener('click', installUpdate);
+  $('#updLater')?.addEventListener('click', () => { UPD = null; el.remove(); });
+  $('#updNotes')?.addEventListener('click', () => info({ title: `Guará ${UPD.version}`, html: `<pre class="upd-notes">${esc(UPD.notes)}</pre>` }));
+}
+
+async function installUpdate() {
+  const el = $('#updateCard');
+  el.innerHTML = `<div class="upd-head"><b>Atualizando o Guará…</b></div>
+    <div class="bar indet" id="updBar"><i style="width:0"></i></div><p class="sub" id="updMsg">Baixando a atualização…</p>`;
+  renderUpdateCard('busy');
+  try {
+    await tauri.core.invoke('update_install');
+  } catch (e) {
+    toast(String(e));
+    renderUpdateCard();
+  }
+}
+
+function updateProgress(p) {
+  const bar = $('#updBar'); const msg = $('#updMsg');
+  if (!bar || !msg) return;
+  if (p.installing) { bar.classList.add('indet'); msg.textContent = 'Instalando… o Guará vai reabrir sozinho.'; return; }
+  if (p.total) {
+    const pct = Math.min(100, Math.round((p.downloaded / p.total) * 100));
+    bar.classList.remove('indet');
+    bar.firstElementChild.style.width = `${pct}%`;
+    msg.textContent = `Baixando… ${pct}%`;
+  }
+}
+
 // ------------------------------------------------------------------ fechar com varredura em andamento
 function askClose() {
   return new Promise((resolve) => {
@@ -807,6 +868,8 @@ function watchClose() {
     setLang(SETTINGS.lang);
     if (SETTINGS.ui_lang !== currentLang()) saveSettings({ ui_lang: currentLang() });
     watchClose();
+    tauri?.event?.listen?.('update-progress', (e) => updateProgress(e.payload));
+    if (SETTINGS.updates !== false) checkUpdate(false);
     tauri?.event?.listen?.('elevate-failed', (e) => { toast(String(e.payload || 'Não foi possível reiniciar como administrador')); });
   } catch (e) {
     main.innerHTML = `<div class="page"><div class="notice bad">${warnSvg}<div>Não foi possível falar com o núcleo do Guará: ${esc(e.message)}. Se abriu esta página manualmente, use o endereço completo exibido pelo comando <code>guara ui</code> (ele inclui o token).</div></div></div>`;

apps/gui/ui/guara-logo.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" role="img" aria-label="Guará"><style>.a{stroke:#0f766e}.b{stroke:#14b8a6}.t{fill:#1d1d1f}@media (prefers-color-scheme:dark){.a{stroke:#2dd4bf}.b{stroke:#5eead4}.t{fill:#f5f5f7}}</style><defs><clipPath id="g-head"><path d="M50 95 C46 88 43 80 40 74 C33 70 25 64 22 56 L14 6 L36 30 C40 28 45 27 50 27 C55 27 60 28 64 30 L86 6 L78 56 C75 64 67 70 60 74 C57 80 54 88 50 95 Z"/></clipPath></defs><g clip-path="url(#g-head)" fill="none" stroke-width="4.2"><path class="a" d="M50 93A7 7 0 0 1 50 107"/><path class="b" d="M50 93A7 7 0 0 0 50 107" stroke-dasharray="3 3" stroke-dashoffset="0"/><path class="a" d="M50 86A14 14 0 0 1 50 114"/><path class="b" d="M50 86A14 14 0 0 0 50 114" stroke-dasharray="6 4" stroke-dashoffset="3"/><path class="a" d="M50 79A21 21 0 0 1 50 121"/><path class="b" d="M50 79A21 21 0 0 0 50 121" stroke-dasharray="9 5" stroke-dashoffset="6"/><path class="a" d="M50 72A28 28 0 0 1 50 128"/><path class="b" d="M50 72A28 28 0 0 0 50 128" stroke-dasharray="3 6" stroke-dashoffset="9"/><path class="a" d="M50 65A35 35 0 0 1 50 135"/><path class="b" d="M50 65A35 35 0 0 0 50 135" stroke-dasharray="6 3" stroke-dashoffset="12"/><path class="a" d="M50 58A42 42 0 0 1 50 142"/><path class="b" d="M50 58A42 42 0 0 0 50 142" stroke-dasharray="9 4" stroke-dashoffset="15"/><path class="a" d="M50 51A49 49 0 0 1 50 149"/><path class="b" d="M50 51A49 49 0 0 0 50 149" stroke-dasharray="3 5" stroke-dashoffset="18"/><path class="a" d="M50 44A56 56 0 0 1 50 156"/><path class="b" d="M50 44A56 56 0 0 0 50 156" stroke-dasharray="6 6" stroke-dashoffset="21"/><path class="a" d="M50 37A63 63 0 0 1 50 163"/><path class="b" d="M50 37A63 63 0 0 0 50 163" stroke-dasharray="9 3" stroke-dashoffset="24"/><path class="a" d="M50 30A70 70 0 0 1 50 170"/><path class="b" d="M50 30A70 70 0 0 0 50 170" stroke-dasharray="3 4" stroke-dashoffset="27"/><path class="a" d="M50 23A77 77 0 0 1 50 177"/><path class="b" d="M50 23A77 77 0 0 0 50 177" stroke-dasharray="6 5" stroke-dashoffset="30"/><path class="a" d="M50 16A84 84 0 0 1 50 184"/><path class="b" d="M50 16A84 84 0 0 0 50 184" stroke-dasharray="9 6" stroke-dashoffset="33"/><path class="a" d="M50 9A91 91 0 0 1 50 191"/><path class="b" d="M50 9A91 91 0 0 0 50 191" stroke-dasharray="3 3" stroke-dashoffset="36"/><path class="a" d="M50 2A98 98 0 0 1 50 198"/><path class="b" d="M50 2A98 98 0 0 0 50 198" stroke-dasharray="6 4" stroke-dashoffset="39"/><rect class="t" stroke="none" x="0" y="74" width="100" height="30"/></g><path class="t" d="M37 50Q42 47 46 52Q41 53 37 50ZM63 50Q58 47 54 52Q59 53 63 50Z"/></svg>

apps/gui/ui/guara.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" role="img" aria-label="Guará"><style>.a{stroke:#0f766e}.b{stroke:#14b8a6}.t{fill:#1d1d1f}@media (prefers-color-scheme:dark){.a{stroke:#2dd4bf}.b{stroke:#5eead4}.t{fill:#f5f5f7}}</style><defs><clipPath id="g-head"><path d="M50 95 C46 88 43 80 40 74 C33 70 25 64 22 56 L14 6 L36 30 C40 28 45 27 50 27 C55 27 60 28 64 30 L86 6 L78 56 C75 64 67 70 60 74 C57 80 54 88 50 95 Z"/></clipPath></defs><g clip-path="url(#g-head)" fill="none" stroke-width="4.2"><path class="a" d="M50 93A7 7 0 0 1 50 107"/><path class="b" d="M50 93A7 7 0 0 0 50 107" stroke-dasharray="3 3" stroke-dashoffset="0"/><path class="a" d="M50 86A14 14 0 0 1 50 114"/><path class="b" d="M50 86A14 14 0 0 0 50 114" stroke-dasharray="6 4" stroke-dashoffset="3"/><path class="a" d="M50 79A21 21 0 0 1 50 121"/><path class="b" d="M50 79A21 21 0 0 0 50 121" stroke-dasharray="9 5" stroke-dashoffset="6"/><path class="a" d="M50 72A28 28 0 0 1 50 128"/><path class="b" d="M50 72A28 28 0 0 0 50 128" stroke-dasharray="3 6" stroke-dashoffset="9"/><path class="a" d="M50 65A35 35 0 0 1 50 135"/><path class="b" d="M50 65A35 35 0 0 0 50 135" stroke-dasharray="6 3" stroke-dashoffset="12"/><path class="a" d="M50 58A42 42 0 0 1 50 142"/><path class="b" d="M50 58A42 42 0 0 0 50 142" stroke-dasharray="9 4" stroke-dashoffset="15"/><path class="a" d="M50 51A49 49 0 0 1 50 149"/><path class="b" d="M50 51A49 49 0 0 0 50 149" stroke-dasharray="3 5" stroke-dashoffset="18"/><path class="a" d="M50 44A56 56 0 0 1 50 156"/><path class="b" d="M50 44A56 56 0 0 0 50 156" stroke-dasharray="6 6" stroke-dashoffset="21"/><path class="a" d="M50 37A63 63 0 0 1 50 163"/><path class="b" d="M50 37A63 63 0 0 0 50 163" stroke-dasharray="9 3" stroke-dashoffset="24"/><path class="a" d="M50 30A70 70 0 0 1 50 170"/><path class="b" d="M50 30A70 70 0 0 0 50 170" stroke-dasharray="3 4" stroke-dashoffset="27"/><path class="a" d="M50 23A77 77 0 0 1 50 177"/><path class="b" d="M50 23A77 77 0 0 0 50 177" stroke-dasharray="6 5" stroke-dashoffset="30"/><path class="a" d="M50 16A84 84 0 0 1 50 184"/><path class="b" d="M50 16A84 84 0 0 0 50 184" stroke-dasharray="9 6" stroke-dashoffset="33"/><path class="a" d="M50 9A91 91 0 0 1 50 191"/><path class="b" d="M50 9A91 91 0 0 0 50 191" stroke-dasharray="3 3" stroke-dashoffset="36"/><path class="a" d="M50 2A98 98 0 0 1 50 198"/><path class="b" d="M50 2A98 98 0 0 0 50 198" stroke-dasharray="6 4" stroke-dashoffset="39"/><rect class="t" stroke="none" x="0" y="74" width="100" height="30"/></g><path class="t" d="M37 50Q42 47 46 52Q41 53 37 50ZM63 50Q58 47 54 52Q59 53 63 50Z"/></svg>

apps/gui/ui/i18n-en.js

@@ -320,7 +320,7 @@ export const EN = {
   '{n} linhas gravadas': '{n} rows written',
   'Relatório de recuperação': 'Recovery report',
   'Gerar relatório': 'Generate report',
-  'Gera um relatório HTML pronto para imprimir, com a origem examinada, os achados e os hashes dos arquivos recuperados.': 'Generates a print-ready HTML report with the examined source, the findings and the hashes of recovered files.',
+  'Gera um relatório pronto para imprimir, com a origem examinada, os achados e os hashes dos arquivos recuperados. Termine o nome em .pdf para gerar PDF; com .html sai uma página web.': 'Generates a print-ready report with the examined source, the findings and the hashes of recovered files. End the name in .pdf for a PDF; with .html you get a web page.',
   'Salvar em': 'Save to',
   'Número do caso': 'Case number',
   'Responsável pelo exame': 'Examiner',
@@ -575,4 +575,19 @@ export const EN = {
   '{n} · {n}{n} · confiança {n} · {n} de {n}': '{n} · {n}{n} · confidence {n} · {n} of {n}',
   'e mais {n}…': 'and {n} more…',
   'abre no seu player: o navegador embutido do Linux não traz os codecs e travaria a janela.': 'opens in your player: the embedded Linux browser does not include the codecs and would freeze the window.',
+  'Nova versão do Guará disponível': 'New Guará version available',
+  'Atualizar agora': 'Update now',
+  'Novidades': 'What\'s new',
+  'Depois': 'Later',
+  'Atualizando o Guará…': 'Updating Guará…',
+  'Baixando a atualização…': 'Downloading the update…',
+  'Baixando… {n}%': 'Downloading… {n}%',
+  'Instalando… o Guará vai reabrir sozinho.': 'Installing… Guará will reopen by itself.',
+  'Esta instalação vem de um pacote do sistema e não se atualiza sozinha. Baixe a versão nova na página da release:': 'This install comes from a system package and cannot update itself. Download the new version from the release page:',
+  'Atualizações automáticas': 'Automatic updates',
+  'Ao abrir, consulta o GitHub para ver se há versão nova (uma consulta, sem enviar dados seus)': 'On startup, checks GitHub for a new version (one request, nothing of yours is sent)',
+  'Verificar agora': 'Check now',
+  'Nova versão {n} disponível': 'New version {n} available',
+  'Você já está na versão mais recente': 'You are already on the latest version',
+  'Não foi possível verificar atualizações: {n}': 'Could not check for updates: {n}',
 };

apps/gui/ui/index.html

@@ -5,7 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
   <meta name="color-scheme" content="light dark">
   <title>Guará</title>
-  <link rel="icon" href="guara.svg" type="image/svg+xml">
+  <link rel="icon" href="guara-s.png" type="image/png">
   <link rel="stylesheet" href="app.css">
 </head>
 <body>
@@ -14,10 +14,10 @@
       <button class="icon-btn" id="menuBtn" aria-label="Abrir menu" aria-expanded="false">
         <svg viewBox="0 0 24 24" width="22" height="22"><path d="M4 7h16M4 12h16M4 17h16" stroke="currentColor" stroke-width="2" stroke-linecap="round" fill="none"/></svg>
       </button>
-      <svg class="logo" width="24" height="24" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><defs><clipPath id="g-head-top"><path d="M50 95 C46 88 43 80 40 74 C33 70 25 64 22 56 L14 6 L36 30 C40 28 45 27 50 27 C55 27 60 28 64 30 L86 6 L78 56 C75 64 67 70 60 74 C57 80 54 88 50 95 Z"/></clipPath></defs><g clip-path="url(#g-head-top)" fill="none" stroke-width="4.2"><path class="a" d="M50 93A7 7 0 0 1 50 107"/><path class="b" d="M50 93A7 7 0 0 0 50 107" stroke-dasharray="3 3" stroke-dashoffset="0"/><path class="a" d="M50 86A14 14 0 0 1 50 114"/><path class="b" d="M50 86A14 14 0 0 0 50 114" stroke-dasharray="6 4" stroke-dashoffset="3"/><path class="a" d="M50 79A21 21 0 0 1 50 121"/><path class="b" d="M50 79A21 21 0 0 0 50 121" stroke-dasharray="9 5" stroke-dashoffset="6"/><path class="a" d="M50 72A28 28 0 0 1 50 128"/><path class="b" d="M50 72A28 28 0 0 0 50 128" stroke-dasharray="3 6" stroke-dashoffset="9"/><path class="a" d="M50 65A35 35 0 0 1 50 135"/><path class="b" d="M50 65A35 35 0 0 0 50 135" stroke-dasharray="6 3" stroke-dashoffset="12"/><path class="a" d="M50 58A42 42 0 0 1 50 142"/><path class="b" d="M50 58A42 42 0 0 0 50 142" stroke-dasharray="9 4" stroke-dashoffset="15"/><path class="a" d="M50 51A49 49 0 0 1 50 149"/><path class="b" d="M50 51A49 49 0 0 0 50 149" stroke-dasharray="3 5" stroke-dashoffset="18"/><path class="a" d="M50 44A56 56 0 0 1 50 156"/><path class="b" d="M50 44A56 56 0 0 0 50 156" stroke-dasharray="6 6" stroke-dashoffset="21"/><path class="a" d="M50 37A63 63 0 0 1 50 163"/><path class="b" d="M50 37A63 63 0 0 0 50 163" stroke-dasharray="9 3" stroke-dashoffset="24"/><path class="a" d="M50 30A70 70 0 0 1 50 170"/><path class="b" d="M50 30A70 70 0 0 0 50 170" stroke-dasharray="3 4" stroke-dashoffset="27"/><path class="a" d="M50 23A77 77 0 0 1 50 177"/><path class="b" d="M50 23A77 77 0 0 0 50 177" stroke-dasharray="6 5" stroke-dashoffset="30"/><path class="a" d="M50 16A84 84 0 0 1 50 184"/><path class="b" d="M50 16A84 84 0 0 0 50 184" stroke-dasharray="9 6" stroke-dashoffset="33"/><path class="a" d="M50 9A91 91 0 0 1 50 191"/><path class="b" d="M50 9A91 91 0 0 0 50 191" stroke-dasharray="3 3" stroke-dashoffset="36"/><path class="a" d="M50 2A98 98 0 0 1 50 198"/><path class="b" d="M50 2A98 98 0 0 0 50 198" stroke-dasharray="6 4" stroke-dashoffset="39"/><rect class="t" stroke="none" x="0" y="74" width="100" height="30"/></g><path class="t" d="M37 50Q42 47 46 52Q41 53 37 50ZM63 50Q58 47 54 52Q59 53 63 50Z"/></svg><strong>Guará</strong>
+      <img class="logo-img" src="guara-s.png" width="24" height="24" alt=""><strong>Guará</strong>
     </header>
     <aside class="sidebar" id="sidebar" aria-label="Dispositivos e sessões">
-      <div class="brand"><svg class="logo" width="30" height="30" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"><defs><clipPath id="g-head-side"><path d="M50 95 C46 88 43 80 40 74 C33 70 25 64 22 56 L14 6 L36 30 C40 28 45 27 50 27 C55 27 60 28 64 30 L86 6 L78 56 C75 64 67 70 60 74 C57 80 54 88 50 95 Z"/></clipPath></defs><g clip-path="url(#g-head-side)" fill="none" stroke-width="4.2"><path class="a" d="M50 93A7 7 0 0 1 50 107"/><path class="b" d="M50 93A7 7 0 0 0 50 107" stroke-dasharray="3 3" stroke-dashoffset="0"/><path class="a" d="M50 86A14 14 0 0 1 50 114"/><path class="b" d="M50 86A14 14 0 0 0 50 114" stroke-dasharray="6 4" stroke-dashoffset="3"/><path class="a" d="M50 79A21 21 0 0 1 50 121"/><path class="b" d="M50 79A21 21 0 0 0 50 121" stroke-dasharray="9 5" stroke-dashoffset="6"/><path class="a" d="M50 72A28 28 0 0 1 50 128"/><path class="b" d="M50 72A28 28 0 0 0 50 128" stroke-dasharray="3 6" stroke-dashoffset="9"/><path class="a" d="M50 65A35 35 0 0 1 50 135"/><path class="b" d="M50 65A35 35 0 0 0 50 135" stroke-dasharray="6 3" stroke-dashoffset="12"/><path class="a" d="M50 58A42 42 0 0 1 50 142"/><path class="b" d="M50 58A42 42 0 0 0 50 142" stroke-dasharray="9 4" stroke-dashoffset="15"/><path class="a" d="M50 51A49 49 0 0 1 50 149"/><path class="b" d="M50 51A49 49 0 0 0 50 149" stroke-dasharray="3 5" stroke-dashoffset="18"/><path class="a" d="M50 44A56 56 0 0 1 50 156"/><path class="b" d="M50 44A56 56 0 0 0 50 156" stroke-dasharray="6 6" stroke-dashoffset="21"/><path class="a" d="M50 37A63 63 0 0 1 50 163"/><path class="b" d="M50 37A63 63 0 0 0 50 163" stroke-dasharray="9 3" stroke-dashoffset="24"/><path class="a" d="M50 30A70 70 0 0 1 50 170"/><path class="b" d="M50 30A70 70 0 0 0 50 170" stroke-dasharray="3 4" stroke-dashoffset="27"/><path class="a" d="M50 23A77 77 0 0 1 50 177"/><path class="b" d="M50 23A77 77 0 0 0 50 177" stroke-dasharray="6 5" stroke-dashoffset="30"/><path class="a" d="M50 16A84 84 0 0 1 50 184"/><path class="b" d="M50 16A84 84 0 0 0 50 184" stroke-dasharray="9 6" stroke-dashoffset="33"/><path class="a" d="M50 9A91 91 0 0 1 50 191"/><path class="b" d="M50 9A91 91 0 0 0 50 191" stroke-dasharray="3 3" stroke-dashoffset="36"/><path class="a" d="M50 2A98 98 0 0 1 50 198"/><path class="b" d="M50 2A98 98 0 0 0 50 198" stroke-dasharray="6 4" stroke-dashoffset="39"/><rect class="t" stroke="none" x="0" y="74" width="100" height="30"/></g><path class="t" d="M37 50Q42 47 46 52Q41 53 37 50ZM63 50Q58 47 54 52Q59 53 63 50Z"/></svg><div><strong>Guará</strong><small>Recuperação de arquivos</small></div></div>
+      <div class="brand"><img class="logo-img" src="guara-s.png" width="30" height="30" alt=""><div><strong>Guará</strong><small>Recuperação de arquivos</small></div></div>
       <nav>
         <div class="side-title">Dispositivos <button class="icon-btn small" id="refreshBtn" title="Atualizar lista" aria-label="Atualizar lista"><svg viewBox="0 0 24 24" width="16" height="16"><path d="M20 12a8 8 0 1 1-2.5-5.8M20 4v5h-5" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/></svg></button></div>
         <ul id="deviceList" class="list"></ul>

crates/guara-cli/src/main.rs

@@ -18,6 +18,45 @@ struct Cli {
     cmd: Cmd,
 }
 
+#[derive(Subcommand)]
+enum SignCmd {
+    /// Cria o par de chaves de assinatura (recusa sobrescrever uma chave existente)
+    Keygen {
+        /// Onde gravar a chave privada (padrão: assinatura.key na pasta de configuração ou GUARA_SIGNING_KEY)
+        #[arg(long)]
+        key: Option<String>,
+    },
+    /// Assina um arquivo e grava <arquivo>.assinatura.json
+    File {
+        path: String,
+        #[arg(long)]
+        key: Option<String>,
+        /// Nome de quem assina (padrão: GUARA_EXAMINER)
+        #[arg(long)]
+        signer: Option<String>,
+    },
+    /// Confere a assinatura de um arquivo
+    Verify {
+        path: String,
+        /// Arquivo de assinatura (padrão: <arquivo>.assinatura.json)
+        #[arg(long)]
+        sig: Option<String>,
+        /// Impressão digital esperada da chave, publicada pelo perito
+        #[arg(long)]
+        trust: Option<String>,
+        #[arg(long)]
+        json: bool,
+    },
+    /// Confere uma pasta de recuperação: assinatura do manifesto e hash de cada arquivo
+    Recovery {
+        dir: String,
+        #[arg(long)]
+        trust: Option<String>,
+        #[arg(long)]
+        json: bool,
+    },
+}
+
 #[derive(Subcommand)]
 enum Cmd {
     /// Lista discos e pendrives detectados
@@ -88,6 +127,23 @@ enum Cmd {
     },
     /// Confere uma imagem E01/Ex01: recalcula o MD5 e compara com o gravado na própria imagem
     Verify { path: String },
+    /// Assina e confere arquivos (manifestos, relatórios) e pastas de recuperação com Ed25519
+    #[command(subcommand)]
+    Sign(SignCmd),
+    /// Mostra a trilha de auditoria (quem fez o quê e quando) ou confere o encadeamento por hash
+    Audit {
+        /// Arquivo da trilha (padrão: auditoria.jsonl na pasta de configuração ou GUARA_AUDIT_LOG)
+        #[arg(long)]
+        log: Option<String>,
+        /// Só confere a cadeia de hashes; sai com erro se ela estiver quebrada
+        #[arg(long)]
+        verify: bool,
+        /// Mostra só as últimas N entradas
+        #[arg(long)]
+        tail: Option<usize>,
+        #[arg(long)]
+        json: bool,
+    },
     /// Exporta os achados de uma sessão para CSV (abre no Excel)
     Export {
         session: String,
@@ -96,10 +152,10 @@ enum Cmd {
         #[command(flatten)]
         filter: FilterArgs,
     },
-    /// Gera o relatório HTML de recuperação (identificação do caso, origem, achados, hashes)
+    /// Gera o relatório de recuperação (identificação do caso, origem, achados, hashes): PDF se o arquivo terminar em .pdf, senão HTML
     Report {
         session: String,
-        /// Arquivo HTML de saída
+        /// Arquivo de saída (.pdf ou .html)
         out: String,
         #[arg(long, default_value = "")]
         case: String,
@@ -427,52 +483,21 @@ fn run(cli: Cli) -> Result<(), String> {
             eng.save_session(&job, &session).map_err(s)?;
             Ok(())
         }
-        Cmd::Verify { path } if path.to_ascii_lowercase().ends_with(".aff4") => {
-            let a = guara_core::aff4::Aff4Source::open(std::path::Path::new(&path)).map_err(s)?;
-            println!("Formato: AFF4");
-            for (k, v) in &a.info {
-                println!("{k}: {v}");
-            }
-            eprintln!("Recalculando o hash...");
-            match a.verify_stream_md5().map_err(s)? {
-                Some(true) => {
-                    println!("MD5 gravado e recalculado conferem.");
-                    Ok(())
-                }
-                Some(false) => Err("O MD5 recalculado difere do gravado na imagem.".into()),
-                None => {
-                    println!("Esta imagem não traz MD5 para conferir.");
-                    Ok(())
-                }
-            }
-        }
         Cmd::Verify { path } => {
-            let e = guara_core::ewf::EwfSource::open(std::path::Path::new(&path)).map_err(s)?;
-            println!(
-                "Formato: {}",
-                if e.info.version == 2 {
-                    "Ex01 (EnCase 7)"
-                } else {
-                    "E01 (EnCase)"
-                }
+            let r = verify_image(&path);
+            guara_core::audit::record(
+                "verify",
+                json!({ "path": path, "result": match &r { Ok(Some(true)) => "conferem", Ok(Some(false)) => "diferem", Ok(None) => "sem hash gravado", Err(_) => "erro" } }),
             );
-            println!("Segmentos: {}", e.info.segments);
-            for (k, v) in &e.info.fields {
-                println!("{k}: {v}");
-            }
-            eprintln!("Recalculando o hash...");
-            match e.verify().map_err(s)? {
-                Some(true) => {
-                    println!("MD5 gravado e recalculado conferem: {}", e.info.md5.clone().unwrap_or_default());
-                    Ok(())
-                }
-                Some(false) => Err("O MD5 recalculado difere do gravado na imagem: ela está corrompida ou foi alterada.".into()),
-                None => {
-                    println!("Esta imagem não traz hash gravado para conferir.");
-                    Ok(())
-                }
-            }
+            r.map(|_| ())
         }
+        Cmd::Audit {
+            log,
+            verify,
+            tail,
+            json,
+        } => audit(log, verify, tail, json),
+        Cmd::Sign(c) => sign_cmd(c),
         Cmd::Image {
             path,
             dest,
@@ -790,6 +815,225 @@ fn recover_job(
     Ok(())
 }
 
+/// Confere o hash gravado numa imagem E01/Ex01 ou AFF4. `Some(true)` = confere.
+fn verify_image(path: &str) -> Result<Option<bool>, String> {
+    if path.to_ascii_lowercase().ends_with(".aff4") {
+        let a = guara_core::aff4::Aff4Source::open(std::path::Path::new(path)).map_err(s)?;
+        println!("Formato: AFF4");
+        for (k, v) in &a.info {
+            println!("{k}: {v}");
+        }
+        eprintln!("Recalculando o hash...");
+        return match a.verify_stream_md5().map_err(s)? {
+            Some(true) => {
+                println!("MD5 gravado e recalculado conferem.");
+                Ok(Some(true))
+            }
+            Some(false) => Err("O MD5 recalculado difere do gravado na imagem.".into()),
+            None => {
+                println!("Esta imagem não traz MD5 para conferir.");
+                Ok(None)
+            }
+        };
+    }
+    let e = guara_core::ewf::EwfSource::open(std::path::Path::new(path)).map_err(s)?;
+    println!(
+        "Formato: {}",
+        if e.info.version == 2 {
+            "Ex01 (EnCase 7)"
+        } else {
+            "E01 (EnCase)"
+        }
+    );
+    println!("Segmentos: {}", e.info.segments);
+    for (k, v) in &e.info.fields {
+        println!("{k}: {v}");
+    }
+    eprintln!("Recalculando o hash...");
+    match e.verify().map_err(s)? {
+        Some(true) => {
+            println!(
+                "MD5 gravado e recalculado conferem: {}",
+                e.info.md5.clone().unwrap_or_default()
+            );
+            Ok(Some(true))
+        }
+        Some(false) => Err(
+            "O MD5 recalculado difere do gravado na imagem: ela está corrompida ou foi alterada."
+                .into(),
+        ),
+        None => {
+            println!("Esta imagem não traz hash gravado para conferir.");
+            Ok(None)
+        }
+    }
+}
+
+/// `guara audit`: lista a trilha ou confere a cadeia de hashes.
+fn audit(log: Option<String>, verify: bool, tail: Option<usize>, json: bool) -> Result<(), String> {
+    let log = match log {
+        Some(p) => guara_core::audit::Log::at(p),
+        None => guara_core::audit::Log::open_default(),
+    };
+    let v = log.verify().map_err(s)?;
+    if verify {
+        if json {
+            println!("{}", serde_json::to_string_pretty(&v).unwrap());
+        } else if v.ok {
+            println!("Cadeia íntegra: {} entradas.", v.entries);
+            if v.entries > 0 {
+                println!(
+                    "Hash da última entrada (guarde-o fora desta máquina): {}",
+                    v.head
+                );
+            }
+        }
+        return match v.broken_at {
+            None => Ok(()),
+            Some((n, why)) => Err(format!("cadeia quebrada na entrada {n}: {why}")),
+        };
+    }
+    let mut entries = log.entries().map_err(s)?;
+    if let Some(n) = tail {
+        let skip = entries.len().saturating_sub(n);
+        entries.drain(..skip);
+    }
+    if json {
+        println!("{}", serde_json::to_string_pretty(&entries).unwrap());
+    } else if entries.is_empty() {
+        println!("Trilha vazia ({}).", log.path().display());
+    } else {
+        for e in &entries {
+            let who = match &e.examiner {
+                Some(x) => format!("{}/{x}", e.user),
+                None => e.user.clone(),
+            };
+            println!(
+                "#{:<4} {}  {who}@{}  {}  {}",
+                e.seq, e.time, e.host, e.action, e.detail
+            );
+        }
+    }
+    if !v.ok {
+        let (n, why) = v.broken_at.unwrap_or_default();
+        eprintln!(
+            "{} cadeia quebrada na entrada {n}: {why}",
+            paint("31", "atenção:")
+        );
+    }
+    Ok(())
+}
+
+/// `guara sign`: chaves, assinatura e conferência.
+fn sign_cmd(c: SignCmd) -> Result<(), String> {
+    use guara_core::sign;
+    use std::path::{Path, PathBuf};
+    let key_path = |k: Option<String>| k.map(PathBuf::from).unwrap_or_else(sign::default_key_path);
+    match c {
+        SignCmd::Keygen { key } => {
+            let p = key_path(key);
+            let k = sign::SigningKey::generate();
+            k.save(&p).map_err(s)?;
+            guara_core::audit::record("sign.keygen", json!({ "fingerprint": k.fingerprint() }));
+            println!(
+                "Chave privada: {} (guarde uma cópia segura; quem a tem assina em seu nome)",
+                p.display()
+            );
+            println!("Chave pública: {}", p.with_extension("pub").display());
+            println!("Impressão digital: {}", k.fingerprint());
+            println!("Publique a impressão digital fora desta máquina para que outros confiram as assinaturas.");
+            Ok(())
+        }
+        SignCmd::File { path, key, signer } => {
+            let p = key_path(key);
+            let k = sign::SigningKey::load(&p).map_err(s)?;
+            let who = signer.or_else(|| std::env::var("GUARA_EXAMINER").ok());
+            let out = sign::sign_file(&k, Path::new(&path), who.as_deref()).map_err(s)?;
+            guara_core::audit::record(
+                "sign",
+                json!({ "path": path, "signature": out.to_string_lossy() }),
+            );
+            println!("Assinatura gravada em {}", out.display());
+            println!("Impressão digital da chave: {}", k.fingerprint());
+            Ok(())
+        }
+        SignCmd::Verify {
+            path,
+            sig,
+            trust,
+            json,
+        } => {
+            let c = sign::verify_file(
+                Path::new(&path),
+                sig.as_deref().map(Path::new),
+                trust.as_deref(),
+            )
+            .map_err(s)?;
+            guara_core::audit::record("sign.verify", json!({ "path": path, "valid": c.valid }));
+            if json {
+                println!("{}", serde_json::to_string_pretty(&c).unwrap());
+            } else if c.valid {
+                println!("Assinatura válida: o arquivo não mudou desde que foi assinado.");
+                println!(
+                    "Chave: {}  ·  assinado em {}{}",
+                    c.fingerprint,
+                    c.signed_at,
+                    c.signer
+                        .as_ref()
+                        .map(|s| format!(" por {s}"))
+                        .unwrap_or_default()
+                );
+                if c.trusted.is_none() {
+                    println!(
+                        "Confira a impressão digital acima com a que o perito publicou (--trust)."
+                    );
+                }
+            }
+            if c.valid {
+                Ok(())
+            } else {
+                Err(c.problems.join("; "))
+            }
+        }
+        SignCmd::Recovery { dir, trust, json } => {
+            let c = sign::verify_recovery(Path::new(&dir), trust.as_deref()).map_err(s)?;
+            guara_core::audit::record(
+                "sign.verify_recovery",
+                json!({ "dir": dir, "valid": c.valid, "files": c.files }),
+            );
+            if json {
+                println!("{}", serde_json::to_string_pretty(&c).unwrap());
+            } else {
+                println!(
+                    "{} de {} arquivo(s) conferem com o manifesto.",
+                    c.ok, c.files
+                );
+                for f in &c.missing {
+                    println!("  ausente: {f}");
+                }
+                for f in &c.changed {
+                    println!("  alterado: {f}");
+                }
+                match &c.manifest_signature {
+                    Some(m) if m.valid => {
+                        println!("Manifesto assinado e íntegro. Chave: {}", m.fingerprint)
+                    }
+                    Some(m) => println!(
+                        "Assinatura do manifesto com problema: {}",
+                        m.problems.join("; ")
+                    ),
+                    None => println!("Manifesto sem assinatura (assine com guara sign file)."),
+                }
+            }
+            if c.valid {
+                Ok(())
+            } else {
+                Err("a recuperação não confere".into())
+            }
+        }
+    }
+}
+
 fn wait(eng: &Engine, job: &str, session: Option<&str>) -> Result<Value, String> {
     let interrupted = Arc::new(AtomicBool::new(false));
     let flag = interrupted.clone();

crates/guara-cli/src/serve.rs

@@ -12,9 +12,9 @@ const JS: &str = include_str!("../../../apps/gui/ui/app.js");
 const PREVIEW_JS: &str = include_str!("../../../apps/gui/ui/preview.js");
 const I18N_JS: &str = include_str!("../../../apps/gui/ui/i18n.js");
 const I18N_EN_JS: &str = include_str!("../../../apps/gui/ui/i18n-en.js");
-const LOGO: &str = include_str!("../../../apps/gui/ui/guara-logo.svg");
 const EXPLORER_JS: &str = include_str!("../../../apps/gui/ui/explorer.js");
-const ICON: &str = include_str!("../../../apps/gui/ui/guara.svg");
+const LOGO: &[u8] = include_bytes!("../../../apps/gui/ui/guara.png");
+const LOGO_S: &[u8] = include_bytes!("../../../apps/gui/ui/guara-s.png");
 const PDF_JS: &str = include_str!("../../../apps/gui/ui/vendor/pdf.min.mjs");
 const PDF_WORKER: &str = include_str!("../../../apps/gui/ui/vendor/pdf.worker.min.mjs");
 
@@ -98,8 +98,11 @@ fn handle(req: Request, eng: &Engine, token: &str, hosts: &[String]) {
                 Response::from_string(I18N_EN_JS).with_header(ct("text/javascript; charset=utf-8")),
             );
         }
-        (Method::Get, "/guara-logo.svg") => {
-            let _ = req.respond(Response::from_string(LOGO).with_header(ct("image/svg+xml")));
+        (Method::Get, "/guara.png") => {
+            let _ = req.respond(Response::from_data(LOGO).with_header(ct("image/png")));
+        }
+        (Method::Get, "/guara-s.png") => {
+            let _ = req.respond(Response::from_data(LOGO_S).with_header(ct("image/png")));
         }
         (Method::Get, "/explorer.js") => {
             let _ = req.respond(
@@ -107,9 +110,6 @@ fn handle(req: Request, eng: &Engine, token: &str, hosts: &[String]) {
                     .with_header(ct("text/javascript; charset=utf-8")),
             );
         }
-        (Method::Get, "/guara.svg") => {
-            let _ = req.respond(Response::from_string(ICON).with_header(ct("image/svg+xml")));
-        }
         (Method::Get, "/vendor/pdf.min.mjs") => {
             let _ = req.respond(
                 Response::from_string(PDF_JS).with_header(ct("text/javascript; charset=utf-8")),

crates/guara-core/Cargo.toml

@@ -14,7 +14,7 @@ sha2 = "0.11"
 sha1 = "0.11"
 md-5 = "0.11"
 jpeg-decoder = { version = "0.3", default-features = false }
-jpeg-encoder = "0.6"
+jpeg-encoder = "0.7"
 image = { version = "0.25", default-features = false, features = ["png", "gif", "bmp", "webp"] }
 flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
 thiserror = "2"
@@ -23,12 +23,14 @@ bzip2 = "0.6"
 zip = { version = "9", default-features = false, features = ["deflate"] }
 snap = "1"
 ruzstd = "0.9"
-lz4_flex = { version = "0.11", default-features = false, features = ["safe-decode", "safe-encode"] }
+lz4_flex = { version = "0.14", default-features = false, features = ["alloc", "safe-decode", "safe-encode"] }
 aes = "0.9"
 hmac = "0.13"
 pbkdf2 = { version = "0.13", default-features = false, features = ["hmac"] }
 ripemd = "0.2"
 argon2 = "0.6"
+ed25519-compact = { version = "2", default-features = false, features = ["random", "std"] }
+lzfse_rust = "0.2.1"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"

crates/guara-core/src/audit.rs

@@ -0,0 +1,324 @@
+//! Trilha de auditoria: cada ação do examinador (abrir uma origem, varrer, recuperar, criar
+//! imagem, exportar) vira uma linha JSON com quem, quando e o quê.
+//!
+//! As linhas são encadeadas por hash: o `hash` de cada uma é o SHA-256 do `hash` da anterior
+//! seguido do corpo da própria linha. Alterar ou apagar uma linha do meio quebra a cadeia e
+//! `guara audit --verify` aponta onde. Cortar o fim do arquivo não é detectável sozinho; para
+//! isso, guarde o hash da última entrada (a "cabeça") fora da máquina, por exemplo no relatório.
+//!
+//! O arquivo fica na pasta de configuração (`auditoria.jsonl`) ou onde `GUARA_AUDIT_LOG`
+//! apontar. Segredos (senhas, chaves) nunca entram no registro.
+
+use crate::error::{Error, Result};
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::{Path, PathBuf};
+
+const GENESIS: &str = "0000000000000000000000000000000000000000000000000000000000000000";
+
+#[derive(Serialize)]
+struct Body<'a> {
+    seq: u64,
+    time: &'a str,
+    user: &'a str,
+    host: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    examiner: Option<&'a str>,
+    version: &'a str,
+    action: &'a str,
+    detail: &'a Value,
+    prev: &'a str,
+}
+
+/// Uma linha da trilha.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Entry {
+    pub seq: u64,
+    /// UTC, ISO 8601.
+    pub time: String,
+    pub user: String,
+    pub host: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub examiner: Option<String>,
+    pub version: String,
+    pub action: String,
+    pub detail: Value,
+    pub prev: String,
+    pub hash: String,
+}
+
+/// Resultado de conferir a cadeia.
+#[derive(Debug, Clone, Serialize)]
+pub struct Verification {
+    pub entries: usize,
+    pub ok: bool,
+    /// Entrada (1, 2, ...) onde a cadeia quebra e o motivo.
+    pub broken_at: Option<(u64, String)>,
+    /// Hash da última entrada; guarde-o fora da máquina para detectar truncamento.
+    pub head: String,
+}
+
+pub struct Log {
+    path: PathBuf,
+}
+
+fn sha_hex(prev: &str, body: &str) -> String {
+    let mut h = Sha256::new();
+    h.update(prev.as_bytes());
+    h.update(b"\n");
+    h.update(body.as_bytes());
+    h.finalize().iter().map(|b| format!("{b:02x}")).collect()
+}
+
+/// UTC em ISO 8601 a partir de segundos Unix (conversão civil de Howard Hinnant).
+pub fn utc_iso(secs: i64) -> String {
+    let days = secs.div_euclid(86400);
+    let rem = secs.rem_euclid(86400);
+    let z = days + 719468;
+    let era = z.div_euclid(146097);
+    let doe = z.rem_euclid(146097);
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    let y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    let y = if m <= 2 { y + 1 } else { y };
+    format!(
+        "{y:04}-{m:02}-{d:02}T{:02}:{:02}:{:02}Z",
+        rem / 3600,
+        rem % 3600 / 60,
+        rem % 60
+    )
+}
+
+fn now_iso() -> String {
+    let secs = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs() as i64)
+        .unwrap_or(0);
+    utc_iso(secs)
+}
+
+fn env(k: &str) -> Option<String> {
+    std::env::var(k).ok().filter(|v| !v.is_empty())
+}
+
+/// Usuário do sistema por trás da ação (o que chamou sudo, quando houver).
+fn current_user() -> String {
+    env("SUDO_USER")
+        .or_else(|| env("USER"))
+        .or_else(|| env("USERNAME"))
+        .or_else(|| env("LOGNAME"))
+        .unwrap_or_else(|| "?".into())
+}
+
+fn host_name() -> String {
+    env("HOSTNAME")
+        .or_else(|| env("COMPUTERNAME"))
+        .or_else(|| {
+            std::fs::read_to_string("/etc/hostname")
+                .ok()
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
+        })
+        .unwrap_or_else(|| "?".into())
+}
+
+/// Última linha não vazia do arquivo, lendo só o fim.
+fn last_line(path: &Path) -> std::io::Result<Option<String>> {
+    let mut f = match std::fs::File::open(path) {
+        Ok(f) => f,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(e) => return Err(e),
+    };
+    let len = f.metadata()?.len();
+    let mut want = 8192u64;
+    loop {
+        let start = len.saturating_sub(want);
+        f.seek(SeekFrom::Start(start))?;
+        let mut buf = vec![];
+        f.read_to_end(&mut buf)?;
+        let text = String::from_utf8_lossy(&buf);
+        let trimmed = text.trim_end();
+        match trimmed.rfind('\n') {
+            Some(i) => return Ok(Some(trimmed[i + 1..].to_string())),
+            None if start == 0 => {
+                return Ok((!trimmed.is_empty()).then(|| trimmed.to_string()));
+            }
+            None => want *= 4,
+        }
+    }
+}
+
+impl Log {
+    pub fn at(path: impl Into<PathBuf>) -> Self {
+        Self { path: path.into() }
+    }
+
+    /// `GUARA_AUDIT_LOG` ou `auditoria.jsonl` na pasta de configuração.
+    pub fn default_path() -> PathBuf {
+        match env("GUARA_AUDIT_LOG") {
+            Some(p) => PathBuf::from(p),
+            None => crate::settings::config_dir().join("auditoria.jsonl"),
+        }
+    }
+
+    pub fn open_default() -> Self {
+        Self::at(Self::default_path())
+    }
+
+    pub fn path(&self) -> &Path {
+        &self.path
+    }
+
+    /// Acrescenta uma entrada ao fim da cadeia.
+    pub fn append(&self, action: &str, detail: Value) -> Result<Entry> {
+        let (seq, prev) = match last_line(&self.path)? {
+            None => (1, GENESIS.to_string()),
+            Some(l) => {
+                let e: Entry = serde_json::from_str(&l)
+                    .map_err(|e| Error::msg(format!("última linha da trilha inválida: {e}")))?;
+                (e.seq + 1, e.hash)
+            }
+        };
+        let (time, user, host) = (now_iso(), current_user(), host_name());
+        let examiner = env("GUARA_EXAMINER");
+        let version = env!("CARGO_PKG_VERSION");
+        let body = serde_json::to_string(&Body {
+            seq,
+            time: &time,
+            user: &user,
+            host: &host,
+            examiner: examiner.as_deref(),
+            version,
+            action,
+            detail: &detail,
+            prev: &prev,
+        })?;
+        let hash = sha_hex(&prev, &body);
+        let line = format!("{},\"hash\":\"{hash}\"}}\n", &body[..body.len() - 1]);
+        if let Some(dir) = self.path.parent() {
+            crate::owner::create_dir_all_owned(dir)?;
+        }
+        let existed = self.path.exists();
+        let mut f = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&self.path)?;
+        f.write_all(line.as_bytes())?;
+        f.flush()?;
+        if !existed {
+            crate::owner::give_to_user(&self.path);
+        }
+        Ok(Entry {
+            seq,
+            time,
+            user,
+            host,
+            examiner,
+            version: version.into(),
+            action: action.into(),
+            detail,
+            prev,
+            hash,
+        })
+    }
+
+    /// Todas as entradas, na ordem. Linha ilegível vira erro (use [`Log::verify`] para saber onde).
+    pub fn entries(&self) -> Result<Vec<Entry>> {
+        let text = match std::fs::read_to_string(&self.path) {
+            Ok(t) => t,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
+            Err(e) => return Err(e.into()),
+        };
+        text.lines()
+            .filter(|l| !l.trim().is_empty())
+            .enumerate()
+            .map(|(i, l)| {
+                serde_json::from_str(l)
+                    .map_err(|e| Error::msg(format!("linha {} da trilha inválida: {e}", i + 1)))
+            })
+            .collect()
+    }
+
+    /// Confere a numeração, o encadeamento e o hash de cada linha.
+    pub fn verify(&self) -> Result<Verification> {
+        let text = match std::fs::read_to_string(&self.path) {
+            Ok(t) => t,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => String::new(),
+            Err(e) => return Err(e.into()),
+        };
+        let mut prev = GENESIS.to_string();
+        let mut n = 0usize;
+        let broken = |n: usize, why: &str, entries: usize, head: &str| Verification {
+            entries,
+            ok: false,
+            broken_at: Some((n as u64, why.to_string())),
+            head: head.to_string(),
+        };
+        for line in text.lines().filter(|l| !l.trim().is_empty()) {
+            n += 1;
+            let Ok(e) = serde_json::from_str::<Entry>(line) else {
+                return Ok(broken(n, "linha ilegível", n - 1, &prev));
+            };
+            if e.seq != n as u64 {
+                return Ok(broken(
+                    n,
+                    "numeração fora de ordem (entrada removida ou inserida)",
+                    n - 1,
+                    &prev,
+                ));
+            }
+            if e.prev != prev {
+                return Ok(broken(n, "não continua a entrada anterior", n - 1, &prev));
+            }
+            let Some(i) = line.rfind(",\"hash\":\"") else {
+                return Ok(broken(n, "linha sem hash", n - 1, &prev));
+            };
+            let body = format!("{}}}", &line[..i]);
+            if sha_hex(&prev, &body) != e.hash {
+                return Ok(broken(
+                    n,
+                    "conteúdo alterado (o hash não confere)",
+                    n - 1,
+                    &prev,
+                ));
+            }
+            prev = e.hash;
+        }
+        Ok(Verification {
+            entries: n,
+            ok: true,
+            broken_at: None,
+            head: prev,
+        })
+    }
+}
+
+/// Registra uma ação na trilha padrão. Falha ao gravar não interrompe a operação, mas é
+/// avisada no stderr: uma ação sem registro precisa ser notada.
+pub fn record(action: &str, detail: Value) {
+    if let Err(e) = Log::open_default().append(action, detail) {
+        eprintln!("aviso: não foi possível gravar a trilha de auditoria ({action}): {e}");
+    }
+}
+
+/// Atalho para detalhes de um caminho de origem.
+pub fn path_detail(path: &str) -> Value {
+    json!({ "path": path })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn iso_de_datas_conhecidas() {
+        assert_eq!(utc_iso(0), "1970-01-01T00:00:00Z");
+        assert_eq!(utc_iso(951_782_400), "2000-02-29T00:00:00Z");
+        assert_eq!(utc_iso(1_792_000_000 + 3661), "2026-10-14T18:47:41Z");
+    }
+}

crates/guara-core/src/fs/apfs.rs

@@ -3,7 +3,7 @@
 //! antigos da árvore (copy-on-write) que ainda estão no disco. Volumes cifrados (FileVault) são
 //! detectados e deixados para a varredura por assinatura.
 
-use super::{make_found, Ctx, NewFound, VolumeScan};
+use super::{make_found, merge_extents, Ctx, NewFound, VolumeScan};
 use crate::source::{read_vec, Source};
 use crate::types::{Confidence, DataLoc, Extent, Origin};
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -27,6 +27,9 @@ fn le64(b: &[u8], o: usize) -> u64 {
 const OBJ_TYPE_MASK: u32 = 0xFFFF;
 const T_BTREE_ROOT: u32 = 2;
 const T_BTREE_NODE: u32 = 3;
+const T_SPACEMAN: u32 = 5;
+const T_CIB: u32 = 7;
+const T_CHECKPOINT_MAP: u32 = 0x0C;
 const SUBTYPE_FSTREE: u32 = 0x0E;
 
 // tipos de registro da árvore de arquivos
@@ -170,6 +173,112 @@ impl<'a> Apfs<'a> {
         }
         m
     }
+
+    /// Endereço físico de um objeto ephemeral (spaceman), achado no mapa de checkpoint mais novo.
+    fn ephemeral_paddr(&self, nx: &[u8], oid: u64) -> Option<u64> {
+        let desc_blocks = le32(nx, 104) as u64;
+        let desc_base = le64(nx, 112);
+        let max_entries = (self.bs as usize).saturating_sub(40) / 40;
+        let mut best: Option<(u64, u64)> = None;
+        for i in 0..desc_blocks {
+            let Some(b) = self.checked_block(desc_base + i) else {
+                continue;
+            };
+            if le32(&b, 24) & OBJ_TYPE_MASK != T_CHECKPOINT_MAP {
+                continue;
+            }
+            let xid = le64(&b, 16);
+            if best.is_some_and(|(x, _)| x >= xid) {
+                continue;
+            }
+            let count = (le32(&b, 36) as usize).min(max_entries);
+            for j in 0..count {
+                let o = 40 + j * 40;
+                if le64(&b, o + 24) == oid {
+                    best = Some((xid, le64(&b, o + 32)));
+                    break;
+                }
+            }
+        }
+        best.map(|(_, p)| p)
+    }
+
+    /// Mapa de espaço livre do contêiner: percorre o spaceman, os chunk-info blocks e os bitmaps
+    /// (bit 1 = bloco em uso).
+    fn free_map(&self, nx: &[u8]) -> Option<Vec<Extent>> {
+        let sm_oid = le64(nx, 152);
+        if sm_oid == 0 {
+            return None;
+        }
+        let sm = self.checked_block(self.ephemeral_paddr(nx, sm_oid)?)?;
+        if le32(&sm, 24) & OBJ_TYPE_MASK != T_SPACEMAN {
+            return None;
+        }
+        // Com CABs (contêineres grandes) os endereços dos CIBs não ficam no spaceman.
+        if le32(&sm, 68) != 0 {
+            return None;
+        }
+        let cib_count = le32(&sm, 64) as usize;
+        let addr_off = le32(&sm, 80) as usize;
+        let end = addr_off.checked_add(cib_count.checked_mul(8)?)?;
+        if cib_count == 0 || end > sm.len() {
+            return None;
+        }
+        let per_cib = (self.bs as usize).saturating_sub(40) / 32;
+        let mut free = vec![];
+        for ci in 0..cib_count {
+            let cp = le64(&sm, addr_off + ci * 8);
+            let Some(cib) = self.checked_block(cp) else {
+                continue;
+            };
+            if le32(&cib, 24) & OBJ_TYPE_MASK != T_CIB {
+                continue;
+            }
+            let count = (le32(&cib, 36) as usize).min(per_cib);
+            for j in 0..count {
+                let o = 40 + j * 32;
+                let addr = le64(&cib, o + 8);
+                let n = le32(&cib, o + 16) as u64;
+                let bm = le64(&cib, o + 24);
+                if n == 0 || addr >= self.blocks {
+                    continue;
+                }
+                let n = n.min(self.blocks - addr);
+                if bm == 0 {
+                    free.push(Extent::new(self.base + addr * self.bs, n * self.bs));
+                    continue;
+                }
+                let Some(b) = self.block(bm) else {
+                    continue;
+                };
+                let mut run: Option<u64> = None;
+                for k in 0..n {
+                    let used = b
+                        .get((k / 8) as usize)
+                        .map(|x| x >> (k % 8) & 1 == 1)
+                        .unwrap_or(true);
+                    match (used, run) {
+                        (false, None) => run = Some(k),
+                        (true, Some(s)) => {
+                            free.push(Extent::new(
+                                self.base + (addr + s) * self.bs,
+                                (k - s) * self.bs,
+                            ));
+                            run = None;
+                        }
+                        _ => {}
+                    }
+                }
+                if let Some(s) = run {
+                    free.push(Extent::new(
+                        self.base + (addr + s) * self.bs,
+                        (n - s) * self.bs,
+                    ));
+                }
+            }
+        }
+        Some(merge_extents(free))
+    }
 }
 
 fn lookup(m: &HashMap<u64, Vec<(u64, u64)>>, oid: u64, max_xid: u64) -> Option<u64> {
@@ -399,6 +508,13 @@ pub fn scan(ctx: &mut Ctx, base: u64, part_len: u64) -> VolumeScan {
         return res;
     };
     let _ = cont_omap_block;
+    res.free = a.free_map(&nx);
+    if res.free.is_none() {
+        res.warnings.push(
+            "APFS: não foi possível ler o mapa de espaço livre; a varredura profunda usará todo o volume."
+                .into(),
+        );
+    }
     let container_omap = a.omap(le64(&nx, 160));
     let max_fs = le32(&nx, 180).min(100) as usize;
     let mut vols: Vec<Volume> = vec![];
@@ -610,6 +726,12 @@ fn scan_volume(ctx: &mut Ctx, a: &Apfs, v: &Volume, allow_stale_scan: bool, res:
     let _ = res;
 }
 
+/// Trechos livres (absolutos) do contêiner, segundo o spaceman.
+pub fn free_extents(src: &dyn Source, base: u64) -> Option<Vec<Extent>> {
+    let (a, nx) = open_container(src, base)?;
+    a.free_map(&nx)
+}
+
 /// Arquivos e pastas atuais do primeiro volume sem cifragem (caminho, tamanho, é pasta).
 pub fn live_paths(src: &dyn Source, base: u64) -> Vec<(String, u64, bool)> {
     let Some((a, nx)) = open_container(src, base) else {

crates/guara-core/src/lib.rs

@@ -12,6 +12,7 @@
 
 pub mod aff4;
 pub mod assemble;
+pub mod audit;
 pub mod carve;
 pub mod crypt;
 pub mod defrag;
@@ -33,6 +34,7 @@ pub mod mp4rebuild;
 pub mod notify;
 pub mod owner;
 pub mod partition;
+pub mod pdf;
 pub mod raid;
 pub mod raid_detect;
 pub mod reconnect;
@@ -42,11 +44,13 @@ pub mod scan;
 pub mod search;
 pub mod service;
 pub mod settings;
+pub mod sign;
 pub mod signatures;
 pub mod source;
 pub mod sqlite;
 pub mod thumb;
 pub mod types;
+pub mod vdisk;
 pub mod volume;
 
 pub use error::{Error, Result};

crates/guara-core/src/partition.rs

@@ -261,7 +261,7 @@ pub fn analyze(src: &dyn Source, search_lost: bool) -> DiskLayout {
         }
         if p.fs == FsKind::Apfs {
             layout.warnings.push(format!(
-                "Partição {} é APFS: leitura de metadados ainda não suportada; usando apenas varredura por assinatura. Se estiver cifrada (FileVault), nada será encontrado.",
+                "Partição {} é APFS: o mapa de espaço livre é lido do spaceman; se o volume estiver cifrado (FileVault), nada será encontrado sem a chave.",
                 p.index + 1
             ));
         }

crates/guara-core/src/pdf.rs

@@ -0,0 +1,484 @@
+//! Gerador mínimo de PDF (A4, texto e tabelas) para o relatório de recuperação.
+//!
+//! Usa só as fontes padrão do PDF (Helvetica, Helvetica-Bold e Courier) com codificação
+//! WinAnsi, então o arquivo é autocontido e não depende de fontes instaladas. Caracteres fora
+//! do Latin-1/WinAnsi viram `?`.
+
+use flate2::write::ZlibEncoder;
+use flate2::Compression;
+use std::io::Write;
+
+const W: f64 = 595.28;
+const H: f64 = 841.89;
+const MARGIN: f64 = 40.0;
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum Font {
+    Regular,
+    Bold,
+    Mono,
+}
+
+impl Font {
+    fn res(self) -> &'static str {
+        match self {
+            Font::Regular => "F1",
+            Font::Bold => "F2",
+            Font::Mono => "F3",
+        }
+    }
+}
+
+// Larguras AFM (milésimos de em) dos caracteres ASCII 32..=126.
+const HELV: [u16; 95] = [
+    278, 278, 355, 556, 556, 889, 667, 191, 333, 333, 389, 584, 278, 333, 278, 278, 556, 556, 556,
+    556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584, 584, 556, 1015, 667, 667, 722, 722, 667,
+    611, 778, 722, 278, 500, 667, 556, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667,
+    667, 611, 278, 278, 278, 469, 556, 333, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222, 500,
+    222, 833, 556, 556, 556, 556, 333, 500, 278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584,
+];
+const HELV_B: [u16; 95] = [
+    278, 333, 474, 556, 556, 889, 722, 238, 333, 333, 389, 584, 278, 333, 278, 278, 556, 556, 556,
+    556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584, 584, 611, 975, 722, 722, 722, 722, 667,
+    611, 778, 722, 278, 556, 722, 611, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667,
+    667, 611, 333, 278, 333, 584, 556, 333, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278, 556,
+    278, 889, 611, 611, 611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584,
+];
+
+/// Letra base de um caractere acentuado do Latin-1 (a largura é a da letra sem acento).
+fn base_letter(c: char) -> char {
+    match c {
+        'À'..='Å' => 'A',
+        'Ç' => 'C',
+        'È'..='Ë' => 'E',
+        'Ì'..='Ï' => 'I',
+        'Ñ' => 'N',
+        'Ò'..='Ö' | 'Ø' => 'O',
+        'Ù'..='Ü' => 'U',
+        'Ý' => 'Y',
+        'à'..='å' => 'a',
+        'ç' => 'c',
+        'è'..='ë' => 'e',
+        'ì'..='ï' => 'i',
+        'ñ' => 'n',
+        'ò'..='ö' | 'ø' => 'o',
+        'ù'..='ü' => 'u',
+        'ý' | 'ÿ' => 'y',
+        _ => '?',
+    }
+}
+
+fn char_width(c: char, f: Font) -> f64 {
+    if f == Font::Mono {
+        return 0.6;
+    }
+    let t = if f == Font::Bold { &HELV_B } else { &HELV };
+    let c = if (' '..='~').contains(&c) {
+        c
+    } else {
+        base_letter(c)
+    };
+    match c {
+        ' '..='~' => t[c as usize - 32] as f64 / 1000.0,
+        _ => 0.556,
+    }
+}
+
+pub fn text_width(s: &str, size: f64, f: Font) -> f64 {
+    s.chars().map(|c| char_width(c, f)).sum::<f64>() * size
+}
+
+/// Byte WinAnsi de um caractere (ou `?`).
+fn win_ansi(c: char) -> u8 {
+    let n = c as u32;
+    match c {
+        '€' => 0x80,
+        '‘' => 0x91,
+        '’' => 0x92,
+        '“' => 0x93,
+        '”' => 0x94,
+        '•' => 0x95,
+        '–' => 0x96,
+        '—' => 0x97,
+        '…' => 0x85,
+        _ if (0x20..=0x7E).contains(&n) || (0xA0..=0xFF).contains(&n) => n as u8,
+        _ => b'?',
+    }
+}
+
+fn escape(s: &str) -> String {
+    let mut o = String::new();
+    for c in s.chars() {
+        match win_ansi(c) {
+            b'(' => o.push_str("\\("),
+            b')' => o.push_str("\\)"),
+            b'\\' => o.push_str("\\\\"),
+            b if (0x20..0x7F).contains(&b) => o.push(b as char),
+            b => o.push_str(&format!("\\{b:03o}")),
+        }
+    }
+    o
+}
+
+/// Quebra `s` em linhas de no máximo `width` pontos. Sem espaço onde quebrar (caminhos,
+/// hashes), corta no meio da palavra.
+pub fn wrap(s: &str, size: f64, f: Font, width: f64) -> Vec<String> {
+    let mut lines = vec![];
+    for para in s.split('\n') {
+        let mut cur = String::new();
+        let mut cur_w = 0.0;
+        for word in para.split(' ') {
+            let ww = text_width(word, size, f);
+            let sp = if cur.is_empty() {
+                0.0
+            } else {
+                char_width(' ', f) * size
+            };
+            if cur_w + sp + ww <= width {
+                if !cur.is_empty() {
+                    cur.push(' ');
+                }
+                cur.push_str(word);
+                cur_w += sp + ww;
+                continue;
+            }
+            if !cur.is_empty() {
+                lines.push(std::mem::take(&mut cur));
+                cur_w = 0.0;
+            }
+            if ww <= width {
+                cur = word.to_string();
+                cur_w = ww;
+            } else {
+                for c in word.chars() {
+                    let cw = char_width(c, f) * size;
+                    if cur_w + cw > width && !cur.is_empty() {
+                        lines.push(std::mem::take(&mut cur));
+                        cur_w = 0.0;
+                    }
+                    cur.push(c);
+                    cur_w += cw;
+                }
+            }
+        }
+        lines.push(cur);
+    }
+    lines
+}
+
+pub struct Col {
+    pub title: &'static str,
+    pub width: f64,
+    pub font: Font,
+    pub right: bool,
+}
+
+pub struct Pdf {
+    title: String,
+    footer: String,
+    pages: Vec<String>,
+    cur: String,
+    y: f64,
+}
+
+type Rgb = (f64, f64, f64);
+pub const TEAL: Rgb = (0.059, 0.463, 0.431);
+pub const GRAY: Rgb = (0.36, 0.43, 0.42);
+pub const BLACK: Rgb = (0.06, 0.12, 0.12);
+
+impl Pdf {
+    pub fn new(title: &str, footer: &str) -> Self {
+        Self {
+            title: title.into(),
+            footer: footer.into(),
+            pages: vec![],
+            cur: String::new(),
+            y: H - MARGIN,
+        }
+    }
+
+    pub fn content_width() -> f64 {
+        W - 2.0 * MARGIN
+    }
+
+    fn new_page(&mut self) {
+        if !self.cur.is_empty() || self.y != H - MARGIN {
+            self.pages.push(std::mem::take(&mut self.cur));
+        }
+        self.y = H - MARGIN;
+    }
+
+    fn ensure(&mut self, h: f64) {
+        if self.y - h < MARGIN + 14.0 {
+            self.new_page();
+        }
+    }
+
+    fn put(&mut self, x: f64, y: f64, s: &str, size: f64, f: Font, c: Rgb) {
+        if s.is_empty() {
+            return;
+        }
+        self.cur.push_str(&format!(
+            "BT /{} {size:.1} Tf {:.3} {:.3} {:.3} rg {x:.2} {y:.2} Td ({}) Tj ET\n",
+            f.res(),
+            c.0,
+            c.1,
+            c.2,
+            escape(s)
+        ));
+    }
+
+    fn rect(&mut self, x: f64, y: f64, w: f64, h: f64, c: Rgb) {
+        self.cur.push_str(&format!(
+            "{:.3} {:.3} {:.3} rg {x:.2} {y:.2} {w:.2} {h:.2} re f\n",
+            c.0, c.1, c.2
+        ));
+    }
+
+    fn line(&mut self, x1: f64, x2: f64, y: f64, c: Rgb, w: f64) {
+        self.cur.push_str(&format!(
+            "{:.3} {:.3} {:.3} RG {w} w {x1:.2} {y:.2} m {x2:.2} {y:.2} l S\n",
+            c.0, c.1, c.2
+        ));
+    }
+
+    pub fn space(&mut self, h: f64) {
+        self.y -= h;
+    }
+
+    pub fn title(&mut self, s: &str, sub: &str) {
+        self.ensure(60.0);
+        self.put(MARGIN, self.y - 20.0, s, 20.0, Font::Bold, BLACK);
+        self.put(MARGIN, self.y - 36.0, sub, 9.0, Font::Regular, GRAY);
+        self.line(MARGIN, W - MARGIN, self.y - 44.0, TEAL, 2.0);
+        self.y -= 58.0;
+    }
+
+    pub fn heading(&mut self, s: &str) {
+        self.ensure(50.0);
+        self.y -= 14.0;
+        self.put(MARGIN, self.y - 11.0, s, 12.0, Font::Bold, TEAL);
+        self.y -= 20.0;
+    }
+
+    pub fn paragraph(&mut self, s: &str, size: f64, f: Font, c: Rgb) {
+        for l in wrap(s, size, f, Self::content_width()) {
+            self.ensure(size * 1.4);
+            self.put(MARGIN, self.y - size, &l, size, f, c);
+            self.y -= size * 1.4;
+        }
+        self.y -= 3.0;
+    }
+
+    /// Aviso destacado com barra lateral.
+    pub fn note(&mut self, s: &str) {
+        let size = 9.0;
+        let lines = wrap(s, size, Font::Regular, Self::content_width() - 16.0);
+        let h = lines.len() as f64 * size * 1.4 + 8.0;
+        self.ensure(h + 4.0);
+        let top = self.y;
+        self.rect(MARGIN, top - h, Self::content_width(), h, (1.0, 0.97, 0.88));
+        self.rect(MARGIN, top - h, 3.0, h, (0.88, 0.63, 0.0));
+        for (i, l) in lines.iter().enumerate() {
+            self.put(
+                MARGIN + 10.0,
+                top - 4.0 - size * 1.4 * (i as f64 + 0.8),
+                l,
+                size,
+                Font::Regular,
+                BLACK,
+            );
+        }
+        self.y -= h + 6.0;
+    }
+
+    /// Linhas rótulo/valor; o valor pode ser monoespaçado.
+    pub fn kv(&mut self, rows: &[(&str, &str, Font)]) {
+        let lw = 140.0;
+        let size = 9.5;
+        for (k, v, f) in rows {
+            let lines = wrap(v, size, *f, Self::content_width() - lw - 8.0);
+            let h = lines.len() as f64 * size * 1.4 + 6.0;
+            self.ensure(h);
+            let top = self.y;
+            self.put(MARGIN + 4.0, top - size - 3.0, k, size, Font::Regular, GRAY);
+            for (i, l) in lines.iter().enumerate() {
+                self.put(
+                    MARGIN + lw,
+                    top - size - 3.0 - i as f64 * size * 1.4,
+                    l,
+                    size,
+                    *f,
+                    BLACK,
+                );
+            }
+            self.line(MARGIN, W - MARGIN, top - h, (0.89, 0.93, 0.93), 0.5);
+            self.y -= h;
+        }
+        self.y -= 4.0;
+    }
+
+    /// Tabela com cabeçalho repetido a cada página e linhas que quebram texto.
+    pub fn table(&mut self, cols: &[Col], rows: &[Vec<String>]) {
+        let size = 8.0;
+        let pad = 3.0;
+        let header = |p: &mut Pdf| {
+            let h = size * 1.4 + 2.0 * pad;
+            p.ensure(h + 2.0 * size * 1.4);
+            let top = p.y;
+            p.rect(
+                MARGIN,
+                top - h,
+                Self::content_width(),
+                h,
+                (0.906, 0.953, 0.949),
+            );
+            let mut x = MARGIN;
+            for c in cols {
+                let tx = if c.right {
+                    x + c.width - pad - text_width(c.title, size, Font::Bold)
+                } else {
+                    x + pad
+                };
+                p.put(
+                    tx,
+                    top - pad - size,
+                    c.title,
+                    size,
+                    Font::Bold,
+                    (0.043, 0.31, 0.29),
+                );
+                x += c.width;
+            }
+            p.y -= h;
+        };
+        header(self);
+        for row in rows {
+            let cells: Vec<Vec<String>> = cols
+                .iter()
+                .zip(row)
+                .map(|(c, t)| wrap(t, size, c.font, c.width - 2.0 * pad))
+                .collect();
+            let n = cells.iter().map(|c| c.len()).max().unwrap_or(1).max(1);
+            let h = n as f64 * size * 1.35 + 2.0 * pad;
+            if self.y - h < MARGIN + 14.0 {
+                self.new_page();
+                header(self);
+            }
+            let top = self.y;
+            let mut x = MARGIN;
+            for (c, lines) in cols.iter().zip(&cells) {
+                for (i, l) in lines.iter().enumerate() {
+                    let tx = if c.right {
+                        x + c.width - pad - text_width(l, size, c.font)
+                    } else {
+                        x + pad
+                    };
+                    self.put(
+                        tx,
+                        top - pad - size - i as f64 * size * 1.35,
+                        l,
+                        size,
+                        c.font,
+                        BLACK,
+                    );
+                }
+                x += c.width;
+            }
+            self.line(MARGIN, W - MARGIN, top - h, (0.89, 0.93, 0.93), 0.5);
+            self.y -= h;
+        }
+        self.y -= 6.0;
+    }
+
+    /// Fecha o documento. `date` é a data de criação em UTC (`AAAAMMDDHHMMSS`).
+    pub fn finish(mut self, date: &str) -> Vec<u8> {
+        if !self.cur.is_empty() || self.pages.is_empty() {
+            self.pages.push(std::mem::take(&mut self.cur));
+        }
+        let total = self.pages.len();
+        for (i, p) in self.pages.iter_mut().enumerate() {
+            let label = format!("{}  ·  página {} de {total}", self.footer, i + 1);
+            let x = W - MARGIN - text_width(&label, 8.0, Font::Regular);
+            p.push_str(&format!(
+                "BT /F1 8 Tf {:.3} {:.3} {:.3} rg {x:.2} 24 Td ({}) Tj ET\n",
+                GRAY.0,
+                GRAY.1,
+                GRAY.2,
+                escape(&label)
+            ));
+        }
+        let mut out: Vec<u8> = b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n".to_vec();
+        let mut offsets: Vec<usize> = vec![];
+        let mut obj = |out: &mut Vec<u8>, body: &[u8]| {
+            offsets.push(out.len());
+            out.extend_from_slice(format!("{} 0 obj\n", offsets.len()).as_bytes());
+            out.extend_from_slice(body);
+            out.extend_from_slice(b"\nendobj\n");
+        };
+        // 1 catálogo, 2 páginas, 3-5 fontes, 6 info, depois (página, conteúdo) por página
+        obj(&mut out, b"<< /Type /Catalog /Pages 2 0 R >>");
+        let kids: String = (0..total)
+            .map(|i| format!("{} 0 R", 7 + 2 * i))
+            .collect::<Vec<_>>()
+            .join(" ");
+        obj(
+            &mut out,
+            format!("<< /Type /Pages /Kids [{kids}] /Count {total} >>").as_bytes(),
+        );
+        for name in ["Helvetica", "Helvetica-Bold", "Courier"] {
+            obj(
+                &mut out,
+                format!(
+                    "<< /Type /Font /Subtype /Type1 /BaseFont /{name} /Encoding /WinAnsiEncoding >>"
+                )
+                .as_bytes(),
+            );
+        }
+        let title: String = format!("\u{feff}{}", self.title)
+            .encode_utf16()
+            .map(|u| format!("{u:04X}"))
+            .collect();
+        obj(
+            &mut out,
+            format!(
+                "<< /Title <{title}> /Producer (Guara {}) /CreationDate (D:{date}Z) >>",
+                env!("CARGO_PKG_VERSION")
+            )
+            .as_bytes(),
+        );
+        for (i, p) in self.pages.iter().enumerate() {
+            obj(
+                &mut out,
+                format!(
+                    "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {W} {H}] /Resources << /Font << /F1 3 0 R /F2 4 0 R /F3 5 0 R >> >> /Contents {} 0 R >>",
+                    8 + 2 * i
+                )
+                .as_bytes(),
+            );
+            let mut z = ZlibEncoder::new(vec![], Compression::default());
+            z.write_all(p.as_bytes()).unwrap();
+            let z = z.finish().unwrap();
+            let mut body =
+                format!("<< /Length {} /Filter /FlateDecode >>\nstream\n", z.len()).into_bytes();
+            body.extend_from_slice(&z);
+            body.extend_from_slice(b"\nendstream");
+            obj(&mut out, &body);
+        }
+        let xref = out.len();
+        out.extend_from_slice(
+            format!("xref\n0 {}\n0000000000 65535 f \n", offsets.len() + 1).as_bytes(),
+        );
+        for o in &offsets {
+            out.extend_from_slice(format!("{o:010} 00000 n \n").as_bytes());
+        }
+        out.extend_from_slice(
+            format!(
+                "trailer\n<< /Size {} /Root 1 0 R /Info 6 0 R >>\nstartxref\n{xref}\n%%EOF\n",
+                offsets.len() + 1
+            )
+            .as_bytes(),
+        );
+        out
+    }
+}

crates/guara-core/src/recover.rs

@@ -286,10 +286,9 @@ pub fn recover_resumable(
         "algoritmos_hash": ["MD5", "SHA-1", "SHA-256"],
         "relatorio": &report,
     });
-    crate::owner::write_owned(
-        &dest.join("guara-manifesto.json"),
-        serde_json::to_vec_pretty(&manifest)?,
-    )?;
+    let manifest_path = dest.join("guara-manifesto.json");
+    crate::owner::write_owned(&manifest_path, serde_json::to_vec_pretty(&manifest)?)?;
+    crate::sign::sign_if_configured(&manifest_path);
     Ok(report)
 }
 

crates/guara-core/src/report.rs

@@ -19,6 +19,14 @@ pub struct CaseInfo {
     pub notes: String,
 }
 
+/// Situação da trilha de auditoria no momento do relatório.
+pub struct AuditNote {
+    pub entries: usize,
+    pub ok: bool,
+    /// Hash da última entrada, para guardar fora da máquina.
+    pub head: String,
+}
+
 pub struct ReportInput<'a> {
     pub case: &'a CaseInfo,
     pub target: &'a str,
@@ -30,6 +38,7 @@ pub struct ReportInput<'a> {
     pub elapsed: f64,
     pub recoveries: &'a [RecoverReport],
     pub source_hashes: Option<&'a Hashes>,
+    pub audit: Option<AuditNote>,
 }
 
 fn cell(s: &str) -> String {
@@ -190,6 +199,15 @@ footer{margin-top:34px;color:#5b6f6d;font-size:12px}@media print{body{background
         if r.options.include_allocated { ", incluindo áreas em uso" } else { "" }
     ));
 
+    if let Some(a) = &r.audit {
+        o.push_str(&format!(
+            "<h2>Trilha de auditoria</h2><table class=\"kv\"><tr><td>Entradas</td><td>{}</td></tr><tr><td>Encadeamento</td><td>{}</td></tr><tr><td>Hash da última entrada</td><td class=\"mono\">{}</td></tr></table>",
+            a.entries,
+            if a.ok { "íntegro" } else { "QUEBRADO: confira com guara audit --verify" },
+            esc(&a.head)
+        ));
+    }
+
     if let Some(l) = r.layout {
         o.push_str("<h2>Partições</h2><table><tr><th>#</th><th>Sistema</th><th>Início (bytes)</th><th>Tamanho</th><th>Rótulo</th><th>Observação</th></tr>");
         for p in &l.partitions {
@@ -299,3 +317,361 @@ footer{margin-top:34px;color:#5b6f6d;font-size:12px}@media print{body{background
     o.push_str("</table><footer>Este relatório descreve o que o Guará encontrou e recuperou. Arquivos de confiança baixa podem estar incompletos ou sobrescritos. Datas dos metadados do sistema de arquivos estão em UTC. Guará é software livre, sem garantias.</footer></main></body></html>");
     o
 }
+
+/// Relatório em PDF (A4), com as mesmas seções do HTML.
+pub fn pdf(r: &ReportInput) -> Vec<u8> {
+    use crate::pdf::{Col, Font, Pdf, BLACK, GRAY};
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs() as i64)
+        .unwrap_or(0);
+    let stamp = crate::audit::utc_iso(now);
+    let version = env!("CARGO_PKG_VERSION");
+    let mut d = Pdf::new(
+        "Guará: relatório de recuperação",
+        &format!("Guará {version}"),
+    );
+    d.title(
+        "Relatório de recuperação de arquivos",
+        &format!("Gerado pelo Guará {version} em {}", fmt_unix(now)),
+    );
+
+    let nf = |v: &str| {
+        if v.is_empty() {
+            "não informado".to_string()
+        } else {
+            v.to_string()
+        }
+    };
+    d.heading("Identificação do caso");
+    let mut rows = vec![
+        ("Número do caso", nf(&r.case.case_id), Font::Regular),
+        (
+            "Responsável pelo exame",
+            nf(&r.case.examiner),
+            Font::Regular,
+        ),
+        ("Organização", nf(&r.case.organization), Font::Regular),
+    ];
+    if !r.case.notes.is_empty() {
+        rows.push(("Observações", r.case.notes.clone(), Font::Regular));
+    }
+    let rows: Vec<(&str, &str, Font)> = rows.iter().map(|(k, v, f)| (*k, v.as_str(), *f)).collect();
+    d.kv(&rows);
+
+    d.heading("Origem examinada");
+    let mut rows: Vec<(&str, String, Font)> =
+        vec![("Dispositivo / imagem", r.target.to_string(), Font::Mono)];
+    if let Some(l) = r.layout {
+        rows.push((
+            "Tamanho",
+            format!("{} ({} bytes)", human(l.size), l.size),
+            Font::Regular,
+        ));
+        rows.push(("Tabela de partições", l.table.to_uppercase(), Font::Regular));
+    }
+    rows.push((
+        "Hash da origem",
+        match r.source_hashes {
+            Some(h) => format!("MD5 {}\nSHA-1 {}\nSHA-256 {}", h.md5, h.sha1, h.sha256),
+            None => "não calculado nesta sessão (use guara hash ou guara image)".into(),
+        },
+        if r.source_hashes.is_some() {
+            Font::Mono
+        } else {
+            Font::Regular
+        },
+    ));
+    if let Some(t) = r.started_unix {
+        rows.push(("Início da varredura", fmt_unix(t), Font::Regular));
+    }
+    rows.push((
+        "Duração da varredura",
+        format!("{:.1} s", r.elapsed),
+        Font::Regular,
+    ));
+    rows.push((
+        "Modo",
+        format!(
+            "{}{}",
+            if r.options.mode == ScanMode::Deep {
+                "profunda (metadados + assinatura)"
+            } else {
+                "rápida (metadados)"
+            },
+            if r.options.include_allocated {
+                ", incluindo áreas em uso"
+            } else {
+                ""
+            }
+        ),
+        Font::Regular,
+    ));
+    rows.push((
+        "Garantia de leitura",
+        "A origem foi aberta somente para leitura; nenhuma escrita foi feita nela.".into(),
+        Font::Regular,
+    ));
+    let rows: Vec<(&str, &str, Font)> = rows.iter().map(|(k, v, f)| (*k, v.as_str(), *f)).collect();
+    d.kv(&rows);
+
+    if let Some(a) = &r.audit {
+        d.heading("Trilha de auditoria");
+        let ok = if a.ok {
+            "íntegro"
+        } else {
+            "QUEBRADO: confira com guara audit --verify"
+        };
+        d.kv(&[
+            ("Entradas", &a.entries.to_string(), Font::Regular),
+            ("Encadeamento", ok, Font::Regular),
+            ("Hash da última entrada", &a.head, Font::Mono),
+        ]);
+    }
+
+    if let Some(l) = r.layout {
+        d.heading("Partições");
+        let cols = [
+            Col {
+                title: "#",
+                width: 22.0,
+                font: Font::Regular,
+                right: false,
+            },
+            Col {
+                title: "Sistema",
+                width: 80.0,
+                font: Font::Regular,
+                right: false,
+            },
+            Col {
+                title: "Início (bytes)",
+                width: 90.0,
+                font: Font::Regular,
+                right: true,
+            },
+            Col {
+                title: "Tamanho",
+                width: 65.0,
+                font: Font::Regular,
+                right: true,
+            },
+            Col {
+                title: "Rótulo",
+                width: 90.0,
+                font: Font::Regular,
+                right: false,
+            },
+            Col {
+                title: "Observação",
+                width: 168.28,
+                font: Font::Regular,
+                right: false,
+            },
+        ];
+        let mut rows: Vec<Vec<String>> = l
+            .partitions
+            .iter()
+            .map(|p| {
+                let obs = [
+                    p.lost.then_some("encontrada por varredura".to_string()),
+                    p.encrypted
+                        .as_ref()
+                        .map(|e| format!("cifrada ({e}), não examinada")),
+                ]
+                .into_iter()
+                .flatten()
+                .collect::<Vec<_>>()
+                .join("; ");
+                vec![
+                    (p.index + 1).to_string(),
+                    p.fs.name().to_string(),
+                    p.start.to_string(),
+                    human(p.len),
+                    p.label.clone().unwrap_or_default(),
+                    obs,
+                ]
+            })
+            .collect();
+        for g in &l.gaps {
+            rows.push(vec![
+                "-".into(),
+                "espaço não particionado".into(),
+                g.start.to_string(),
+                human(g.len),
+                String::new(),
+                String::new(),
+            ]);
+        }
+        d.table(&cols, &rows);
+    }
+
+    let mut by_cat = std::collections::BTreeMap::new();
+    let mut conf = [0usize; 3];
+    let mut bytes = 0u64;
+    for f in r.found {
+        *by_cat.entry(f.category.label_pt()).or_insert(0usize) += 1;
+        conf[f.confidence as usize] += 1;
+        bytes += f.size;
+    }
+    d.heading("Resumo dos achados");
+    d.kv(&[
+        (
+            "Arquivos encontrados",
+            &format!("{} ({})", r.found.len(), human(bytes)),
+            Font::Bold,
+        ),
+        (
+            "Confiança",
+            &format!(
+                "alta {}  ·  média {}  ·  baixa {}",
+                conf[2], conf[1], conf[0]
+            ),
+            Font::Regular,
+        ),
+        (
+            "Por tipo",
+            &by_cat
+                .iter()
+                .map(|(k, v)| format!("{k}: {v}"))
+                .collect::<Vec<_>>()
+                .join("  ·  "),
+            Font::Regular,
+        ),
+    ]);
+    for w in r.warnings {
+        d.note(w);
+    }
+
+    if !r.recoveries.is_empty() {
+        d.heading("Arquivos recuperados (integridade)");
+        for rec in r.recoveries {
+            d.paragraph(
+                &format!(
+                    "Destino: {}, {} arquivo(s), {}{}",
+                    rec.destination,
+                    rec.recovered.len(),
+                    human(rec.total_bytes),
+                    if rec.failed.is_empty() {
+                        String::new()
+                    } else {
+                        format!(", {} falha(s)", rec.failed.len())
+                    }
+                ),
+                9.0,
+                Font::Regular,
+                BLACK,
+            );
+            let cols = [
+                Col {
+                    title: "Arquivo",
+                    width: 140.0,
+                    font: Font::Mono,
+                    right: false,
+                },
+                Col {
+                    title: "Tamanho",
+                    width: 55.0,
+                    font: Font::Regular,
+                    right: true,
+                },
+                Col {
+                    title: "Hashes",
+                    width: 320.28,
+                    font: Font::Mono,
+                    right: false,
+                },
+            ];
+            let rows: Vec<Vec<String>> = rec
+                .recovered
+                .iter()
+                .take(MAX_ROWS)
+                .map(|f| {
+                    vec![
+                        f.path.clone(),
+                        human(f.size),
+                        format!("MD5 {}\nSHA-1 {}\nSHA-256 {}", f.md5, f.sha1, f.sha256),
+                    ]
+                })
+                .collect();
+            d.table(&cols, &rows);
+        }
+    }
+
+    d.heading("Relação de arquivos encontrados");
+    if r.found.len() > MAX_ROWS {
+        d.note(&format!(
+            "Mostrando os primeiros {MAX_ROWS} de {}. Use a exportação CSV para a lista completa.",
+            r.found.len()
+        ));
+    }
+    let cols = [
+        Col {
+            title: "Nome",
+            width: 110.0,
+            font: Font::Regular,
+            right: false,
+        },
+        Col {
+            title: "Pasta",
+            width: 110.0,
+            font: Font::Regular,
+            right: false,
+        },
+        Col {
+            title: "Tamanho",
+            width: 50.0,
+            font: Font::Regular,
+            right: true,
+        },
+        Col {
+            title: "Modificado (UTC)",
+            width: 92.0,
+            font: Font::Regular,
+            right: false,
+        },
+        Col {
+            title: "Origem",
+            width: 50.0,
+            font: Font::Regular,
+            right: false,
+        },
+        Col {
+            title: "Conf.",
+            width: 32.0,
+            font: Font::Regular,
+            right: false,
+        },
+        Col {
+            title: "Posição",
+            width: 71.28,
+            font: Font::Mono,
+            right: true,
+        },
+    ];
+
+    let rows: Vec<Vec<String>> = r
+        .found
+        .iter()
+        .take(MAX_ROWS)
+        .map(|f| {
+            vec![
+                f.name.clone(),
+                f.dir.clone().unwrap_or_default(),
+                human(f.size),
+                iso(f.modified),
+                f.origin.label().to_string(),
+                f.confidence.label_pt().to_string(),
+                f.first_offset().map(|o| o.to_string()).unwrap_or_default(),
+            ]
+        })
+        .collect();
+    d.table(&cols, &rows);
+    d.paragraph(
+        "Este relatório descreve o que o Guará encontrou e recuperou. Arquivos de confiança baixa podem estar incompletos ou sobrescritos. Datas dos metadados do sistema de arquivos estão em UTC. Guará é software livre, sem garantias.",
+        8.0,
+        Font::Regular,
+        GRAY,
+    );
+    d.finish(&stamp.replace(['-', ':', 'T', 'Z'], ""))
+}

crates/guara-core/src/service.rs

@@ -247,6 +247,13 @@ impl Engine {
             }
             s.warnings.extend(asm.notes.iter().cloned());
         }
+        crate::audit::record(
+            "scan.start",
+            json!({
+                "job": job.id, "source": path, "size": asm.source.size(),
+                "fingerprint": fp, "encrypted_volumes_opened": asm.unlocked.len(),
+            }),
+        );
         *job.fingerprint.lock().unwrap() = fp;
         *job.session_file.lock().unwrap() = Some(new_session_path(path));
         spawn_scan(job.clone(), None);
@@ -487,6 +494,13 @@ impl Engine {
             }
         }
         recover::check_destination(Some(Path::new(&sj.target)), &dest_path)?;
+        crate::audit::record(
+            "recover.start",
+            json!({
+                "scan_job": sj.id, "source": sj.target, "destination": dest,
+                "files": files.len(), "bytes": total,
+            }),
+        );
         let job = self.register(
             JobKind::Recover,
             dest.to_string(),
@@ -525,6 +539,15 @@ impl Engine {
             let mut s = j2.st.lock().unwrap();
             match res {
                 Ok(rep) => {
+                    crate::audit::record(
+                        "recover.finish",
+                        json!({
+                            "scan_job": parent.id, "destination": rep.destination,
+                            "recovered": rep.recovered.len(), "failed": rep.failed.len(),
+                            "skipped": rep.skipped, "bytes": rep.total_bytes,
+                            "cancelled": rep.cancelled,
+                        }),
+                    );
                     s.report = serde_json::to_value(&rep).ok();
                     parent.st.lock().unwrap().recoveries.push(rep.clone());
                     if !rep.cancelled
@@ -571,6 +594,10 @@ impl Engine {
             Some(Path::new(path)),
             Path::new(dest).parent().unwrap_or(Path::new(".")),
         )?;
+        crate::audit::record(
+            "image.start",
+            json!({ "source": path, "destination": dest, "format": format!("{format:?}").split([' ', '{']).next().unwrap_or("").to_lowercase() }),
+        );
         let job = self.register(
             JobKind::Image,
             dest.to_string(),
@@ -592,6 +619,14 @@ impl Engine {
             let mut s = j2.st.lock().unwrap();
             match res {
                 Ok(rep) => {
+                    crate::audit::record(
+                        "image.finish",
+                        json!({
+                            "destination": dest, "bytes": rep.bytes, "md5": rep.md5,
+                            "sha1": rep.sha1, "sha256": rep.sha256,
+                            "unreadable_ranges": rep.bad_ranges.len(), "cancelled": rep.cancelled,
+                        }),
+                    );
                     s.status = if rep.cancelled {
                         Status::Stopped
                     } else {
@@ -620,6 +655,10 @@ impl Engine {
             None => s.found.iter().collect(),
         };
         crate::owner::write_owned(Path::new(path), crate::report::csv(&items))?;
+        crate::audit::record(
+            "export.csv",
+            json!({ "job": id, "source": j.target, "path": path, "rows": items.len() }),
+        );
         Ok(items.len())
     }
 
@@ -636,7 +675,16 @@ impl Engine {
         let elapsed = s
             .finished_in
             .unwrap_or_else(|| s.started.elapsed().as_secs_f64());
-        let html = crate::report::html(&crate::report::ReportInput {
+        let audit = crate::audit::Log::open_default()
+            .verify()
+            .ok()
+            .filter(|v| v.entries > 0)
+            .map(|v| crate::report::AuditNote {
+                entries: v.entries,
+                ok: v.ok,
+                head: v.head,
+            });
+        let input = crate::report::ReportInput {
             case: &case,
             target: &j.target,
             options: &j.opts,
@@ -647,8 +695,22 @@ impl Engine {
             elapsed,
             recoveries: &s.recoveries,
             source_hashes: hashes.as_ref(),
-        });
-        crate::owner::write_owned(Path::new(path), html)?;
+            audit,
+        };
+        let as_pdf = Path::new(path)
+            .extension()
+            .is_some_and(|e| e.eq_ignore_ascii_case("pdf"));
+        let bytes = if as_pdf {
+            crate::report::pdf(&input)
+        } else {
+            crate::report::html(&input).into_bytes()
+        };
+        crate::owner::write_owned(Path::new(path), bytes)?;
+        crate::sign::sign_if_configured(Path::new(path));
+        crate::audit::record(
+            "export.report",
+            json!({ "job": id, "source": j.target, "path": path, "case": case.case_id, "examiner": case.examiner }),
+        );
         Ok(())
     }
 
@@ -659,6 +721,10 @@ impl Engine {
             return Err(Error::msg("informe pelo menos um termo"));
         }
         let src = open_path(Path::new(path)).map_err(|e| open_error(path, e))?;
+        crate::audit::record(
+            "search.start",
+            json!({ "source": path, "terms": opts.terms }),
+        );
         let job = self.register(
             JobKind::Search,
             path.to_string(),
@@ -751,7 +817,15 @@ impl Engine {
             } else if pos < size {
                 s.status = Status::Stopped;
             } else {
-                s.report = serde_json::to_value(h.finalize()).ok();
+                let hashes = h.finalize();
+                crate::audit::record(
+                    "hash.finish",
+                    json!({
+                        "source": j2.target, "bytes": size, "md5": hashes.md5,
+                        "sha1": hashes.sha1, "sha256": hashes.sha256,
+                    }),
+                );
+                s.report = serde_json::to_value(hashes).ok();
                 s.status = Status::Done;
             }
             s.finished_in = Some(s.started.elapsed().as_secs_f64());
@@ -763,7 +837,12 @@ impl Engine {
 
     pub fn save_session(&self, id: &str, path: &str) -> Result<()> {
         let j = self.job(id)?;
-        write_session(&j, Path::new(path))
+        write_session(&j, Path::new(path))?;
+        crate::audit::record(
+            "session.save",
+            json!({ "job": id, "source": j.target, "path": path }),
+        );
+        Ok(())
     }
 
     pub fn load_session(&self, path: &str) -> Result<String> {
@@ -834,6 +913,10 @@ impl Engine {
         }
         // continua salvando automaticamente no mesmo arquivo se a varredura for retomada
         *job.session_file.lock().unwrap() = Some(PathBuf::from(path));
+        crate::audit::record(
+            "session.load",
+            json!({ "job": job.id, "source": data.target, "path": path }),
+        );
         if data.done {
             spawn_enrich(job.clone());
         }
@@ -1021,6 +1104,10 @@ impl Engine {
                     .transpose()?
                     .unwrap_or_default();
                 let raw = open_path(Path::new(&path)).map_err(|e| open_error(&path, e))?;
+                crate::audit::record(
+                    "inspect",
+                    json!({ "source": path, "size": raw.size(), "fingerprint": crate::source::fingerprint(raw.as_ref()) }),
+                );
                 let a = crate::assemble::assemble_source(raw, &asm)?;
                 let mut layout = partition::analyze(a.source.as_ref(), false);
                 if a.skip_primary {
@@ -1319,6 +1406,13 @@ fn spawn_scan(job: Arc<Job>, cp: Option<Checkpoint>) {
         }
         s.finished_in = Some(s.started.elapsed().as_secs_f64());
         let done = s.status == Status::Done;
+        crate::audit::record(
+            "scan.finish",
+            json!({
+                "job": job.id, "source": job.target,
+                "status": format!("{:?}", s.status).to_lowercase(), "found": s.found.len(),
+            }),
+        );
         drop(s);
         if done {
             spawn_enrich(job);

crates/guara-core/src/settings.rs

@@ -23,6 +23,10 @@ pub struct Settings {
     /// Mostrar mapas das fotos com GPS (baixa blocos do OpenStreetMap pela internet).
     #[serde(default)]
     pub maps: bool,
+    /// Procurar versão nova no GitHub ao abrir o app (uma consulta ao `latest.json` da release,
+    /// sem enviar nada além do que qualquer navegador envia).
+    #[serde(default = "yes")]
+    pub updates: bool,
 }
 
 fn auto() -> String {
@@ -41,6 +45,7 @@ impl Default for Settings {
             ui_lang: None,
             notify: true,
             maps: false,
+            updates: true,
         }
     }
 }

crates/guara-core/src/sign.rs

@@ -0,0 +1,399 @@
+//! Assinatura digital (Ed25519) de manifestos, relatórios e qualquer outro arquivo, e conferência
+//! de uma recuperação inteira.
+//!
+//! A assinatura fica ao lado do arquivo, em `<arquivo>.assinatura.json`, e cobre o SHA-256 do
+//! conteúdo, o tamanho, o nome, a hora e o assinante. Quem confere recalcula o hash do arquivo,
+//! refaz a mensagem a partir dos campos do JSON e valida com a chave pública que vem nele. Isso
+//! prova que o arquivo não mudou desde que foi assinado **por quem tem a chave**; para saber de
+//! quem é a chave, compare a impressão digital (`fingerprint`) com a que o perito publicou ou
+//! registrou fora da máquina, passando-a em `trusted_fingerprint`.
+//!
+//! A hora é a do relógio da máquina de quem assinou: não é um carimbo de tempo de terceiros
+//! (RFC 3161) e, sozinha, não prova *quando* a assinatura foi feita.
+//!
+//! A chave privada fica em `assinatura.key` na pasta de configuração (ou onde
+//! `GUARA_SIGNING_KEY` apontar), em arquivo de texto com permissão 0600 nos sistemas Unix. Quem
+//! precisa de mais proteção deve guardá-la num pendrive ou volume cifrado e apontar para lá.
+
+use crate::error::{Error, Result};
+use ed25519_compact::{KeyPair, Noise, PublicKey, Seed, Signature};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::io::Read;
+use std::path::{Path, PathBuf};
+
+const FORMAT: &str = "guara-assinatura-v1";
+const KEY_HEADER: &str = "guara-ed25519-seed-v1";
+const PUB_HEADER: &str = "guara-ed25519-public-v1";
+
+fn hex(b: &[u8]) -> String {
+    b.iter().map(|x| format!("{x:02x}")).collect()
+}
+
+fn unhex(s: &str) -> Option<Vec<u8>> {
+    let s = s.trim();
+    if s.len() % 2 != 0 || !s.is_ascii() {
+        return None;
+    }
+    (0..s.len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(&s[i..i + 2], 16).ok())
+        .collect()
+}
+
+/// Impressão digital da chave pública: os 10 primeiros bytes do SHA-256, em grupos de 4 hex.
+pub fn fingerprint(public_key: &[u8]) -> String {
+    let h = Sha256::digest(public_key);
+    let h = hex(&h[..10]);
+    h.as_bytes()
+        .chunks(4)
+        .map(|c| std::str::from_utf8(c).unwrap())
+        .collect::<Vec<_>>()
+        .join(":")
+}
+
+/// Compara impressões digitais ignorando maiúsculas, `:` e espaços.
+fn same_fingerprint(a: &str, b: &str) -> bool {
+    let n = |s: &str| {
+        s.chars()
+            .filter(|c| c.is_ascii_hexdigit())
+            .map(|c| c.to_ascii_lowercase())
+            .collect::<String>()
+    };
+    let (a, b) = (n(a), n(b));
+    !a.is_empty() && a == b
+}
+
+/// Par de chaves de assinatura.
+pub struct SigningKey {
+    kp: KeyPair,
+}
+
+impl SigningKey {
+    pub fn generate() -> Self {
+        Self {
+            kp: KeyPair::from_seed(Seed::generate()),
+        }
+    }
+
+    pub fn public_bytes(&self) -> [u8; 32] {
+        *self.kp.pk
+    }
+
+    pub fn fingerprint(&self) -> String {
+        fingerprint(&self.public_bytes())
+    }
+
+    pub fn load(path: &Path) -> Result<Self> {
+        let text = std::fs::read_to_string(path).map_err(|e| {
+            Error::msg(format!(
+                "não foi possível ler a chave {}: {e}",
+                path.display()
+            ))
+        })?;
+        let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
+        if lines.next() != Some(KEY_HEADER) {
+            return Err(Error::msg(format!(
+                "{} não é uma chave de assinatura do Guará",
+                path.display()
+            )));
+        }
+        let seed = lines
+            .next()
+            .and_then(unhex)
+            .and_then(|b| <[u8; 32]>::try_from(b).ok())
+            .ok_or_else(|| Error::msg("chave de assinatura corrompida"))?;
+        Ok(Self {
+            kp: KeyPair::from_seed(Seed::new(seed)),
+        })
+    }
+
+    /// Grava a chave privada (0600 no Unix) e, ao lado, a pública (`.pub`). Recusa sobrescrever.
+    pub fn save(&self, path: &Path) -> Result<()> {
+        use std::io::Write;
+        if let Some(dir) = path.parent() {
+            crate::owner::create_dir_all_owned(dir)?;
+        }
+        let mut opts = std::fs::OpenOptions::new();
+        opts.write(true).create_new(true);
+        #[cfg(unix)]
+        std::os::unix::fs::OpenOptionsExt::mode(&mut opts, 0o600);
+        let mut f = opts.open(path).map_err(|e| {
+            if e.kind() == std::io::ErrorKind::AlreadyExists {
+                Error::msg(format!(
+                    "já existe uma chave em {}; apague-a de propósito se quiser trocar (as assinaturas antigas continuam válidas com a chave pública antiga)",
+                    path.display()
+                ))
+            } else {
+                e.into()
+            }
+        })?;
+        f.write_all(format!("{KEY_HEADER}\n{}\n", hex(self.kp.sk.seed().as_ref())).as_bytes())?;
+        drop(f);
+        crate::owner::give_to_user(path);
+        let pubp = pub_path(path);
+        crate::owner::write_owned(
+            &pubp,
+            format!(
+                "{PUB_HEADER}\n{}\n# impressão digital: {}\n",
+                hex(&self.public_bytes()),
+                self.fingerprint()
+            ),
+        )?;
+        Ok(())
+    }
+}
+
+fn pub_path(key: &Path) -> PathBuf {
+    key.with_extension("pub")
+}
+
+/// `GUARA_SIGNING_KEY` ou `assinatura.key` na pasta de configuração.
+pub fn default_key_path() -> PathBuf {
+    match std::env::var("GUARA_SIGNING_KEY") {
+        Ok(p) if !p.is_empty() => PathBuf::from(p),
+        _ => crate::settings::config_dir().join("assinatura.key"),
+    }
+}
+
+/// Arquivo que acompanha `path` com a assinatura.
+pub fn signature_path(path: &Path) -> PathBuf {
+    let mut n = path.as_os_str().to_os_string();
+    n.push(".assinatura.json");
+    PathBuf::from(n)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SignatureFile {
+    pub formato: String,
+    pub arquivo: String,
+    pub tamanho: u64,
+    pub sha256: String,
+    pub assinado_em: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assinante: Option<String>,
+    pub chave_publica: String,
+    pub impressao_digital: String,
+    pub assinatura: String,
+}
+
+fn message(f: &SignatureFile) -> Vec<u8> {
+    format!(
+        "{}\narquivo={}\ntamanho={}\nsha256={}\nassinado_em={}\nassinante={}\n",
+        f.formato,
+        f.arquivo,
+        f.tamanho,
+        f.sha256,
+        f.assinado_em,
+        f.assinante.as_deref().unwrap_or("")
+    )
+    .into_bytes()
+}
+
+/// SHA-256 e tamanho de um arquivo, lido em blocos.
+pub fn hash_file(path: &Path) -> Result<(String, u64)> {
+    let mut f = std::fs::File::open(path)?;
+    let mut h = Sha256::new();
+    let mut buf = vec![0u8; 1 << 20];
+    let mut total = 0u64;
+    loop {
+        let n = f.read(&mut buf)?;
+        if n == 0 {
+            break;
+        }
+        h.update(&buf[..n]);
+        total += n as u64;
+    }
+    Ok((hex(&h.finalize()), total))
+}
+
+fn now_iso() -> String {
+    let secs = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_secs() as i64)
+        .unwrap_or(0);
+    crate::audit::utc_iso(secs)
+}
+
+/// Assina `path` e grava `<path>.assinatura.json`. Devolve o caminho da assinatura.
+pub fn sign_file(key: &SigningKey, path: &Path, signer: Option<&str>) -> Result<PathBuf> {
+    let (sha256, size) = hash_file(path)?;
+    let mut sig = SignatureFile {
+        formato: FORMAT.into(),
+        arquivo: path
+            .file_name()
+            .map(|n| n.to_string_lossy().into_owned())
+            .unwrap_or_default(),
+        tamanho: size,
+        sha256,
+        assinado_em: now_iso(),
+        assinante: signer.filter(|s| !s.is_empty()).map(String::from),
+        chave_publica: hex(&key.public_bytes()),
+        impressao_digital: key.fingerprint(),
+        assinatura: String::new(),
+    };
+    sig.assinatura = hex(key
+        .kp
+        .sk
+        .sign(message(&sig), Some(Noise::generate()))
+        .as_ref());
+    let out = signature_path(path);
+    crate::owner::write_owned(&out, serde_json::to_vec_pretty(&sig)?)?;
+    Ok(out)
+}
+
+/// Resultado de conferir uma assinatura.
+#[derive(Debug, Clone, Serialize)]
+pub struct Check {
+    /// O arquivo é o mesmo e a assinatura vale para a chave que vem nela.
+    pub valid: bool,
+    pub file_matches: bool,
+    pub signature_valid: bool,
+    pub fingerprint: String,
+    pub signed_at: String,
+    pub signer: Option<String>,
+    /// `Some(true/false)` quando uma impressão digital de confiança foi informada.
+    pub trusted: Option<bool>,
+    pub problems: Vec<String>,
+}
+
+pub fn verify_file(
+    path: &Path,
+    sig_path: Option<&Path>,
+    trusted_fingerprint: Option<&str>,
+) -> Result<Check> {
+    let sp = sig_path
+        .map(Path::to_path_buf)
+        .unwrap_or_else(|| signature_path(path));
+    let raw = std::fs::read(&sp).map_err(|e| {
+        Error::msg(format!(
+            "não foi possível ler a assinatura {}: {e}",
+            sp.display()
+        ))
+    })?;
+    let sig: SignatureFile = serde_json::from_slice(&raw)
+        .map_err(|e| Error::msg(format!("assinatura ilegível: {e}")))?;
+    let mut problems = vec![];
+    if sig.formato != FORMAT {
+        problems.push(format!(
+            "formato de assinatura desconhecido ({})",
+            sig.formato
+        ));
+    }
+    let (sha, size) = hash_file(path)?;
+    let file_matches = sha == sig.sha256 && size == sig.tamanho;
+    if !file_matches {
+        problems.push("o arquivo mudou depois de assinado (hash ou tamanho diferem)".into());
+    }
+    let pk = unhex(&sig.chave_publica).and_then(|b| PublicKey::from_slice(&b).ok());
+    let sg = unhex(&sig.assinatura).and_then(|b| Signature::from_slice(&b).ok());
+    let signature_valid = match (&pk, &sg) {
+        (Some(pk), Some(sg)) => pk.verify(message(&sig), sg).is_ok(),
+        _ => false,
+    };
+    if !signature_valid {
+        problems.push("a assinatura não confere (campos alterados ou chave errada)".into());
+    }
+    let real_fp = pk
+        .as_ref()
+        .map(|p| fingerprint(p.as_ref()))
+        .unwrap_or_default();
+    if real_fp != sig.impressao_digital {
+        problems.push("a impressão digital declarada não é a da chave pública".into());
+    }
+    let trusted = trusted_fingerprint.map(|t| same_fingerprint(t, &real_fp));
+    if trusted == Some(false) {
+        problems.push(format!(
+            "a chave que assinou ({real_fp}) não é a esperada ({})",
+            trusted_fingerprint.unwrap_or_default()
+        ));
+    }
+    Ok(Check {
+        valid: problems.is_empty(),
+        file_matches,
+        signature_valid,
+        fingerprint: real_fp,
+        signed_at: sig.assinado_em,
+        signer: sig.assinante,
+        trusted,
+        problems,
+    })
+}
+
+/// Confere uma pasta de recuperação: a assinatura do manifesto (se houver) e o hash de cada
+/// arquivo contra o que o manifesto registrou.
+#[derive(Debug, Clone, Serialize)]
+pub struct RecoveryCheck {
+    pub manifest_signature: Option<Check>,
+    pub files: usize,
+    pub ok: usize,
+    pub missing: Vec<String>,
+    pub changed: Vec<String>,
+    /// `true` quando tudo confere (e, havendo assinatura, ela vale).
+    pub valid: bool,
+}
+
+pub fn verify_recovery(dir: &Path, trusted_fingerprint: Option<&str>) -> Result<RecoveryCheck> {
+    let manifest = dir.join("guara-manifesto.json");
+    let raw = std::fs::read(&manifest)
+        .map_err(|e| Error::msg(format!("não foi possível ler {}: {e}", manifest.display())))?;
+    let v: serde_json::Value = serde_json::from_slice(&raw)?;
+    let sigp = signature_path(&manifest);
+    let manifest_signature = if sigp.is_file() {
+        Some(verify_file(&manifest, None, trusted_fingerprint)?)
+    } else {
+        None
+    };
+    let list = v["relatorio"]["recovered"]
+        .as_array()
+        .cloned()
+        .unwrap_or_default();
+    let (mut ok, mut missing, mut changed) = (0, vec![], vec![]);
+    for f in &list {
+        let (Some(rel), Some(want)) = (f["path"].as_str(), f["sha256"].as_str()) else {
+            continue;
+        };
+        // o manifesto é dado de entrada: não deixa sair da pasta
+        if rel.split('/').any(|c| c == "..") || Path::new(rel).is_absolute() {
+            changed.push(format!("{rel} (caminho fora da pasta)"));
+            continue;
+        }
+        let p = dir.join(rel);
+        match hash_file(&p) {
+            Ok((h, _)) if h == want => ok += 1,
+            Ok(_) => changed.push(rel.to_string()),
+            Err(_) => missing.push(rel.to_string()),
+        }
+    }
+    let signature_ok = match &manifest_signature {
+        Some(c) => c.valid,
+        None => true,
+    };
+    let valid = missing.is_empty() && changed.is_empty() && signature_ok;
+    Ok(RecoveryCheck {
+        manifest_signature,
+        files: list.len(),
+        ok,
+        missing,
+        changed,
+        valid,
+    })
+}
+
+/// Assina `path` se existir uma chave configurada; nunca interrompe quem chamou. Registra na
+/// trilha de auditoria.
+pub fn sign_if_configured(path: &Path) {
+    let kp = default_key_path();
+    if !kp.is_file() {
+        return;
+    }
+    let result = SigningKey::load(&kp)
+        .and_then(|k| sign_file(&k, path, std::env::var("GUARA_EXAMINER").ok().as_deref()));
+    match result {
+        Ok(sig) => crate::audit::record(
+            "sign",
+            serde_json::json!({ "path": path.to_string_lossy(), "signature": sig.to_string_lossy() }),
+        ),
+        Err(e) => eprintln!("aviso: não foi possível assinar {}: {e}", path.display()),
+    }
+}

crates/guara-core/src/source.rs

@@ -286,7 +286,13 @@ pub fn open_path(path: &Path) -> io::Result<Arc<dyn Source>> {
             .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
         return Ok(Arc::new(e));
     }
-    Ok(Arc::new(file))
+    drop(file);
+    if let Some(v) = crate::vdisk::open(path)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?
+    {
+        return Ok(Arc::new(v));
+    }
+    Ok(Arc::new(FileSource::open(path)?))
 }
 
 /// Identidade do conteúdo de um disco: SHA-256 do tamanho + primeiro e último MiB

crates/guara-core/src/vdisk/dmg.rs

@@ -0,0 +1,234 @@
+//! DMG (Apple UDIF): rodapé `koly`, tabelas `mish` do plist e chunks zerados, brutos, ADC,
+//! zlib, bzip2 e LZFSE (`ULFO`). Imagens cifradas (`encrcdsa`) são recusadas com mensagem
+//! clara.
+
+use super::{bad, be32, be64, read_exact, read_vec, Backend};
+use crate::source::{FileSource, Source};
+use std::io::{self, Read};
+use std::sync::Mutex;
+
+const SECTOR: u64 = 512;
+
+pub(super) fn is_dmg(file: &FileSource) -> bool {
+    let size = file.size();
+    if size < 1024 {
+        return false;
+    }
+    let mut t = [0u8; 512];
+    read_exact(file, size - SECTOR, &mut t).is_ok()
+        && &t[..4] == b"koly"
+        && be32(&t, 4) == 4
+        && be32(&t, 8) == 512
+}
+
+/// Imagem cifrada pelo `hdiutil`: começa com `encrcdsa` ou `cdsaencr`.
+pub(super) fn is_encrypted(head: &[u8]) -> bool {
+    head.starts_with(b"encrcdsa") || head.starts_with(b"cdsaencr")
+}
+
+#[derive(Clone, Copy)]
+struct Chunk {
+    start: u64,
+    len: u64,
+    ty: u32,
+    off: u64,
+    comp_len: u64,
+}
+
+pub(super) struct Dmg {
+    file: FileSource,
+    size: u64,
+    chunks: Vec<Chunk>,
+    cache: Mutex<Option<(usize, Vec<u8>)>>,
+}
+
+fn base64(s: &str) -> Vec<u8> {
+    let mut out = Vec::with_capacity(s.len() * 3 / 4);
+    let (mut acc, mut bits) = (0u32, 0);
+    for c in s.bytes() {
+        let v = match c {
+            b'A'..=b'Z' => c - b'A',
+            b'a'..=b'z' => c - b'a' + 26,
+            b'0'..=b'9' => c - b'0' + 52,
+            b'+' => 62,
+            b'/' => 63,
+            _ => continue,
+        };
+        acc = acc << 6 | v as u32;
+        bits += 6;
+        if bits >= 8 {
+            bits -= 8;
+            out.push((acc >> bits) as u8);
+            acc &= (1 << bits) - 1;
+        }
+    }
+    out
+}
+
+/// Descompacta ADC (Apple Data Compression).
+fn adc(src: &[u8], max: usize) -> io::Result<Vec<u8>> {
+    let mut out: Vec<u8> = Vec::with_capacity(max);
+    let mut i = 0;
+    while i < src.len() && out.len() < max {
+        let c = src[i];
+        i += 1;
+        if c & 0x80 != 0 {
+            let n = (c & 0x7F) as usize + 1;
+            let lit = src.get(i..i + n).ok_or_else(|| bad("chunk ADC truncado"))?;
+            out.extend_from_slice(lit);
+            i += n;
+        } else {
+            let (len, off) = if c & 0x40 != 0 {
+                let b = src.get(i..i + 2).ok_or_else(|| bad("chunk ADC truncado"))?;
+                i += 2;
+                (
+                    (c & 0x3F) as usize + 4,
+                    (b[0] as usize) << 8 | b[1] as usize,
+                )
+            } else {
+                let b = *src.get(i).ok_or_else(|| bad("chunk ADC truncado"))?;
+                i += 1;
+                ((c >> 2) as usize + 3, ((c & 3) as usize) << 8 | b as usize)
+            };
+            let off = off + 1;
+            if off > out.len() {
+                return Err(bad("referência ADC inválida"));
+            }
+            for _ in 0..len {
+                out.push(out[out.len() - off]);
+            }
+        }
+    }
+    Ok(out)
+}
+
+impl Dmg {
+    pub(super) fn open(file: FileSource) -> io::Result<Self> {
+        let mut head = [0u8; 8];
+        let _ = file.read_at(0, &mut head);
+        if is_encrypted(&head) {
+            return Err(bad(
+                "DMG cifrado (encrcdsa) não é suportado; desproteja a imagem antes",
+            ));
+        }
+        let size = file.size();
+        let t = read_vec(&file, size - SECTOR, SECTOR as usize)?;
+        let fork = be64(&t, 24);
+        let xml_off = be64(&t, 216);
+        let xml_len = be64(&t, 224);
+        let sectors = be64(&t, 492);
+        if xml_len == 0 || xml_len > 256 << 20 {
+            return Err(bad("plist do DMG ausente ou grande demais"));
+        }
+        let xml = read_vec(&file, xml_off, xml_len as usize)?;
+        let xml = String::from_utf8_lossy(&xml);
+        let from = xml
+            .find("<key>blkx</key>")
+            .ok_or_else(|| bad("tabela blkx não encontrada no DMG"))?;
+        let rest = &xml[from..];
+        let rest = &rest[..rest.find("</array>").unwrap_or(rest.len())];
+        let mut chunks: Vec<Chunk> = vec![];
+        let mut cur = rest;
+        while let Some(a) = cur.find("<data>") {
+            let after = &cur[a + 6..];
+            let Some(b) = after.find("</data>") else {
+                break;
+            };
+            let mish = base64(&after[..b]);
+            cur = &after[b + 7..];
+            if mish.len() < 204 || &mish[..4] != b"mish" {
+                continue;
+            }
+            let first = be64(&mish, 8);
+            let data_off = be64(&mish, 24);
+            let n = be32(&mish, 200) as usize;
+            for i in 0..n {
+                let Some(c) = mish.get(204 + i * 40..204 + (i + 1) * 40) else {
+                    break;
+                };
+                let ty = be32(c, 0);
+                if ty == 0x7FFF_FFFE || ty == 0xFFFF_FFFF {
+                    continue;
+                }
+                chunks.push(Chunk {
+                    start: (first + be64(c, 8)) * SECTOR,
+                    len: be64(c, 16) * SECTOR,
+                    ty,
+                    off: fork + data_off + be64(c, 24),
+                    comp_len: be64(c, 32),
+                });
+            }
+        }
+        if chunks.is_empty() {
+            return Err(bad("DMG sem chunks"));
+        }
+        chunks.sort_by_key(|c| c.start);
+        let end = chunks.iter().map(|c| c.start + c.len).max().unwrap_or(0);
+        Ok(Self {
+            file,
+            size: end.max(sectors * SECTOR),
+            chunks,
+            cache: Mutex::new(None),
+        })
+    }
+
+    fn decode(&self, c: &Chunk) -> io::Result<Vec<u8>> {
+        if c.len > 64 << 20 || c.comp_len > 64 << 20 {
+            return Err(bad("chunk de DMG grande demais"));
+        }
+        let raw = read_vec(&self.file, c.off, c.comp_len as usize)?;
+        let mut out = Vec::with_capacity(c.len as usize);
+        match c.ty {
+            0x8000_0004 => out = adc(&raw, c.len as usize)?,
+            0x8000_0005 => {
+                flate2::read::ZlibDecoder::new(&raw[..]).read_to_end(&mut out)?;
+            }
+            0x8000_0006 => {
+                bzip2::read::BzDecoder::new(&raw[..]).read_to_end(&mut out)?;
+            }
+            0x8000_0007 => {
+                lzfse_rust::decode_bytes(&raw, &mut out)
+                    .map_err(|e| bad(format!("chunk LZFSE inválido: {e}")))?;
+            }
+            t => return Err(bad(format!("tipo de chunk DMG 0x{t:08x} desconhecido"))),
+        }
+        out.resize(c.len as usize, 0);
+        Ok(out)
+    }
+}
+
+impl Backend for Dmg {
+    fn size(&self) -> u64 {
+        self.size
+    }
+
+    fn read_chunk(&self, voff: u64, buf: &mut [u8]) -> io::Result<usize> {
+        let i = self.chunks.partition_point(|c| c.start + c.len <= voff);
+        let Some(c) = self.chunks.get(i).copied() else {
+            let n = buf.len().min((self.size - voff) as usize);
+            buf[..n].fill(0);
+            return Ok(n);
+        };
+        if voff < c.start {
+            // espaço que nenhuma tabela cobre
+            let n = buf.len().min((c.start - voff) as usize);
+            buf[..n].fill(0);
+            return Ok(n);
+        }
+        let rel = voff - c.start;
+        let n = buf.len().min((c.len - rel) as usize);
+        match c.ty {
+            0 | 2 => buf[..n].fill(0),
+            1 => read_exact(&self.file, c.off + rel, &mut buf[..n])?,
+            _ => {
+                let mut cache = self.cache.lock().unwrap();
+                if cache.as_ref().map(|x| x.0) != Some(i) {
+                    *cache = Some((i, self.decode(&c)?));
+                }
+                let data = &cache.as_ref().unwrap().1;
+                buf[..n].copy_from_slice(&data[rel as usize..rel as usize + n]);
+            }
+        }
+        Ok(n)
+    }
+}

crates/guara-core/src/vdisk/mod.rs

@@ -0,0 +1,251 @@
+//! Imagens de disco virtual e contêineres: QCOW2, VMDK, VHD, VHDX e DMG (UDIF).
+//!
+//! Cada formato é aberto como o disco que contém, somente para leitura, e entra na cadeia
+//! normal (partições, sistemas de arquivos, cifras) por meio de [`Source`]. Discos
+//! diferenciais (VHD e VHDX com pai, QCOW2 com arquivo de apoio, VMDK com pai) seguem a
+//! cadeia até o disco base. A identidade do pai (UUID, CID, data) não é conferida: se o pai foi
+//! alterado depois do filho, os dados lidos refletem o pai atual.
+
+mod dmg;
+mod qcow2;
+mod vhd;
+mod vhdx;
+mod vmdk;
+
+use crate::error::{Error, Result};
+use crate::source::{FileSource, Source};
+use std::io;
+use std::path::Path;
+
+pub(crate) fn be16(b: &[u8], o: usize) -> u16 {
+    u16::from_be_bytes(b[o..o + 2].try_into().unwrap())
+}
+pub(crate) fn be32(b: &[u8], o: usize) -> u32 {
+    u32::from_be_bytes(b[o..o + 4].try_into().unwrap())
+}
+pub(crate) fn be64(b: &[u8], o: usize) -> u64 {
+    u64::from_be_bytes(b[o..o + 8].try_into().unwrap())
+}
+pub(crate) fn le16(b: &[u8], o: usize) -> u16 {
+    u16::from_le_bytes(b[o..o + 2].try_into().unwrap())
+}
+pub(crate) fn le32(b: &[u8], o: usize) -> u32 {
+    u32::from_le_bytes(b[o..o + 4].try_into().unwrap())
+}
+pub(crate) fn le64(b: &[u8], o: usize) -> u64 {
+    u64::from_le_bytes(b[o..o + 8].try_into().unwrap())
+}
+
+/// Leitura dentro de um único bloco do formato; devolve quantos bytes entregou (pode ser
+/// menos que `buf.len()`, nunca zero antes do fim do disco).
+pub(crate) trait Backend: Send + Sync {
+    fn size(&self) -> u64;
+    fn read_chunk(&self, voff: u64, buf: &mut [u8]) -> io::Result<usize>;
+}
+
+/// Disco virtual aberto de uma imagem de contêiner.
+pub struct VDisk {
+    inner: Box<dyn Backend>,
+    format: &'static str,
+}
+
+impl VDisk {
+    /// Nome do formato (`QCOW2`, `VMDK`, `VHD`, `VHDX`, `DMG`).
+    pub fn format(&self) -> &'static str {
+        self.format
+    }
+}
+
+impl Source for VDisk {
+    fn size(&self) -> u64 {
+        self.inner.size()
+    }
+    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<usize> {
+        let size = self.inner.size();
+        if offset >= size {
+            return Ok(0);
+        }
+        let want = buf.len().min((size - offset) as usize);
+        let mut done = 0;
+        while done < want {
+            let n = self
+                .inner
+                .read_chunk(offset + done as u64, &mut buf[done..want])?;
+            if n == 0 {
+                break;
+            }
+            done += n;
+        }
+        Ok(done)
+    }
+}
+
+pub(crate) fn bad(msg: impl Into<String>) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, msg.into())
+}
+
+pub(crate) fn io_err(e: io::Error, what: &str) -> Error {
+    Error::msg(format!("{what}: {e}"))
+}
+
+/// Cadeias de arquivos pai (VHD/VHDX diferenciais) não passam deste limite, o que também
+/// corta ciclos.
+const MAX_DEPTH: u32 = 16;
+
+/// Formato de contêiner reconhecido pelos primeiros bytes (e, para VHD fixo e DMG, pelo
+/// fim do arquivo). `None` quando é um disco bruto.
+pub fn detect(file: &FileSource, head: &[u8]) -> Option<&'static str> {
+    if head.starts_with(b"QFI\xfb") {
+        return Some("QCOW2");
+    }
+    if head.starts_with(b"KDMV") || head.starts_with(b"# Disk DescriptorFile") {
+        return Some("VMDK");
+    }
+    if head.starts_with(b"vhdxfile") {
+        return Some("VHDX");
+    }
+    if head.starts_with(b"conectix") || vhd::is_fixed(file) {
+        return Some("VHD");
+    }
+    if dmg::is_encrypted(head) || dmg::is_dmg(file) {
+        return Some("DMG");
+    }
+    None
+}
+
+/// Abre `path` como disco virtual, ou `Ok(None)` se não for um contêiner conhecido.
+pub fn open(path: &Path) -> Result<Option<VDisk>> {
+    open_depth(path, 0)
+}
+
+pub(crate) fn open_depth(path: &Path, depth: u32) -> Result<Option<VDisk>> {
+    if depth > MAX_DEPTH {
+        return Err(Error::msg("cadeia de discos pai longa demais ou circular"));
+    }
+    let file = FileSource::open(path)?;
+    let mut head = [0u8; 96];
+    let got = file.read_at(0, &mut head).unwrap_or(0);
+    let Some(format) = detect(&file, &head[..got]) else {
+        return Ok(None);
+    };
+    let name = format!("{format} {}", path.display());
+    let inner: Box<dyn Backend> = match format {
+        "QCOW2" => Box::new(qcow2::Qcow2::open(file, path, depth).map_err(|e| io_err(e, &name))?),
+        "VMDK" => Box::new(vmdk::Vmdk::open(file, path, depth).map_err(|e| io_err(e, &name))?),
+        "VHD" => Box::new(vhd::Vhd::open(file, path, depth).map_err(|e| io_err(e, &name))?),
+        "VHDX" => Box::new(vhdx::Vhdx::open(file, path, depth).map_err(|e| io_err(e, &name))?),
+        _ => Box::new(dmg::Dmg::open(file).map_err(|e| io_err(e, &name))?),
+    };
+    Ok(Some(VDisk { inner, format }))
+}
+
+/// Abre o disco pai (VHD/VHDX diferencial, QCOW2 com apoio, VMDK com pai). Com `raw`, o
+/// arquivo é tratado como disco bruto sem tentar reconhecer o formato.
+pub(crate) fn open_parent(
+    candidates: &[std::path::PathBuf],
+    depth: u32,
+    raw: bool,
+) -> io::Result<Box<dyn Source>> {
+    for p in candidates {
+        if !p.is_file() {
+            continue;
+        }
+        if !raw {
+            if let Some(v) = open_depth(p, depth + 1).map_err(|e| bad(e.to_string()))? {
+                return Ok(Box::new(v));
+            }
+        } else if depth > MAX_DEPTH {
+            return Err(bad("cadeia de discos pai longa demais ou circular"));
+        }
+        let f = FileSource::open(p)?;
+        return Ok(Box::new(f));
+    }
+    Err(bad(format!(
+        "disco pai não encontrado (procurado: {})",
+        candidates
+            .iter()
+            .map(|p| p.display().to_string())
+            .collect::<Vec<_>>()
+            .join(", ")
+    )))
+}
+
+/// Lê de um arquivo por posição e exige todos os bytes.
+pub(crate) fn read_exact(f: &FileSource, off: u64, buf: &mut [u8]) -> io::Result<()> {
+    crate::source::read_exact_at(f, off, buf)
+}
+
+pub(crate) fn read_vec(f: &FileSource, off: u64, len: usize) -> io::Result<Vec<u8>> {
+    let mut v = vec![0u8; len];
+    read_exact(f, off, &mut v)?;
+    Ok(v)
+}
+
+/// Tabelas em memória têm teto: um cabeçalho adulterado não pode pedir gigabytes.
+pub(crate) fn check_table(entries: u64, entry_size: u64, what: &str) -> io::Result<usize> {
+    const MAX: u64 = 512 * 1024 * 1024;
+    if entries.saturating_mul(entry_size) > MAX {
+        return Err(bad(format!("{what} grande demais ({entries} entradas)")));
+    }
+    Ok(entries as usize)
+}
+
+/// UTF-16 (big ou little endian) até o primeiro nulo.
+pub(crate) fn utf16(b: &[u8], big: bool) -> String {
+    let units: Vec<u16> = b
+        .chunks_exact(2)
+        .map(|c| if big { be16(c, 0) } else { le16(c, 0) })
+        .take_while(|&u| u != 0)
+        .collect();
+    String::from_utf16_lossy(&units)
+}
+
+/// Caminhos onde procurar o disco pai: o caminho gravado (relativo ao arquivo filho, com `\`
+/// virando `/`) e, como alternativa, só o nome do arquivo na mesma pasta.
+pub(crate) fn candidate_paths(dir: &Path, names: &[String]) -> Vec<std::path::PathBuf> {
+    let mut out: Vec<std::path::PathBuf> = vec![];
+    for n in names {
+        let n = n.trim().replace('\\', "/");
+        let n = n.strip_prefix("file:///").unwrap_or(&n).to_string();
+        if n.is_empty() {
+            continue;
+        }
+        let rel = n.trim_start_matches("./");
+        let full = std::path::PathBuf::from(rel);
+        for p in [
+            if full.is_absolute() {
+                full.clone()
+            } else {
+                dir.join(rel)
+            },
+            dir.join(rel.rsplit('/').next().unwrap_or(rel)),
+        ] {
+            if !out.contains(&p) {
+                out.push(p);
+            }
+        }
+    }
+    out
+}
+
+/// Lê do disco pai (ou zeros, sem pai); o que o pai não cobre também é zero.
+pub(crate) fn read_parent(
+    parent: &Option<Box<dyn Source>>,
+    voff: u64,
+    buf: &mut [u8],
+) -> io::Result<()> {
+    let Some(p) = parent else {
+        buf.fill(0);
+        return Ok(());
+    };
+    let mut done = 0;
+    while done < buf.len() {
+        let n = p.read_at(voff + done as u64, &mut buf[done..])?;
+        if n == 0 {
+            buf[done..].fill(0);
+            break;
+        }
+        done += n;
+    }
+    Ok(())
+}

crates/guara-core/src/vdisk/qcow2.rs

@@ -0,0 +1,212 @@
+//! QCOW2 (QEMU), versões 2 e 3: tabelas L1/L2, clusters comprimidos (deflate e zstd),
+//! clusters zerados e arquivo de apoio (backing file): o que o filho não alocou vem do pai.
+//! Imagens cifradas, com arquivo de dados externo, com L2 estendido ou com apoio que não é um
+//! arquivo local (`json:`, `nbd:`, URLs) são recusadas.
+
+use super::{
+    bad, be32, be64, candidate_paths, check_table, open_parent, read_exact, read_parent, read_vec,
+    Backend,
+};
+use crate::source::{FileSource, Source};
+use std::io::{self, Read};
+use std::path::Path;
+use std::sync::Mutex;
+
+const OFFSET_MASK: u64 = 0x00ff_ffff_ffff_fe00;
+const COMPRESSED: u64 = 1 << 62;
+
+pub(super) struct Qcow2 {
+    file: FileSource,
+    size: u64,
+    cluster_bits: u32,
+    l1: Vec<u64>,
+    zstd: bool,
+    parent: Option<Box<dyn Source>>,
+    /// Último cluster comprimido decodificado: (deslocamento do cluster virtual, dados).
+    cache: Mutex<Option<(u64, Vec<u8>)>>,
+}
+
+impl Qcow2 {
+    pub(super) fn open(file: FileSource, path: &Path, depth: u32) -> io::Result<Self> {
+        let h = read_vec(&file, 0, 112.min(file.size() as usize))?;
+        if h.len() < 72 {
+            return Err(bad("cabeçalho QCOW2 truncado"));
+        }
+        let version = be32(&h, 4);
+        if version != 2 && version != 3 {
+            return Err(bad(format!("versão QCOW {version} não suportada")));
+        }
+        let cluster_bits = be32(&h, 20);
+        if !(9..=21).contains(&cluster_bits) {
+            return Err(bad(format!(
+                "tamanho de cluster inválido (2^{cluster_bits})"
+            )));
+        }
+        let size = be64(&h, 24);
+        match be32(&h, 32) {
+            0 => {}
+            1 => return Err(bad("imagem QCOW2 cifrada (AES legado) não é suportada")),
+            _ => return Err(bad("imagem QCOW2 cifrada (LUKS) não é suportada; abra o volume LUKS depois de convertê-la")),
+        }
+        let mut zstd = false;
+        if version == 3 && h.len() >= 108 {
+            let incompat = be64(&h, 72);
+            if incompat & (1 << 2) != 0 {
+                return Err(bad("QCOW2 com arquivo de dados externo não é suportado"));
+            }
+            if incompat & (1 << 4) != 0 {
+                return Err(bad("QCOW2 com L2 estendido não é suportado"));
+            }
+            if incompat & (1 << 3) != 0 {
+                zstd = h[104] == 1;
+                if h[104] > 1 {
+                    return Err(bad("tipo de compressão QCOW2 desconhecido"));
+                }
+            }
+        }
+        let parent = if be64(&h, 8) != 0 {
+            Some(Self::open_backing(&file, &h, version, path, depth)?)
+        } else {
+            None
+        };
+        let l1_size = be32(&h, 36) as u64;
+        let l1_off = be64(&h, 40);
+        let n = check_table(l1_size, 8, "tabela L1")?;
+        let raw = read_vec(&file, l1_off, n * 8)?;
+        let l1 = raw.chunks_exact(8).map(|c| be64(c, 0)).collect();
+        Ok(Self {
+            file,
+            size,
+            cluster_bits,
+            l1,
+            zstd,
+            parent,
+            cache: Mutex::new(None),
+        })
+    }
+
+    /// Abre o arquivo de apoio. O formato vem da extensão de cabeçalho `0xE2792ACA`; `raw`
+    /// (ou ausente em v2) é lido sem reconhecer formato, como o QEMU faz.
+    fn open_backing(
+        file: &FileSource,
+        h: &[u8],
+        version: u32,
+        path: &Path,
+        depth: u32,
+    ) -> io::Result<Box<dyn Source>> {
+        let (off, len) = (be64(h, 8), be32(h, 16) as usize);
+        if len == 0 || len > 1023 {
+            return Err(bad("nome do arquivo de apoio QCOW2 inválido"));
+        }
+        let name = String::from_utf8_lossy(&read_vec(file, off, len)?).into_owned();
+        if name.starts_with("json:")
+            || name.contains("://")
+            || name.split(':').next().is_some_and(|p| {
+                matches!(p, "nbd" | "ssh" | "rbd" | "sheepdog" | "gluster" | "iscsi")
+            })
+        {
+            return Err(bad(format!(
+                "o arquivo de apoio {name} não é um arquivo local; só caminhos de arquivo são suportados"
+            )));
+        }
+        // extensões de cabeçalho: depois do cabeçalho, alinhadas a 8 bytes
+        let hlen = if version == 3 && h.len() >= 104 {
+            be32(h, 100) as u64
+        } else {
+            72
+        };
+        let mut raw = false;
+        let mut pos = hlen.div_ceil(8) * 8;
+        for _ in 0..64 {
+            let mut eh = [0u8; 8];
+            if read_exact(file, pos, &mut eh).is_err() {
+                break;
+            }
+            let (kind, elen) = (be32(&eh, 0), be32(&eh, 4) as u64);
+            if kind == 0 || elen > 1 << 20 {
+                break;
+            }
+            if kind == 0xE279_2ACA {
+                let fmt = read_vec(file, pos + 8, elen as usize)?;
+                raw = fmt == b"raw";
+            }
+            pos += 8 + elen.div_ceil(8) * 8;
+        }
+        if version == 2 {
+            raw = false;
+        }
+        let dir = path.parent().unwrap_or(Path::new("."));
+        open_parent(&candidate_paths(dir, &[name]), depth, raw)
+    }
+
+    fn cluster_size(&self) -> u64 {
+        1 << self.cluster_bits
+    }
+
+    fn l2_entry(&self, cluster_idx: u64) -> io::Result<u64> {
+        let per_l2 = self.cluster_size() / 8;
+        let l1_idx = (cluster_idx / per_l2) as usize;
+        let l2_idx = cluster_idx % per_l2;
+        let Some(&l1e) = self.l1.get(l1_idx) else {
+            return Ok(0);
+        };
+        let l2_off = l1e & OFFSET_MASK;
+        if l2_off == 0 {
+            return Ok(0);
+        }
+        let mut b = [0u8; 8];
+        read_exact(&self.file, l2_off + l2_idx * 8, &mut b)?;
+        Ok(u64::from_be_bytes(b))
+    }
+
+    fn inflate(&self, entry: u64) -> io::Result<Vec<u8>> {
+        let shift = 62 - (self.cluster_bits - 8);
+        let host = entry & ((1u64 << shift) - 1);
+        let nsect = ((entry >> shift) & ((1u64 << (self.cluster_bits - 8)) - 1)) + 1;
+        let csize = (nsect * 512 - (host & 511)) as usize;
+        let avail = self.file.size().saturating_sub(host) as usize;
+        let raw = read_vec(&self.file, host, csize.min(avail))?;
+        let mut out = Vec::with_capacity(self.cluster_size() as usize);
+        if self.zstd {
+            let mut d = ruzstd::decoding::StreamingDecoder::new(&raw[..])
+                .map_err(|e| bad(format!("cluster zstd inválido: {e}")))?;
+            d.read_to_end(&mut out)?;
+        } else {
+            flate2::read::DeflateDecoder::new(&raw[..]).read_to_end(&mut out)?;
+        }
+        out.resize(self.cluster_size() as usize, 0);
+        Ok(out)
+    }
+}
+
+impl Backend for Qcow2 {
+    fn size(&self) -> u64 {
+        self.size
+    }
+
+    fn read_chunk(&self, voff: u64, buf: &mut [u8]) -> io::Result<usize> {
+        let cs = self.cluster_size();
+        let idx = voff / cs;
+        let within = voff % cs;
+        let n = buf.len().min((cs - within) as usize);
+        let entry = self.l2_entry(idx)?;
+        if entry & COMPRESSED != 0 {
+            let mut cache = self.cache.lock().unwrap();
+            if cache.as_ref().map(|c| c.0) != Some(idx) {
+                *cache = Some((idx, self.inflate(entry)?));
+            }
+            let data = &cache.as_ref().unwrap().1;
+            buf[..n].copy_from_slice(&data[within as usize..within as usize + n]);
+            return Ok(n);
+        }
+        let off = entry & OFFSET_MASK;
+        if entry & 1 != 0 {
+            buf[..n].fill(0); // zerado de propósito: não consulta o pai
+        } else if off == 0 {
+            read_parent(&self.parent, voff, &mut buf[..n])?;
+        } else {
+            read_exact(&self.file, off + within, &mut buf[..n])?;
+        }
+        Ok(n)
+    }
+}

crates/guara-core/src/vdisk/vhd.rs

@@ -0,0 +1,175 @@
+//! VHD (Microsoft Virtual PC e Hyper-V): discos fixos, dinâmicos e diferenciais. O disco
+//! diferencial lê o pai (achado pelos localizadores do cabeçalho) nos setores que a camada
+//! filha não preencheu.
+
+use super::{
+    bad, be32, be64, candidate_paths, check_table, open_parent, read_exact, read_parent, read_vec,
+    utf16, Backend,
+};
+use crate::source::{FileSource, Source};
+use std::io;
+use std::path::Path;
+
+const SECTOR: u64 = 512;
+const NONE: u32 = 0xFFFF_FFFF;
+
+enum Kind {
+    Fixed,
+    Dynamic {
+        bat: Vec<u32>,
+        block_size: u64,
+        bitmap_size: u64,
+    },
+}
+
+pub(super) struct Vhd {
+    file: FileSource,
+    size: u64,
+    kind: Kind,
+    parent: Option<Box<dyn Source>>,
+}
+
+fn footer_ok(f: &[u8]) -> bool {
+    if f.len() < 512 || &f[..8] != b"conectix" {
+        return false;
+    }
+    let mut sum = 0u32;
+    for (i, &b) in f[..512].iter().enumerate() {
+        if !(64..68).contains(&i) {
+            sum = sum.wrapping_add(b as u32);
+        }
+    }
+    !sum == be32(f, 64)
+}
+
+/// VHD fixo: disco bruto seguido de um rodapé de 512 bytes.
+pub(super) fn is_fixed(file: &FileSource) -> bool {
+    let size = file.size();
+    if size < 2 * SECTOR {
+        return false;
+    }
+    let mut f = [0u8; 512];
+    read_exact(file, size - SECTOR, &mut f).is_ok()
+        && footer_ok(&f)
+        && be32(&f, 60) == 2
+        && be64(&f, 16) == u64::MAX
+}
+
+impl Vhd {
+    pub(super) fn open(file: FileSource, path: &Path, depth: u32) -> io::Result<Self> {
+        let size = file.size();
+        let mut footer = [0u8; 512];
+        let tail_ok = size >= SECTOR && {
+            read_exact(&file, size - SECTOR, &mut footer)?;
+            footer_ok(&footer)
+        };
+        if !tail_ok {
+            read_exact(&file, 0, &mut footer)?;
+            if !footer_ok(&footer) {
+                return Err(bad("rodapé VHD inválido"));
+            }
+        }
+        let current = be64(&footer, 48);
+        let disk_type = be32(&footer, 60);
+        match disk_type {
+            2 => {
+                return Ok(Self {
+                    file,
+                    size: current,
+                    kind: Kind::Fixed,
+                    parent: None,
+                });
+            }
+            3 | 4 => {}
+            t => return Err(bad(format!("tipo de VHD {t} desconhecido"))),
+        }
+        let dh = read_vec(&file, be64(&footer, 16), 1024)?;
+        if &dh[..8] != b"cxsparse" {
+            return Err(bad("cabeçalho de disco dinâmico VHD inválido"));
+        }
+        let bat_off = be64(&dh, 16);
+        let entries = be32(&dh, 28) as u64;
+        let block_size = be32(&dh, 32) as u64;
+        if block_size < SECTOR || !block_size.is_power_of_two() {
+            return Err(bad("tamanho de bloco VHD inválido"));
+        }
+        let n = check_table(entries, 4, "tabela de alocação")?;
+        let raw = read_vec(&file, bat_off, n * 4)?;
+        let bat = raw.chunks_exact(4).map(|c| be32(c, 0)).collect();
+        let bitmap_size = (block_size / SECTOR / 8).div_ceil(SECTOR) * SECTOR;
+        let parent = if disk_type == 4 {
+            let dir = path.parent().unwrap_or(Path::new("."));
+            let mut names = vec![];
+            for i in 0..8 {
+                let o = 576 + i * 24;
+                let code = &dh[o..o + 4];
+                let len = be32(&dh, o + 8) as usize;
+                let off = be64(&dh, o + 16);
+                if matches!(code, b"W2ru" | b"W2ku" | b"Wi2r" | b"Wi2k") && len > 0 && len < 4096 {
+                    if let Ok(b) = read_vec(&file, off, len) {
+                        names.push(utf16(&b, false));
+                    }
+                }
+            }
+            names.push(utf16(&dh[64..64 + 512], true));
+            Some(open_parent(&candidate_paths(dir, &names), depth, false)?)
+        } else {
+            None
+        };
+        Ok(Self {
+            file,
+            size: current,
+            kind: Kind::Dynamic {
+                bat,
+                block_size,
+                bitmap_size,
+            },
+            parent,
+        })
+    }
+}
+
+impl Backend for Vhd {
+    fn size(&self) -> u64 {
+        self.size
+    }
+
+    fn read_chunk(&self, voff: u64, buf: &mut [u8]) -> io::Result<usize> {
+        let Kind::Dynamic {
+            bat,
+            block_size,
+            bitmap_size,
+        } = &self.kind
+        else {
+            let n = buf.len().min((self.size - voff) as usize);
+            read_exact(&self.file, voff, &mut buf[..n])?;
+            return Ok(n);
+        };
+        let block = (voff / block_size) as usize;
+        let within = voff % block_size;
+        let mut n = buf.len().min((block_size - within) as usize);
+        let entry = bat.get(block).copied().unwrap_or(NONE);
+        if entry == NONE {
+            read_parent(&self.parent, voff, &mut buf[..n])?;
+            return Ok(n);
+        }
+        let base = entry as u64 * SECTOR;
+        let first = within / SECTOR;
+        let last = (within + n as u64 - 1) / SECTOR;
+        let nbytes = (last / 8 - first / 8 + 1) as usize;
+        let bm = read_vec(&self.file, base + first / 8, nbytes)?;
+        let bit = |s: u64| bm[(s / 8 - first / 8) as usize] & (0x80 >> (s % 8)) != 0;
+        let present = bit(first);
+        let mut s = first;
+        while s <= last && bit(s) == present {
+            s += 1;
+        }
+        n = n.min((s * SECTOR - within) as usize);
+        if present {
+            read_exact(&self.file, base + bitmap_size + within, &mut buf[..n])?;
+        } else {
+            read_parent(&self.parent, voff, &mut buf[..n])?;
+        }
+        Ok(n)
+    }
+}

crates/guara-core/src/vdisk/vhdx.rs

@@ -0,0 +1,206 @@
+//! VHDX (Hyper-V): tabela de regiões, metadados, BAT com blocos de bitmap intercalados,
+//! discos fixos, dinâmicos e diferenciais (pai achado pelo localizador de pai).
+//!
+//! O log de transações não é reproduzido: abrir a imagem nunca a escreve. Se o disco foi
+//! desligado no meio de uma escrita, os dados ainda no log não aparecem.
+
+use super::{
+    bad, candidate_paths, check_table, le16, le32, le64, open_parent, read_exact, read_parent,
+    read_vec, utf16, Backend,
+};
+use crate::source::{FileSource, Source};
+use std::io;
+use std::path::Path;
+
+const MB: u64 = 1 << 20;
+
+/// GUID em texto para os 16 bytes gravados em disco (três primeiros campos little-endian).
+fn guid(s: &str) -> [u8; 16] {
+    let hex: Vec<u8> = s
+        .replace('-', "")
+        .as_bytes()
+        .chunks(2)
+        .map(|p| u8::from_str_radix(std::str::from_utf8(p).unwrap(), 16).unwrap())
+        .collect();
+    let mut g = [0u8; 16];
+    g[..4].copy_from_slice(&[hex[3], hex[2], hex[1], hex[0]]);
+    g[4..6].copy_from_slice(&[hex[5], hex[4]]);
+    g[6..8].copy_from_slice(&[hex[7], hex[6]]);
+    g[8..].copy_from_slice(&hex[8..]);
+    g
+}
+
+pub(super) struct Vhdx {
+    file: FileSource,
+    size: u64,
+    block_size: u64,
+    sector_size: u64,
+    chunk_ratio: u64,
+    bat: Vec<u64>,
+    parent: Option<Box<dyn Source>>,
+}
+
+impl Vhdx {
+    pub(super) fn open(file: FileSource, path: &Path, depth: u32) -> io::Result<Self> {
+        let rt = read_vec(&file, 192 * 1024, 64 * 1024)?;
+        if &rt[..4] != b"regi" {
+            return Err(bad("tabela de regiões VHDX inválida"));
+        }
+        let count = le32(&rt, 8).min(2047) as usize;
+        let (mut bat_at, mut meta_at) = (None, None);
+        for i in 0..count {
+            let e = &rt[16 + i * 32..16 + (i + 1) * 32];
+            let region = (le64(e, 16), le32(e, 24) as u64);
+            if e[..16] == guid("2DC27766-F623-4200-9D64-115E9BFD4A08") {
+                bat_at = Some(region);
+            } else if e[..16] == guid("8B7CA206-4790-4B9A-B8FE-575F050F886E") {
+                meta_at = Some(region);
+            }
+        }
+        let (Some((bat_off, bat_len)), Some((meta_off, meta_len))) = (bat_at, meta_at) else {
+            return Err(bad("regiões BAT e metadados não encontradas"));
+        };
+        let meta = read_vec(&file, meta_off, meta_len.min(MB) as usize)?;
+        if &meta[..8] != b"metadata" {
+            return Err(bad("região de metadados VHDX inválida"));
+        }
+        let items = le16(&meta, 10) as usize;
+        let find = |id: [u8; 16]| -> Option<&[u8]> {
+            (0..items).find_map(|i| {
+                let e = meta.get(32 + i * 32..32 + (i + 1) * 32)?;
+                if e[..16] != id {
+                    return None;
+                }
+                let (o, l) = (le32(e, 16) as usize, le32(e, 20) as usize);
+                meta.get(o..o + l)
+            })
+        };
+        let params = find(guid("CAA16737-FA36-4D43-B3B6-33F0AA44E76B"))
+            .filter(|p| p.len() >= 8)
+            .ok_or_else(|| bad("parâmetros do arquivo VHDX ausentes"))?;
+        let block_size = le32(params, 0) as u64;
+        let has_parent = le32(params, 4) & 2 != 0;
+        let size = find(guid("2FA54224-CD1B-4876-B211-5DBED83BF4B8"))
+            .filter(|p| p.len() >= 8)
+            .map(|p| le64(p, 0))
+            .ok_or_else(|| bad("tamanho do disco VHDX ausente"))?;
+        let sector_size = find(guid("8141BF1D-A96F-4709-BA47-F233A8FAAB5F"))
+            .filter(|p| p.len() >= 4)
+            .map(|p| le32(p, 0) as u64)
+            .unwrap_or(512);
+        if block_size < MB || !block_size.is_power_of_two() || !matches!(sector_size, 512 | 4096) {
+            return Err(bad("parâmetros VHDX inválidos"));
+        }
+        let chunk_ratio = (1u64 << 23) * sector_size / block_size;
+        let payload = size.div_ceil(block_size);
+        // Com pai, cada trecho termina com a entrada do bitmap de setores, mesmo que o disco acabe antes.
+        let want = if has_parent {
+            payload.div_ceil(chunk_ratio) * (chunk_ratio + 1)
+        } else {
+            payload + payload.div_ceil(chunk_ratio)
+        };
+        let n = check_table(want.min(bat_len / 8), 8, "BAT")?;
+        let raw = read_vec(&file, bat_off, n * 8)?;
+        let bat = raw.chunks_exact(8).map(|c| le64(c, 0)).collect();
+
+        let parent = if has_parent {
+            let loc = find(guid("A8D35F2D-B30B-454D-ABF7-D3D84834AB0C"))
+                .ok_or_else(|| bad("localizador de pai VHDX ausente"))?;
+            let count = if loc.len() >= 20 {
+                le16(loc, 18) as usize
+            } else {
+                0
+            };
+            let mut names = vec![];
+            for i in 0..count {
+                let Some(e) = loc.get(20 + i * 12..20 + (i + 1) * 12) else {
+                    break;
+                };
+                let (ko, vo) = (le32(e, 0) as usize, le32(e, 4) as usize);
+                let (ks, vs) = (le16(e, 8) as usize, le16(e, 10) as usize);
+                let (Some(k), Some(v)) = (loc.get(ko..ko + ks), loc.get(vo..vo + vs)) else {
+                    continue;
+                };
+                let key = utf16(k, false);
+                if matches!(
+                    key.as_str(),
+                    "relative_path" | "absolute_win32_path" | "volume_path"
+                ) {
+                    names.push(utf16(v, false));
+                }
+            }
+            let dir = path.parent().unwrap_or(Path::new("."));
+            Some(open_parent(&candidate_paths(dir, &names), depth, false)?)
+        } else {
+            None
+        };
+        Ok(Self {
+            file,
+            size,
+            block_size,
+            sector_size,
+            chunk_ratio,
+            bat,
+            parent,
+        })
+    }
+
+    fn bat(&self, i: u64) -> u64 {
+        self.bat.get(i as usize).copied().unwrap_or(0)
+    }
+}
+
+impl Backend for Vhdx {
+    fn size(&self) -> u64 {
+        self.size
+    }
+
+    fn read_chunk(&self, voff: u64, buf: &mut [u8]) -> io::Result<usize> {
+        let block = voff / self.block_size;
+        let within = voff % self.block_size;
+        let mut n = buf.len().min((self.block_size - within) as usize);
+        let e = self.bat(block + block / self.chunk_ratio);
+        let off = e & 0xFFFF_FFFF_FFF0_0000;
+        match e & 7 {
+            6 => {
+                read_exact(&self.file, off + within, &mut buf[..n])?;
+            }
+            7 => {
+                // Parcialmente presente: o bitmap do trecho diz, setor a setor, onde está o dado.
+                let chunk = block / self.chunk_ratio;
+                let bm_entry = self.bat(chunk * (self.chunk_ratio + 1) + self.chunk_ratio);
+                let ss = self.sector_size;
+                let per_block = self.block_size / ss;
+                let first = within / ss;
+                let last = (within + n as u64 - 1) / ss;
+                let base_bit = (block % self.chunk_ratio) * per_block;
+                let bm_off = bm_entry & 0xFFFF_FFFF_FFF0_0000;
+                if bm_entry & 7 != 6 {
+                    read_parent(&self.parent, voff, &mut buf[..n])?;
+                    return Ok(n);
+                }
+                let b0 = (base_bit + first) / 8;
+                let b1 = (base_bit + last) / 8;
+                let bm = read_vec(&self.file, bm_off + b0, (b1 - b0 + 1) as usize)?;
+                let bit = |s: u64| {
+                    let p = base_bit + s;
+                    bm[(p / 8 - b0) as usize] >> (p % 8) & 1 == 1
+                };
+                let present = bit(first);
+                let mut s = first;
+                while s <= last && bit(s) == present {
+                    s += 1;
+                }
+                n = n.min((s * ss - within) as usize);
+                if present {
+                    read_exact(&self.file, off + within, &mut buf[..n])?;
+                } else {
+                    read_parent(&self.parent, voff, &mut buf[..n])?;
+                }
+            }
+            2 | 3 => buf[..n].fill(0),
+            _ => read_parent(&self.parent, voff, &mut buf[..n])?,
+        }
+        Ok(n)
+    }
+}

crates/guara-core/src/vdisk/vmdk.rs

@@ -0,0 +1,376 @@
+//! VMDK (VMware, VirtualBox): extensões esparsas (inclusive `streamOptimized` com grãos
+//! comprimidos) e descritores de texto com extensões `FLAT`, `SPARSE` e `ZERO`, como
+//! `monolithicFlat` e `twoGbMaxExtentSparse`. Discos com pai (snapshots) leem o pai nos grãos
+//! que o filho não alocou; o formato SEsparse é recusado.
+
+use super::{
+    bad, candidate_paths, check_table, le16, le32, le64, open_parent, read_exact, read_parent,
+    read_vec, Backend,
+};
+use crate::source::{FileSource, Source};
+use std::io::{self, Read};
+use std::path::Path;
+use std::sync::Mutex;
+
+const SECTOR: u64 = 512;
+const GD_AT_END: u64 = u64::MAX;
+
+struct Sparse {
+    file: FileSource,
+    grain: u64,
+    gtes: u64,
+    gd: Vec<u32>,
+    compressed: bool,
+    cache: Mutex<Option<(u64, Vec<u8>)>>,
+}
+
+enum Kind {
+    Zero,
+    Flat { file: FileSource, offset: u64 },
+    Sparse(Sparse),
+}
+
+struct Extent {
+    start: u64,
+    len: u64,
+    kind: Kind,
+}
+
+pub(super) struct Vmdk {
+    extents: Vec<Extent>,
+    size: u64,
+    parent: Option<Box<dyn Source>>,
+}
+
+/// Valor de uma chave `chave=valor` do descritor, sem aspas.
+fn desc_value(descriptor: &str, key: &str) -> Option<String> {
+    descriptor.lines().find_map(|l| {
+        l.trim()
+            .strip_prefix(key)
+            .and_then(|r| r.trim_start().strip_prefix('='))
+            .map(|v| v.trim().trim_matches('"').to_string())
+    })
+}
+
+/// Descritor (texto) de um arquivo VMDK: o próprio arquivo, se for descritor, ou o embutido
+/// logo depois do cabeçalho de uma extensão esparsa.
+fn descriptor_of(path: &Path) -> Option<String> {
+    let f = FileSource::open(path).ok()?;
+    let head = read_vec(&f, 0, (f.size() as usize).min(24 * 512)).ok()?;
+    if head.starts_with(b"KDMV") {
+        let off = (le64(&head, 28) * SECTOR) as usize;
+        let len = (le64(&head, 36) * SECTOR) as usize;
+        let d = head.get(off..(off + len).min(head.len()))?;
+        let end = d.iter().position(|&b| b == 0).unwrap_or(d.len());
+        return Some(String::from_utf8_lossy(&d[..end]).into_owned());
+    }
+    head.starts_with(b"# Disk Desc")
+        .then(|| String::from_utf8_lossy(&head).into_owned())
+}
+
+/// Como o descritor identifica o pai: pelo nome (`parentFileNameHint`) e/ou, no VirtualBox, só
+/// pelo UUID (`ddb.uuid.parent`); `cid` é o `parentCID` que o pai precisa ter.
+struct ParentRef {
+    name: Option<String>,
+    uuid: Option<String>,
+    cid: Option<String>,
+}
+
+fn parent_ref(descriptor: &str) -> Option<ParentRef> {
+    let cid = desc_value(descriptor, "parentCID")
+        .filter(|c| !c.is_empty() && !c.eq_ignore_ascii_case("ffffffff"));
+    let uuid = desc_value(descriptor, "ddb.uuid.parent")
+        .filter(|u| !u.is_empty() && u.chars().any(|c| c != '0' && c != '-'));
+    let name = desc_value(descriptor, "parentFileNameHint").filter(|n| !n.is_empty());
+    (cid.is_some() || uuid.is_some()).then_some(ParentRef { name, uuid, cid })
+}
+
+/// Procura, na pasta do filho e nas duas acima, um VMDK cujo `ddb.uuid.image` seja `uuid`.
+fn find_by_uuid(dir: &Path, uuid: &str) -> Option<std::path::PathBuf> {
+    let mut d = Some(dir);
+    for _ in 0..3 {
+        let cur = d?;
+        for e in std::fs::read_dir(cur).ok()?.flatten() {
+            let p = e.path();
+            if p.extension()
+                .is_some_and(|x| x.eq_ignore_ascii_case("vmdk"))
+                && descriptor_of(&p)
+                    .and_then(|ds| desc_value(&ds, "ddb.uuid.image"))
+                    .is_some_and(|u| u.eq_ignore_ascii_case(uuid))
+            {
+                return Some(p);
+            }
+        }
+        d = cur.parent();
+    }
+    None
+}
+
+impl Sparse {
+    fn open(file: FileSource) -> io::Result<(Self, u64, Option<String>)> {
+        let mut h = read_vec(&file, 0, SECTOR as usize)?;
+        if &h[..4] == b"SESp" || &h[..4] == b"seSp" {
+            return Err(bad("VMDK no formato SEsparse (vSphere) não é suportado"));
+        }
+        if &h[..4] != b"KDMV" {
+            return Err(bad("extensão VMDK sem assinatura KDMV"));
+        }
+        if le64(&h, 56) == GD_AT_END {
+            let size = file.size();
+            if size < 3 * SECTOR {
+                return Err(bad("VMDK truncado"));
+            }
+            h = read_vec(&file, size - 2 * SECTOR, SECTOR as usize)?;
+            if &h[..4] != b"KDMV" {
+                return Err(bad("rodapé do VMDK streamOptimized ausente"));
+            }
+        }
+        let flags = le32(&h, 8);
+        let capacity = le64(&h, 12);
+        let grain = le64(&h, 20);
+        let desc_off = le64(&h, 28);
+        let desc_len = le64(&h, 36);
+        let gtes = le32(&h, 44) as u64;
+        let gd_off = le64(&h, 56);
+        let algo = le16(&h, 77);
+        if grain == 0 || !grain.is_power_of_two() || gtes == 0 {
+            return Err(bad("cabeçalho VMDK inválido"));
+        }
+        let compressed = flags & (1 << 16) != 0;
+        if compressed && algo != 1 {
+            return Err(bad("compressão de grão VMDK desconhecida"));
+        }
+        let descriptor = if desc_off != 0 && desc_len != 0 {
+            let raw = read_vec(
+                &file,
+                desc_off * SECTOR,
+                (desc_len * SECTOR).min(1 << 20) as usize,
+            )?;
+            let end = raw.iter().position(|&b| b == 0).unwrap_or(raw.len());
+            Some(String::from_utf8_lossy(&raw[..end]).into_owned())
+        } else {
+            None
+        };
+        let gde = capacity.div_ceil(gtes * grain);
+        let n = check_table(gde, 4, "diretório de grãos")?;
+        let raw = read_vec(&file, gd_off * SECTOR, n * 4)?;
+        let gd = raw.chunks_exact(4).map(|c| le32(c, 0)).collect();
+        Ok((
+            Self {
+                file,
+                grain: grain * SECTOR,
+                gtes,
+                gd,
+                compressed,
+                cache: Mutex::new(None),
+            },
+            capacity * SECTOR,
+            descriptor,
+        ))
+    }
+
+    /// Lê dentro de um grão. O `bool` é `false` quando o grão não está alocado neste arquivo
+    /// (o chamador completa com o pai); grão zerado de propósito devolve zeros.
+    fn read(&self, off: u64, buf: &mut [u8]) -> io::Result<(usize, bool)> {
+        let g = off / self.grain;
+        let within = off % self.grain;
+        let n = buf.len().min((self.grain - within) as usize);
+        let gt_sector = self.gd.get((g / self.gtes) as usize).copied().unwrap_or(0) as u64;
+        let mut sector = 0u64;
+        if gt_sector > 1 {
+            let mut b = [0u8; 4];
+            read_exact(&self.file, gt_sector * SECTOR + (g % self.gtes) * 4, &mut b)?;
+            sector = u32::from_le_bytes(b) as u64;
+        }
+        if sector == 0 {
+            return Ok((n, false));
+        }
+        if sector == 1 {
+            buf[..n].fill(0);
+            return Ok((n, true));
+        }
+        if !self.compressed {
+            read_exact(&self.file, sector * SECTOR + within, &mut buf[..n])?;
+            return Ok((n, true));
+        }
+        let mut cache = self.cache.lock().unwrap();
+        if cache.as_ref().map(|c| c.0) != Some(g) {
+            let mut m = [0u8; 12];
+            read_exact(&self.file, sector * SECTOR, &mut m)?;
+            let csize = le32(&m, 8) as usize;
+            if csize == 0 || csize > self.grain as usize * 2 {
+                return Err(bad("grão VMDK comprimido com tamanho inválido"));
+            }
+            let raw = read_vec(&self.file, sector * SECTOR + 12, csize)?;
+            let mut out = Vec::with_capacity(self.grain as usize);
+            flate2::read::ZlibDecoder::new(&raw[..]).read_to_end(&mut out)?;
+            out.resize(self.grain as usize, 0);
+            *cache = Some((g, out));
+        }
+        let data = &cache.as_ref().unwrap().1;
+        buf[..n].copy_from_slice(&data[within as usize..within as usize + n]);
+        Ok((n, true))
+    }
+}
+
+/// Extensões de um descritor de texto: `RW 2048 FLAT "disco-f001.vmdk" 0`.
+fn parse_descriptor(text: &str, dir: &Path) -> io::Result<Vec<Extent>> {
+    let mut out = vec![];
+    let mut start = 0u64;
+    for line in text.lines() {
+        let l = line.trim();
+        let mut it = l.split_whitespace();
+        let (Some(access), Some(sectors), Some(kind)) = (it.next(), it.next(), it.next()) else {
+            continue;
+        };
+        if !matches!(access, "RW" | "RDONLY" | "NOACCESS") {
+            continue;
+        }
+        let Ok(sectors) = sectors.parse::<u64>() else {
+            continue;
+        };
+        let len = sectors * SECTOR;
+        let name = match (l.find('"'), l.rfind('"')) {
+            (Some(a), Some(b)) if b > a => Some(&l[a + 1..b]),
+            _ => None,
+        };
+        let kind = match kind {
+            "ZERO" => Kind::Zero,
+            "FLAT" | "VMFS" => {
+                let name = name.ok_or_else(|| bad("extensão FLAT sem nome de arquivo"))?;
+                let offset = l
+                    .rsplit_once('"')
+                    .and_then(|(_, r)| r.trim().parse::<u64>().ok())
+                    .unwrap_or(0);
+                Kind::Flat {
+                    file: FileSource::open(&dir.join(name))?,
+                    offset: offset * SECTOR,
+                }
+            }
+            "SPARSE" => {
+                let name = name.ok_or_else(|| bad("extensão SPARSE sem nome de arquivo"))?;
+                let (sp, cap, _) = Sparse::open(FileSource::open(&dir.join(name))?)?;
+                if cap != len {
+                    return Err(bad("tamanho da extensão VMDK difere do descritor"));
+                }
+                Kind::Sparse(sp)
+            }
+            other => return Err(bad(format!("tipo de extensão VMDK {other} não suportado"))),
+        };
+        out.push(Extent { start, len, kind });
+        start += len;
+    }
+    if out.is_empty() {
+        return Err(bad("descritor VMDK sem extensões"));
+    }
+    Ok(out)
+}
+
+impl Vmdk {
+    fn open_parent_of(r: &ParentRef, dir: &Path, depth: u32) -> io::Result<Box<dyn Source>> {
+        let mut found = r
+            .name
+            .as_ref()
+            .map(|n| candidate_paths(dir, std::slice::from_ref(n)))
+            .unwrap_or_default();
+        let by_name = found.iter().any(|p| p.is_file());
+        if !by_name {
+            if let Some(p) = r.uuid.as_deref().and_then(|u| find_by_uuid(dir, u)) {
+                found = vec![p];
+            }
+        }
+        if r.name.is_none() && r.uuid.is_none() {
+            return Err(bad(
+                "VMDK com pai, mas o descritor não diz qual (sem parentFileNameHint nem ddb.uuid.parent)",
+            ));
+        }
+        if r.name.is_none() && found.is_empty() {
+            return Err(bad(
+                "VMDK com pai identificado só por UUID (VirtualBox) e o pai não está na pasta do filho nem nas duas acima",
+            ));
+        }
+        if let Some(cid) = &r.cid {
+            // o pai precisa ser o mesmo de quando o filho foi criado
+            if let Some(p) = found.iter().find(|p| p.is_file()) {
+                let have = descriptor_of(p).and_then(|d| desc_value(&d, "CID"));
+                if have
+                    .as_deref()
+                    .is_some_and(|h| !h.eq_ignore_ascii_case(cid))
+                {
+                    return Err(bad(format!(
+                        "o pai {} foi alterado depois do filho (CID {} em vez de {cid}); os dados do filho não valem mais",
+                        p.display(),
+                        have.unwrap_or_default()
+                    )));
+                }
+            }
+        }
+        open_parent(&found, depth, false)
+    }
+
+    pub(super) fn open(file: FileSource, path: &Path, depth: u32) -> io::Result<Self> {
+        let mut head = [0u8; 4];
+        let _ = file.read_at(0, &mut head);
+        let dir = path.parent().unwrap_or(Path::new("."));
+        let (extents, descriptor) = if &head == b"KDMV" {
+            let (sp, size, descriptor) = Sparse::open(file)?;
+            (
+                vec![Extent {
+                    start: 0,
+                    len: size,
+                    kind: Kind::Sparse(sp),
+                }],
+                descriptor,
+            )
+        } else {
+            if file.size() > 1 << 20 {
+                return Err(bad("descritor VMDK grande demais"));
+            }
+            let raw = read_vec(&file, 0, file.size() as usize)?;
+            let text = String::from_utf8_lossy(&raw).into_owned();
+            (parse_descriptor(&text, dir)?, Some(text))
+        };
+        let parent = match descriptor.as_deref().and_then(parent_ref) {
+            Some(r) => Some(Self::open_parent_of(&r, dir, depth)?),
+            None => None,
+        };
+        let size = extents.iter().map(|e| e.len).sum();
+        Ok(Self {
+            extents,
+            size,
+            parent,
+        })
+    }
+}
+
+impl Backend for Vmdk {
+    fn size(&self) -> u64 {
+        self.size
+    }
+
+    fn read_chunk(&self, voff: u64, buf: &mut [u8]) -> io::Result<usize> {
+        let i = self.extents.partition_point(|e| e.start + e.len <= voff);
+        let Some(e) = self.extents.get(i) else {
+            return Ok(0);
+        };
+        let rel = voff - e.start;
+        let n = buf.len().min((e.len - rel) as usize);
+        match &e.kind {
+            Kind::Zero => {
+                buf[..n].fill(0);
+                Ok(n)
+            }
+            Kind::Flat { file, offset } => {
+                read_exact(file, offset + rel, &mut buf[..n])?;
+                Ok(n)
+            }
+            Kind::Sparse(s) => {
+                let (got, allocated) = s.read(rel, &mut buf[..n])?;
+                if !allocated {
+                    read_parent(&self.parent, voff, &mut buf[..got])?;
+                }
+                Ok(got)
+            }
+        }
+    }
+}