diff --git a/CLAUDE.md b/CLAUDE.md index 069daa3..e5f30c5 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -12,6 +12,7 @@ Ferramenta em Go para preparar máquinas Windows, Linux e macOS com um comando ( - `docs/diagnostico.md`: `toolkit diagnostico` (só leitura; funciona sem admin e lê mais quando já roda como admin, sem nunca elevar sozinho: `Deps.Admin`, `Skipped.NeedsAdmin`): o que cada SO lê, regras e limiares do resumo "o que está ruim e o que fazer", série, UUID, MAC e hostname lidos, informações sem máscara (decisão do Paulo: é ferramenta de análise), `--completo`, `--json`, `--relatorio`. Código em `internal/diagnostico` (coleta_win/lin/mac, analise, relatorio) e `internal/cli/diagnostico.go`; coletores só pelo `exec.ReadOnlyRunner` e `Deps` injetáveis. - `docs/rede.md`: `toolkit rede` (só leitura; sem Elevate, sem varredura, sem escrita, sem requisição externa): o que cada SO lê, achados e severidades (5 níveis, portas sensíveis em lista fechada), administrador, limites honestos, o que NUNCA faz. Aba da TUI em `docs/tui.md` (Rede › Análise). IP público e portal cativo SÓ sob pedido (`toolkit rede ip`/`portal`, tecla `o`/`w` na TUI; PR9, decisões 1 e 2 do plano): sem serviço padrão, só com URL informada, confirmação que nomeia o serviço, sem redirecionamento. - `docs/otimizacao.md`: `toolkit otimizacao` (só Windows, SÓ LEITURA; parte A da função 3: gargalos de CPU, memória, disco do sistema, inicialização, serviços automáticos e boot (evento 100; sem evento = "sem dado", nunca "rápido")): o que lê (CIM `Win32_PerfFormattedData_*`, não `Get-Counter`, que é traduzido), limiares com fronteira testada, lista fixa do que NÃO faz (`NeverList`/`NeverRecommendTerms`), `--completo`, `--json`, `--relatorio`, seção Otimização da TUI. Código em `internal/otimizacao` e `internal/cli/otimizacao.go`. **Parte B (PR12, EXPERIMENTAL): `toolkit otimizacao animacoes [--dry-run] [--yes]` e `... desfazer`** (`internal/animacoes`, `internal/cli/otimizacao_animacoes.go`): catálogo FECHADO só HKCU com o único valor confirmado em fonte oficial (`MinAnimate` REG_SZ "0"; `TaskbarAnimations` e `VisualFXSetting` ficaram fora, A VERIFICAR), plano antes, backup por SID (0600, dono gravado) ANTES da 1ª escrita e validado contra o catálogo antes de qualquer leitura/escrita, reaplicar não sobrescreve o original, desfazer restaura tipo e conteúdo (apaga só o que não existia), System das animações recusa tudo fora de `HKCU\\` (`ErrSoHKCU`), nunca Elevate, reaproveita o `reg.exe` da privacidade (ausência provada). TUI: Máquina › Otimização, `m` alterna Gargalos/Animações (`internal/tui/otimizacao_anim.go`: p, a…, d…, c; confirmação única, plano por ID de uso único, faixa de resultado). +- `docs/usb.md`: `toolkit usb` (só Windows, **EXPERIMENTAL**, PR14 do plano: sem VM): modo empresa, só os USB conectados hoje; limite honesto (VID/PID clonado passa), a PROVA dos essenciais pela árvore PnP, ordem do aplicar, reversão automática, desfazer garantido, roteiro de recuperação e a lista A VERIFICAR em VM. - `docs/privacidade.md`: `toolkit privacidade` (só Windows): perfis, plano antes, backup e `desfazer` (com zero pendências também pergunta e revalida antes de remover o backup; o mesmo nas animações), administrador explícito, `--dry-run`. - `docs/apps-nativos.md`: `toolkit apps-nativos` (só Windows): catálogo fechado e lista de negação, perfis, escopo usuário x todos, administrador, backup, como reinstalar (sem desfazer automático), aba da TUI. - `docs/receitas.md`: formato das receitas, ciclo de reboot e retomada, exemplos e a seção do `diag-rede` (Linux e macOS, só leitura, sem máscara, alvos por `TOOLKIT_DIAG_*` e idioma por `TOOLKIT_LANG`/`LANG`). Resumo legível dos diagnósticos: campo `render` (renderizadores em `internal/diagfmt`: windows/linux/macos memory e disks), tecla `d` na aba Diagnóstico e `recipe run --detalhes` mostram a saída original; Log da TUI com `✓ nome`. @@ -82,6 +83,7 @@ Ferramenta em Go para preparar máquinas Windows, Linux e macOS com um comando ( - Gate: `scripts/ci.sh` (ou `make ci`; `~/.local/bin` entra no FIM do PATH; o gofmt vai por `scripts/check-gofmt.sh`, que reprova também sintaxe quebrada, com autoteste em `scripts/check-gofmt_test.sh`). Actions do workflow fixadas por SHA de commit (versão em comentário) e checkout com `persist-credentials: false`. Heavy pelo build-slot: `~/.maestri-local/build-slot.sh ./scripts/ci.sh`. `.github/workflows/ci.yml` só em `workflow_dispatch`. - `toolkit privacidade` (`internal/cli/privacidade.go`, núcleo em `internal/privacidade`, texto em `docs/privacidade.md`): sem args só mostra estado e planos; `aplicar --perfil basico|recomendado [--dry-run] [--yes] [--somente-usuario]` imprime o plano, recusa sem administrador ANTES de mudar (nunca eleva sozinho), pede `[s/N]` (sem terminal exige `--yes`), grava backup e aplica; `desfazer` restaura do backup. Fora do Windows recusa sem tocar em nada. `Deps.Priv` (System/Store/Now) injetável; os testes usam um Windows em memória. Depois de confirmar (e com `--yes`) o CLI recalcula o plano (e o backup, no desfazer) e recusa sem mutação se mudou ("o estado mudou desde o plano mostrado"), como a TUI; o mesmo vale para `apps-nativos remover`. +- `toolkit usb` (`internal/cli/usb.go` e `tui_usb.go`, núcleo em `internal/usb`, texto em `docs/usb.md`; PR14 do plano, **EXPERIMENTAL**: nunca rodou numa máquina real, tudo que depende do Windows é A VERIFICAR em VM e NADA se aplica por padrão): modo empresa de USB permitidos, SÓ Windows. `usb` (estado, só leitura), `usb aplicar [--prazo N (padrão 10, mín 2, máx 60)] [--dry-run] [--yes]`, `usb confirmar`, `usb desfazer [--dry-run] [--yes]` e o subcomando OCULTO `usb reverter` (o que a tarefa de reversão executa: o mesmo `usb.Undo`, sem pergunta). Fora do Windows recusa sem tocar em nada (Linux/macOS são PR15/PR16). Núcleo: `System` (Edition/IsAdmin/Devices/ReadTree/RegWrite/RegDelete/KeyDelete/ExportReg/ProtectDir/StageBinary/ArmTask/ReadTask/DeleteTask; a implementação real usa `reg.exe` e `powershell.exe` por caminho absoluto, leituras pelo `exec.ReadOnlyRunner`, escritas pelo `MutatingRunner` e NUNCA `Elevate`: o administrador é conferido antes e o toolkit nunca eleva sozinho; scripts PowerShell constantes, ASCII, sem aspas duplas), `Analyze(devs, excluded)` (árvore de pais por `NewDeviceTree`, que recusa pai desconhecido, ciclo, instância repetida e raiz diferente de 1; barramento pelo prefixo da instância; política candidata = IDs de hardware com VID/PID dos USB marcados + 6 genéricos fechados, negação SÓ das 2 classes de USB, camada primeiro e negação por último; a PROVA avalia a política contra a árvore e exige todos os essenciais (Keyboard/Mouse/HIDClass de qualquer barramento, disco/controladores/hub raiz internos, todos os nós de um composto, os pais) permitidos), `BuildPlan` (só leitura; recusa Home/edição, política pré-existente em Restrictions e falta de prova), `Apply` (ordem: prazo, edição, admin, sem backup nem tarefa anteriores, prova, pasta protegida + backup SHA-256 relido, cópia do binário com hash, tarefa de reversão criada e CONFERIDA, só então as chaves; falha antes = zero alterações e a tarefa e o backup saem; falha no meio = restauração imediata e, se falhar, tarefa e backup ficam), `Undo` (restaura EXATAMENTE o snapshot; nunca apaga Restrictions às cegas; conflito com valor alterado por fora = para; snapshot ausente/corrompido depois de aplicar = `ESTADO ORIGINAL DESCONHECIDO`, sem escrever), `Confirm` (confere que a tarefa é a do toolkit e a remove), `ReadStatus`/`BuildUndo`. `checkRel`/`checkWrite` são a lista fechada de alvos (nada de DenyUnspecified, DenyDeviceIDs, retroativo). `FileStore` (`usb-backup.json` atômico com hash; o hash detecta corrupção, a ACL da pasta `C:\ProgramData\toolkit` impede adulteração). `internal/usb/usbtest` (Sys e MemStore em memória, dados sintéticos) serve CLI e TUI. `Deps.Usb` (System/Store/Now) injetável. Depois do `[s/N]` o CLI recalcula o plano (ou o desfazer e o snapshot) e recusa sem mutação se mudou. `ApplyOptions.ExpectedPlan`: o Apply recalcula o plano e recusa (`ErrPlanChanged`) antes do backup se ele diferir do mostrado. Teclado/mouse/HID desmarcado = recusa por regra (independe da classe do nó: um nó `HIDClass` simples NÃO é negado pela política, limite honesto a verificar em VM). TUI: seção **USB permitidos (experimental)** na área Segurança, que NÃO lê nada ao abrir (leitura do PnP é lenta: tecla `c`) (`internal/tui/usb_tab.go`; tecla nova `n` = manter…, com confirmação própria; plano de uso único por ID como a Privacidade; prazo estático "reverte às HH:MM"); Início ganhou o objetivo "Permitir só os USB conhecidos (modo empresa) — experimental" (`! só Windows` / `! experimental`). - `toolkit rede` (`internal/cli/rede.go`, núcleo em `internal/rede`, texto em `docs/rede.md`; PR8 do plano de segurança e TUI): análise de rede SÓ LEITURA (IPs, perfil, tipo de segurança do Wi-Fi conectado, DNS, portas em escuta, firewall, IPv6 privacy). `rede.Collect(ctx, goos, Deps{Runner, ReadFile, Glob, Now, Lang, Admin})` roda só pelo `exec.ReadOnlyRunner` (nenhum `Elevate`; o que pede root vira `Skipped.NeedsAdmin`), com caminho absoluto no Windows/macOS, `LookPath` + `LC_ALL=C` no Linux; o nmcli leva SEMPRE `--rescan no` e o macOS lê o Wi-Fi por `ipconfig getsummary ` (passivo), nunca varre nem lê senha; `contrato_test.go` fixa a lista fechada de comandos, os termos proibidos e que o pacote não tem `net/http`/`net.Dial`/`os/exec`. `rede.Analyze` dá achados de 5 níveis (alta/média/baixa/info/ok; `Finding.ID` estável; textos pt/en/es via `diagfmt.T`; "sem dado" nunca vira ok; portas sensíveis em tabela fechada, só em endereço não local, severidade pelo firewall); `Summary`/`Full` montam o texto. Flags `--completo`, `--json`, `--relatorio` (0600, nunca sobrescreve; aviso de dados da rede local no stderr antes de gravar). `Deps.Rede` (`RedeDeps{Collect, Now, IsAdmin}`; sem IsAdmin usa o do diagnóstico). IP público e portal cativo (PR9, `internal/rede/publico.go`; `Collect` NUNCA os chama): SÓ SOB PEDIDO e SÓ com a URL que a pessoa informa (`TOOLKIT_IP_URL`/`--servico-ip`, `TOOLKIT_PORTAL_URL`/`--servico-portal`; `rede.NewPlan` valida com `catalog.CheckURL`: https, host público, 443, sem userinfo/fragmento/IP literal/localhost; sem URL = "nenhum serviço configurado", nada enviado; NUNCA embutir serviço padrão). `rede.Fetcher` (interface) mantém `internal/rede` sem `net/http`; o cliente real é `internal/rede/httpclient` (TLS 1.2+, sem proxy, sem cookies, SEM seguir redirecionamento, 5 s, corpo 1 KiB, recusa endereço não público, User-Agent `toolkit`). `QueryPublicIP` valida a resposta como IP público por `netip` (corpo nunca é mostrado); `ProbePortal`: 204 livre, 3xx/200/511 "possível portal cativo" (nada aberto). Antes de enviar: `Plan.Describe` (host, o que é enviado, o que se revela), `[s/N]`/`--yes` (sem terminal exige `--yes`), `--dry-run` não envia; na TUI o plano exibido é de uso único. `Report.PublicIP`/`Portal` só são preenchidos depois da confirmação; achado `maquina-exposta` cruza portas e firewall já lidos ("o toolkit não testa de fora"; CGNAT = provavelmente não alcançável por IPv4). `RedeDeps.Fetcher` injetável (testes: cliente falso que conta chamadas; nunca a internet). TUI: `internal/tui/rede_tab.go` (`RedeTab` sobre `NetBackend` + `NetQueryBackend` opcional (teclas `o` IP público… e `w` portal cativo…, confirmação única, uso único do plano); leitura só quando a pessoa pede, `c`, Esc cancela; estados do `stateview.go`; resumo+achados no topo e dados rolando; sem `d` nem `Detailer`), backend real em `internal/cli/tui_rede.go`; o Início deixou de marcar "Analisar a rede" como em breve (`Unavailable` segue existindo como mecanismo). - `toolkit otimizacao` (`internal/cli/otimizacao.go`, núcleo em `internal/otimizacao`, texto em `docs/otimizacao.md`): só Windows, só leitura, sem administrador (o log de boot pode negar: `Skipped.NeedsAdmin`, o toolkit nunca eleva). `Collect(ctx, goos, Deps) *Report` (fora do Windows não chama o Runner: `Supported=false`), `Analyze(r, lang) []Finding`, `Summary`, `Full`, `Legend`, `NeverList`. Scripts PowerShell constantes, ASCII, via `exec.ReadOnlyRunner` (teste de contrato percorre todos). `Deps.Otim` (`Collect`/`Now`/`IsAdmin`) injetável. Fora do Windows o comando recusa sem ler nem gravar (como a privacidade). Seção "Otimização" da TUI (3ª da área Máquina, `internal/tui/otimizacao_tab.go`, backend em `internal/cli/tui_otimizacao.go`): NÃO lê ao abrir, `c`/Enter lê, `Esc` cancela, painel de detalhe com os limiares; objetivo "Deixar o Windows mais leve" no Início (só promete a leitura). - `toolkit apps-nativos` (`internal/cli/apps_nativos.go`, núcleo em `internal/appsnativos`, texto em `docs/apps-nativos.md`): sem args lista o catálogo fechado com instalado/ausente; `remover (--perfil basico|completo | --app id...) [--todos-usuarios] [--dry-run] [--yes]` imprime SEMPRE o plano, recusa `--todos-usuarios` sem administrador ANTES de mudar (nunca eleva sozinho), pede `[s/N]` (sem terminal exige `--yes`), grava backup por SID e remove; `reinstalar` só IMPRIME como reinstalar do backup (sem desfazer automático). Fora do Windows recusa sem tocar em nada. `Deps.AppsNat` (System/Store/Now) injetável; os testes usam um Windows em memória. Aba da TUI "Apps nativos" (6ª, `internal/tui/apps_nativos_tab.go`, backend em `internal/cli/tui_apps_nativos.go`, mesmo molde da Privacidade): espaço marca, `b` marca o perfil básico, `t` todo o catálogo, `m` todos os usuários (exige administrador), `p` plano, `r` plano + `[s/N]` dentro da TUI, `i` como reinstalar (só texto); plano de USO ÚNICO com ID opaco (`Apply(sel, ID)`, recálculo idêntico ou `ErrNatStalePlan`), Esc cancela a preparação, fora do Windows só avisa. diff --git a/README.md b/README.md index 1422906..5a66bd9 100644 --- a/README.md +++ b/README.md @@ -65,6 +65,7 @@ toolkit recipe list toolkit recipe run wsl-dev toolkit recipe status toolkit diagnostico # saúde da máquina, só leitura: o que está ruim e o que fazer (docs/diagnostico.md) +toolkit usb # modo empresa: USB permitidos (Windows, EXPERIMENTAL; veja docs/usb.md): só lê o estado; aplicar/confirmar/desfazer toolkit rede # análise da rede, só leitura: IPs, Wi-Fi, DNS, portas em escuta, firewall (docs/rede.md) toolkit otimizacao # Windows: o que pesa na máquina (CPU, memória, disco, inicialização), só leitura (docs/otimizacao.md) toolkit rede ip --servico-ip URL # IP público, SÓ sob pedido, com serviço que você informa e confirmação (sem serviço padrão) diff --git a/docs/plano-seguranca-e-tui.md b/docs/plano-seguranca-e-tui.md index c0ee60b..73c3869 100644 --- a/docs/plano-seguranca-e-tui.md +++ b/docs/plano-seguranca-e-tui.md @@ -487,7 +487,7 @@ Continuação da numeração dos PRs de produto (o último documentado é o PR8 | **PR11** Otimização: leitura de gargalos | `internal/otimizacao` (leitura), `toolkit otimizacao`, TUI área 2 > Otimização (parte Gargalos) | nada | baixo | fixtures; limiares com fronteira; "sem evento" não vira "rápido" | | **PR12** Otimização: animações (muda `HKCU`) | plano, backup, desfazer, API `SystemParametersInfo`, TUI parte Animações | PR11, valores confirmados em VM | médio | ida e volta; nenhuma escrita em `HKLM`; nenhum serviço | | **PR13** Apps: acesso remoto (RustDesk, se aprovado) | entrada com aviso de segurança | decisão do Paulo e id confirmado | médio | aviso na tela; hash fixado; sem configuração do app | -| **PR14** USB: Windows | `internal/usb`, leitura PnP, plano, política em camadas, timer de reversão, backup/desfazer, TUI área 3 > USB permitidos, `docs/usb.md` com roteiro de recuperação | tudo acima, VM de laboratório | **alto** | todos os testes da função 1; roteiro de recuperação **testado em VM**; revisão reforçada; só depois do smoke do Paulo | +| **PR14** USB: Windows (feito como EXPERIMENTAL, sem VM: `docs/usb.md`) | `internal/usb`, leitura PnP, plano, política em camadas, timer de reversão, backup/desfazer, TUI área 3 > USB permitidos, `docs/usb.md` com roteiro de recuperação | tudo acima, VM de laboratório | **alto** | todos os testes da função 1; roteiro de recuperação **testado em VM**; revisão reforçada; só depois do smoke do Paulo | | **PR15** USB: Linux (USBGuard) | `usbguard` via apt/dnf, `rules.conf`, serviço com confirmação | PR14 (reuso do desenho) | alto | idem; sem pacote no gerenciador = "indisponível" | | **PR16** USB: macOS (orientação) | texto e, se existir forma suportada, leitura; sem mudança | PR14 | baixo | texto honesto; nada executa | @@ -501,14 +501,14 @@ Sugestão de **ordem**: PR8, PR10, PR11 podem andar em paralelo (independentes); | 2 | O portal cativo entra na primeira versão da análise de rede? (PR8: aplicada a recomendação, fora da fase; PR9: entra junto do IP público, só sob pedido e com URL informada) | **Não**: junto do IP público, no PR9 | | 3 | RustDesk entra no catálogo, dadas as CVEs de 2026 e o uso em golpes? | **Resolvida no PR13 (2026-11-14): entra**, no macOS (cask) e no Linux (flatpak), com o aviso na tela e a versão mínima **1.5.0** verificada no NVD; **sem instalador no Windows** (id do winget inexistente). O toolkit NÃO enforça a versão mínima (ver [Verificação do PR13](#verificação-do-pr13-rustdesk-e-versão-mínima)) | | 4 | Chrome entra apesar da possibilidade de falha de hash por URL do fabricante mutável? | **Entra**, com a mensagem explicativa; hash divergente nunca é contornado | -| 5 | USB no Windows Home: recusar ou tentar? | **Recusar** (a Microsoft não lista a edição); revalidar na VM | -| 6 | USB: identificar por ID de hardware (modelo) ou por ID de instância (unidade)? | **ID de hardware** com todos os nós do dispositivo; instância só se a VM mostrar que é estável | -| 7 | Prazo do timer de reversão | **10 minutos**, configurável por flag, mínimo 2 | +| 5 | USB no Windows Home: recusar ou tentar? (PR14: aplicada a recomendação) | **Recusar** (a Microsoft não lista a edição); revalidar na VM | +| 6 | USB: identificar por ID de hardware (modelo) ou por ID de instância (unidade)? | **ID de hardware** com todos os nós do dispositivo; instância só se a VM mostrar que é estável (PR14: aplicada a recomendação) | +| 7 | Prazo do timer de reversão | **10 minutos**, configurável por flag, mínimo 2 (PR14: aplicada, `--prazo`, máximo 60) | | 8 | Linux: aceitar USBGuard só onde há pacote no gerenciador? | **Sim**; Arch fica de fora até confirmar pacote oficial | | 9 | macOS: só orientação? | **Sim** | | 10 | Otimização: incluir mais que animações (ex.: efeitos de transparência, modo de energia)? | **Não** nesta rodada; só animações (reversíveis por usuário) | | 11 | Categoria nova `remoto` para acesso remoto, ou `utilitarios`? | **`utilitarios`** (não criar categoria por um app) | -| 12 | Quem tem a VM de laboratório e quando roda o smoke de USB (Windows e Linux)? | Antes de iniciar o PR14; sem VM, o PR14 não começa | +| 12 | Quem tem a VM de laboratório e quando roda o smoke de USB (Windows e Linux)? | Antes de iniciar o PR14; sem VM, o PR14 não começa. **PR14: sem VM; o Paulo e o Maestro mandaram implementar mesmo assim, COMO EXPERIMENTAL** (rótulo no título da seção, no CLI, nas docs e na ajuda; nada se aplica por padrão; lista A VERIFICAR em `docs/usb.md`). O smoke em VM continua sendo a condição para tirar o rótulo | ## Pendências A VERIFICAR diff --git a/docs/tui.md b/docs/tui.md index 4357e14..41a9925 100644 --- a/docs/tui.md +++ b/docs/tui.md @@ -21,7 +21,7 @@ saída. Em CI (`CI`, `GITHUB_ACTIONS`, `TF_BUILD` e semelhantes ligadas; vazio, ## Áreas e seções (fase 3 do redesign, variante A) A raiz tem **áreas**, cada uma com **seções** (as abas): `0 Início` (objetivos que levam às outras áreas, abaixo), `1 Instalar` (Apps, Receitas), `2 Máquina` -(Diagnóstico, Apps nativos, Otimização), `3 Segurança` (Privacidade), `4 Rede` (Análise: a leitura da rede, só leitura; veja "Rede › Análise" abaixo) e `5 Histórico` (Execuções, o Log). Tudo continua numa lista PLANA de seções (`Model.tabs`): +(Diagnóstico, Apps nativos, Otimização), `3 Segurança` (Privacidade, USB permitidos (experimental)), `4 Rede` (Análise: a leitura da rede, só leitura; veja "Rede › Análise" abaixo) e `5 Histórico` (Execuções, o Log). Tudo continua numa lista PLANA de seções (`Model.tabs`): execução, seleção, `Reloader`, resultados e origens seguem por índice plano; `Model.areas` só agrupa os índices. `NewWithAreas(o, []AreaDef)` monta o modo áreas (é o que `toolkit` abre, via `tui.RunAreas`); `New(o, tabs...)` é o modo legado (uma área por aba, números 1 a N, Tab percorre todas, sem a linha 2) e segue valendo para os testes. @@ -36,10 +36,10 @@ legado (uma área por aba, números 1 a N, Tab percorre todas, sem a linha 2) e Seção interativa (`internal/tui/inicio_tab.go`, montada em `internal/cli/tui_inicio.go`): uma lista por OBJETIVO, cada um com título, uma frase didática (quebra na largura, nunca leva reticências) e, quando vale, uma etiqueta de estado ou requisito -(símbolo + palavra, nunca só cor). Os oito objetivos: Instalar programas (1 Apps), Preparar a máquina com uma receita (1 +(símbolo + palavra, nunca só cor). Os nove objetivos: Instalar programas (1 Apps), Preparar a máquina com uma receita (1 Receitas), Ver a saúde da máquina (2 Diagnóstico), Remover apps nativos do Windows (2 Apps nativos; `! só Windows` fora do Windows), Deixar o Windows mais leve (2 Otimização; `! só Windows` fora do Windows; a descrição promete a leitura de gargalos e as animações experimentais, com backup e desfazer; sem ganho), Proteger a privacidade do Windows (3 Privacidade; `! só Windows` fora do Windows, `! pede administrador para alguns -itens` no Windows sem administrador), Analisar a rede (4 Análise) e Ver o que já rodou (5 Execuções). As etiquetas +itens` no Windows sem administrador), Permitir só os USB conhecidos (modo empresa) — experimental (3 USB permitidos (experimental); `! só Windows` fora do Windows, `! experimental · pede administrador` no Windows sem administrador e `! experimental` como administrador; Enter só abre a seção, que não lê nada até a tecla `c`), Analisar a rede (4 Análise) e Ver o que já rodou (5 Execuções). As etiquetas usam só o que o cli já sabe (GOOS e `Options.IsAdmin`): nada é lido do sistema. A etiqueta vai à direita do título quando cabe, senão numa linha própria. Com folga há uma linha em branco entre os itens (120x40); em 80x24 a lista compacta e cabe inteira. Abaixo disso rola, mantendo o item do cursor inteiro na tela, e a régua mostra `↓ mais N linhas`. @@ -281,11 +281,12 @@ Ações por sentido (a mesma letra em todas as seções): | Tecla | Sentido | Onde | |---|---|---| -| a | aplicar… (abre confirmação) | Privacidade, Otimização › Animações (experimental) | -| d | desfazer… (abre confirmação) | Privacidade, Otimização › Animações | -| p | ver plano (só leitura) | Privacidade, Apps nativos, Otimização › Animações | +| a | aplicar… (abre confirmação) | Privacidade, Otimização › Animações (experimental), USB permitidos (experimental) | +| d | desfazer… (abre confirmação) | Privacidade, Otimização › Animações, USB permitidos (experimental) | +| p | ver plano (só leitura) | Privacidade, Apps nativos, Otimização › Animações, USB permitidos (experimental) | | c | ler de novo (recarrega; em Otimização é também a primeira leitura dos gargalos; na parte Animações relê o estado) | Diagnóstico, visão Máquina; Otimização | | r | remover… (abre confirmação) | Apps nativos | +| n | manter… (abre confirmação: mantém o que foi aplicado e cancela a reversão automática) | USB permitidos (experimental), só no estado "aplicado, aguardando confirmação" | | m | alterna o escopo ou a visão: `só usuário` (Privacidade), `todos os usuários` (Apps nativos, exige administrador), `máquina` / `receitas` (Diagnóstico), `animações` / `gargalos` (Otimização) | Privacidade, Apps nativos, Diagnóstico, Otimização | | i | como reinstalar (só texto; nada é executado) | Apps nativos | | b | marca o perfil básico | Apps nativos | @@ -434,3 +435,27 @@ ctx que ele cancela ao sair). Touch ID do Paulo. Smoke manual das fases 2 e 3 (e da TUI) em Windows 11, macOS e Linux ainda por fazer. **Pendente de reinício.** Uma receita que espera reinício (`ItemReboot`) nunca vira "feito": a faixa usa o tipo `pendente` (`!`) e o título começa pela pendência ("Pendente de reinício: 1 aguardando reinício, 2 ok"), para a faixa compacta (menos de 20 linhas) não perdê-la. + +## Segurança › USB permitidos (experimental) (PR14, só Windows) + +Seção nova da área `3 Segurança` (texto completo e o roteiro de recuperação em `docs/usb.md`). **EXPERIMENTAL**: o rótulo vai no título da seção, no corpo e nas +confirmações; nunca rodou numa máquina real (A VERIFICAR em VM) e nada se aplica por padrão. `internal/tui/usb_tab.go` (`UsbTab`, `UsbBackend`, +`Reloader`, `Resulter`, `SectionHelper`); o backend real é `internal/cli/tui_usb.go`. + +- **Leitura preguiçosa**: `Init` não lê nada (a leitura do PnP varre todos os dispositivos e levaria segundos em toda abertura da TUI); a seção mostra "ainda não lido" e a primeira leitura é a tecla `c`. +- **Estados** (padronizados em `stateview.go`): carregando, erro (com `StateErrorAfterChange` depois de uma ação), fora do Windows (`StateUnsupported`), edição + sem suporte (`StateUnsupportedEdition`, novo), e os cinco estados do modo empresa: nunca aplicado (lista dos USB com `espaço` marca/desmarca), **aplicado, + aguardando confirmação** (mostra `REVERTE SOZINHO às HH:MM`; o horário é ESTÁTICO, sem contagem viva, por isso o golden é determinístico e + `TOOLKIT_REDUCE_MOTION` não muda nada), aplicado e confirmado, sobra de uma aplicação e **estado original desconhecido** (só mostra a recuperação manual). +- **Teclas** (legenda única de `keys.go`): `↑↓` dispositivo, `espaço` marcar, `p` ver plano, `a` aplicar…, `n` manter… (letra nova, só no estado armado), `d` + desfazer…, `c` ler de novo. `s`/`y` só aplicam dentro de uma confirmação aberta; plano recusado (sem prova, edição, política existente) ou desfazer sem como + restaurar nunca vira confirmação. +- **Confirmação única** (`confirm.go`) com a evidência: lista de dispositivos e o que fica permitido ou bloqueado, a prova, o risco de trancar o teclado, o + backup protegido, o prazo da reversão e o roteiro de recuperação; foco inicial em Cancelar; sem administrador o botão de confirmar fica indisponível. `n` + tem confirmação própria. +- **Plano de uso único por ID** (como a Privacidade): a confirmação só age sobre o plano exibido, Esc cancela a preparação, a resposta tardia de um plano + cancelado nunca abre nada; o backend ainda exige que o plano recalculado seja idêntico ao mostrado (inclusive a seleção de dispositivos). +- **Faixa de resultado** (`Resulter`): aplicado = `ResultPending` ("Aplicado, aguardando confirmação"; a ação não terminou até manter ou reverter), mantido, + desfeito, plano mudou, precisa de administrador, falha no meio (registro restaurado na hora). +- Início: objetivo "Permitir só os USB conhecidos (modo empresa) — experimental" (`! só Windows` / `! experimental · pede administrador` / `! experimental`). +- Goldens: `usb_{principal,confirma,confirma_semadmin,recusado,armado,manter,desconhecido,linux,home,faixa_aplicado}_{80x24,120x40,60x16}.golden`. diff --git a/docs/usb.md b/docs/usb.md new file mode 100644 index 0000000..ecb0a46 --- /dev/null +++ b/docs/usb.md @@ -0,0 +1,203 @@ +# `toolkit usb`: modo empresa, USB permitidos (Windows, EXPERIMENTAL) + +> ## EXPERIMENTAL: ainda não rodou numa máquina real +> +> Esta função foi implementada (PR14 do [plano](plano-seguranca-e-tui.md)) **sem** o smoke numa VM de laboratório que a decisão 12 do plano pedia. O Paulo e o +> Maestro mandaram implementar mesmo assim, **como experimental**. Tudo o que depende do comportamento real do Windows está marcado **A VERIFICAR em VM** +> (lista completa no fim). **Nada se aplica por padrão**: só `toolkit usb aplicar` (depois do plano e do `[s/N]`) ou a ação da TUI (depois da confirmação). +> Não use numa máquina de produção antes de rodar o roteiro de VM abaixo. + +> ## LIMITE HONESTO +> +> - **Um dispositivo que CLONA o VID/PID de um permitido PASSA.** Os IDs são anunciados pelo próprio dispositivo; um bad USB que copia o ID de um teclado +> da lista entra. +> - A política só controla a **instalação ou atualização de driver** de dispositivo novo. **O que já está instalado continua funcionando.** +> - **A política nega só as duas classes de USB (`USB` e `USBDevice`).** Um dispositivo HID **novo e simples** (não composto) costuma ter o nó USB de classe +> `HIDClass` ("USB Input Device"), que **nenhuma regra nega**: o avaliador do toolkit o considera permitido mesmo fora da lista, e esse é justamente o bad USB +> mais simples (um teclado falso). Se isso se confirmar na VM, a política **não barra** esse tipo de dispositivo (A VERIFICAR em VM, item 3 do fim; o +> plano mostra "a política NÃO o bloquearia" para o dispositivo desmarcado de classe não negada, em vez de dizer "BLOQUEADO"). +> - **Não é defesa contra atacante com acesso físico que conheça os IDs.** Isso exige controle de endpoint gerenciado (MDM/EDR) e bloqueio físico das portas. +> - Mensagem do toolkit em todos os fluxos: "Isto reduz o risco, não o elimina." + +## O que faz + +Grava a política oficial "Restrições de instalação de dispositivos" em `HKLM\SOFTWARE\Policies\Microsoft\Windows\DeviceInstall\Restrictions`, **em ordem de +camadas** (`AllowDenyLayered`), com: + +- `AllowDeviceIDs`: os IDs de **hardware** (com `VID_xxxx&PID_xxxx`) de **todos os nós** dos USB conectados e marcados (dispositivo, interfaces `&MI_xx`, nós + HID), mais um conjunto **fechado** de 6 IDs genéricos de controlador e hub raiz (`PCI\CC_0C03`, `PCI\CC_0C0330`, `PNP0CA1`, `USB\ROOT_HUB20`, + `USB\ROOT_HUB30`, `USB\USB20_HUB`). **ID compatível genérico (classe HID, `USB\COMPOSITE`...) nunca entra.** +- `DenyDeviceClasses`: **só as duas classes de USB** (`{36fc9e60-c465-11cf-8056-444553540000}` e `{88BAE032-5A81-49f0-BC3D-A4FF138216D6}`). + +**Nunca** escreve `DenyUnspecified` (global: valeria para Bluetooth, PS/2, I2C, NVMe, monitor, impressora...), nunca bloqueia por classe `Keyboard`, `Mouse`, +`HIDClass` ou `DiskDrive`, nunca liga a opção retroativa, nada fora da lista fechada de alvos (`checkRel` recusa qualquer outro caminho antes de executar). + +## Comandos + +``` +toolkit usb estado (só leitura, sem administrador) +toolkit usb aplicar [--prazo N] [--dry-run] [--yes] +toolkit usb confirmar +toolkit usb desfazer [--dry-run] [--yes] +``` + +`aplicar` mostra o plano (dispositivos, a PROVA, ordem, prazo, recuperação) e só depois do `[s/N]` (foco em Cancelar; sem terminal exige `--yes`) executa. O plano +é **recalculado depois da confirmação** e tem de ser idêntico ao mostrado (vale com `--yes`). Fora do Windows: "só existe no Windows", sem tocar em nada +(Linux é o PR15; macOS, o PR16). + +`reverter` é um subcomando **oculto** que a tarefa de reversão executa (o mesmo caminho do `desfazer`, sem pergunta). + +### Decisões (recomendação do plano, aplicada) + +| # | Decisão | Aplicado | +|---|---|---| +| 5 | USB no Windows Home | **Recusa** (a Microsoft não lista a edição). Só Pro, Enterprise e Education passam; Server, IoT e as demais também são recusadas | +| 6 | Identificar por ID de hardware ou de instância | **ID de hardware** (VID/PID, todos os nós). Instância só se a VM provar que é estável (A VERIFICAR) | +| 7 | Prazo da reversão | **10 minutos**, `--prazo N`, **mínimo 2**, máximo 60 | +| 12 | VM antes do PR14 | **Não houve VM**: por isso a função é experimental. O Maestro e o Paulo autorizaram | + +Decisões de desenho registradas neste PR (a revisar na VM): + +1. **Política pré-existente = recusa.** Se a chave `Restrictions` já tem **qualquer** valor ou subchave (GPO, MDM, outra ferramenta ou uma aplicação anterior), o + `aplicar` recusa. Ligar `AllowDenyLayered` muda a precedência de políticas que o toolkit não modela, e a prova não saberia avaliá-las. O desfazer, por outro + lado, **preserva** o que outra origem acrescentar depois (e para se um valor que o toolkit gravou foi alterado por fora). +2. A chave `Restrictions` vazia pré-existente é aceita; o snapshot registra que ela já existia e o desfazer não a apaga. +3. A tarefa de reversão executa uma **cópia do próprio toolkit** na pasta protegida (hash SHA-256 conferido contra o binário em execução), não um script + embutido: a lógica de restauração fica em Go testado. +4. **Edições:** só Pro, Enterprise e Education passam. IoT Enterprise, Server e as demais são recusadas, mesmo que a fonte do plano liste IoT Enterprise: não + foi possível confirmar o `EditionID` dela e o toolkit prefere recusar. A revisar na VM. +5. **A pasta protegida é a do estado do administrador.** `C:\ProgramData\toolkit` também guarda o estado das receitas, os logs e os backups da + privacidade (sempre de processos elevados; sem elevação o toolkit usa `%LOCALAPPDATA%\toolkit`). Trocar a ACL dela (dono Administradores, só SYSTEM e + Administradores, sem herança) vale para tudo isso. A VERIFICAR em VM que nada não elevado precisa ler ali; se precisar, mover o backup do USB para uma subpasta. +6. **A TUI não lê o PnP ao abrir.** A leitura varre todos os dispositivos e leva vários segundos; a seção mostra "ainda não lido" e a primeira leitura é a + tecla `c` (como na Otimização). O subcomando oculto `usb reverter` também não consulta versão nova. + +## A PROVA de dispositivos essenciais + +Antes de gravar qualquer chave o toolkit lê o PnP (`Get-PnpDevice -PresentOnly` e `Get-PnpDeviceProperty` com `DEVPKEY_Device_Parent`/`HardwareIds`/ +`CompatibleIds`, PowerShell por caminho absoluto, script ASCII fixo, só leitura), monta a **árvore de pais** e **avalia a política candidata contra ela, em +código** (a ordem em camadas: ID de hardware **e** compatível > classe > sem regra = permitido). Um nó é bloqueado se ele **ou qualquer pai** for bloqueado. +Só aplica se **todos** estes ficarem permitidos, com todos os pais: + +- teclado, mouse, touchpad e demais HID **de qualquer barramento** (USB, Bluetooth, PS/2, I2C/ACPI); +- discos, controladores de disco (NVMe/SATA/RAID) e controladores USB e hubs raiz **internos**; e ao menos um disco interno precisa aparecer na leitura; +- composto: **todos** os nós (`&MI_xx`) do dispositivo USB que contém um essencial; +- a cadeia de pais (por exemplo, o rádio Bluetooth USB que leva o teclado Bluetooth). + +**Teclado, mouse ou outro HID conectado e DESMARCADO = recusa por regra explícita**, qualquer que seja a classe do nó USB (mesmo que a política não o bloqueasse), +porque o toolkit não aceita deixar um essencial fora da lista. + +Leitura que falha, JSON cortado, contagem que não bate, pai desconhecido, ciclo, instância repetida ou ID com caractere de controle = **recusa**, nada é +alterado. **Teclado ou mouse conectado e desmarcado = recusa** (o plano diz qual). Desmarcar um pendrive (nó de classe `USB`) é permitido: ele fica bloqueado ao reconectar. Para um dispositivo desmarcado cuja classe a política não nega, o +plano diz que ele ficou fora da lista mas que a política **não o bloquearia**. + +## Ordem obrigatória do `aplicar` + +1. prazo (2..60) -> edição (Pro, Enterprise, Education) -> **administrador** (recusa antes de qualquer mudança; o toolkit nunca eleva sozinho) -> nenhum backup + nem tarefa anteriores; +2. plano com a **prova**, recalculado dentro do `Apply` e comparado, texto a texto, com o plano que foi MOSTRADO e confirmado (`ApplyOptions.ExpectedPlan`; + diferente = `ErrPlanChanged`, antes de qualquer passo): o que é gravado é o que foi mostrado; +3. pasta protegida `C:\ProgramData\toolkit` (caminho FIXO, nunca a variável `%ProgramData%`): criada, **dono Administradores**, ACL só de SYSTEM e + Administradores (sem herança), ponto de reparse recusado, ACL **relida em SDDL** (não depende do idioma) e conferida; +4. **backup**: `usb-backup.json` (atômico) com SHA-256 do conteúdo, de cada alvo da lista fechada (inclusive "não existia"), e `usb-restrictions-backup.reg` + (com hash) quando a chave já existia; relido e comparado com o gravado; +5. cópia do binário na pasta protegida (hash da cópia = hash do original); +6. **tarefa de reversão** criada (SYSTEM, execução única, `StartWhenAvailable`, **até 3 novas tentativas, 1 por minuto**, se o programa sair com erro; comando fixo) e **conferida**: existe, habilitada, programa e argumento **exatos**, + SYSTEM, próximo disparo no futuro e dentro do prazo (com folga de 2 min); +7. **só então** as chaves, na ordem segura: `AllowDenyLayered` primeiro (sem ela a negação venceria a liberação), a lista de IDs, e a negação **por último**; +8. releitura: cada entrada tem de estar como gravada. + +Falha em qualquer passo antes da primeira chave = **zero alterações** (a tarefa e o backup deste `aplicar` são removidos). Falha no meio das chaves: tentativa +de **restauração imediata**; se ela também falhar, a tarefa e o backup ficam como reserva. + +## Reversão automática e `confirmar` + +Sem `toolkit usb confirmar` dentro do prazo, a tarefa executa `toolkit usb reverter` (como SYSTEM, sem sessão) e restaura o snapshot sozinha. `confirmar` +(ou a tecla `n` na TUI, com confirmação própria e foco em Cancelar) confere que a tarefa é **exatamente** a do toolkit, remove só ela e mantém a política e o +backup. Viabilidade (tarefa rodando sem sessão e com o teclado bloqueado, depois de reiniciar, ACL, comportamento se a máquina desligar antes do prazo): +**A VERIFICAR em VM**. + +**Reversão que falha deixa rastro.** O `reverter` (SYSTEM) NÃO pergunta administrador por outro PowerShell (a própria tarefa prova o SYSTEM; sem direito o +`reg.exe` falha sozinho e nada é escrito às cegas) e grava o resultado, de sucesso ou de erro, em `usb-revert-result.txt` na pasta protegida. `toolkit usb` e a +seção da TUI mostram "a reversão automática rodou e falhou: ..." (um valor mudado por GPO/MDM entre o aplicar e a reversão vira conflito e a reversão recusa). +O Apply seguinte apaga o rastro velho. Se a reversão falhar, o backup e a tarefa NÃO são apagados. + +**Confirmar com a reversão já rodando.** Remover a tarefa não para uma execução em andamento: depois de remover, o `confirmar` relê o estado e só diz +"confirmado" se a política ainda está aplicada. + +**Preparação.** A árvore do registro é lida de novo logo antes da primeira escrita; se mudou na janela (GPO/MDM), o aplicar aborta sem escrever. Se o toolkit +foi iniciado de uma pasta que usuário comum grava (fora de Program Files e Windows), o plano avisa: a tarefa executa uma CÓPIA dele. + +**Pasta protegida já existente.** `C:\ProgramData\toolkit` pode ter sido criada por um usuário comum antes. Além do dono e da ACL da pasta, o toolkit refaz a ACL +e o dono de cada FILHO (`icacls /reset` e `/setowner`, nunca na pasta raiz), recusa link (ponto de reparse) dentro dela e apaga um `.reg` velho antes do export. +Antes de importar o `.reg` no roteiro manual, confira o SHA-256 dele com o que está no `usb-backup.json` (`Get-FileHash`). + +## Desfazer garantido + +- Restaura **exatamente o snapshot validado** (`usb-backup.json`: hash, estrutura, caminhos só da lista fechada, tamanho limitado). **Nunca apaga a chave + `Restrictions` às cegas**: só remove o que o toolkit criou (valores, subchaves `AllowDeviceIDs`/`DenyDeviceClasses` **vazias** e, se o snapshot registra que + ela não existia e está vazia, a própria `Restrictions`). Política de outra origem que apareça depois **fica**. +- Valor que o toolkit gravou e que agora tem outro conteúdo = **conflito**: nada é escrito. +- **Snapshot ausente, corrompido ou adulterado depois de uma aplicação** (a tarefa de reversão existe, ou há chaves da lista fechada sem snapshot): o toolkit + diz **ESTADO ORIGINAL DESCONHECIDO**, **não escreve nada** e mostra a recuperação manual. "Nada a desfazer" só aparece quando nunca houve aplicação. +- O hash detecta **corrupção**; quem impede **adulteração** é a ACL da pasta protegida (quem pode reescrever o arquivo com hash novo já é administrador). + +## Se o teclado travar mesmo assim (roteiro de recuperação) + +Mostrado também na confirmação e no plano. **Comandos exatos do WinRE e do Modo Seguro: A VERIFICAR em VM.** + +1. Espere o prazo: a tarefa de reversão restaura sozinha. +2. Use outro teclado ou mouse **já permitido** (tenha um de reserva). +3. Entre com **outra conta de administrador**, restaure o `.reg` íntegro de `C:\ProgramData\toolkit`. **Só apague** a chave + `HKLM\SOFTWARE\Policies\Microsoft\Windows\DeviceInstall\Restrictions` (Editor de Registro ou `gpedit.msc`) **depois de confirmar que não havia política + anterior** (GPO de domínio, MDM ou outra ferramenta); senão apagaria uma política que não é do toolkit. Sem o `.reg` íntegro, o toolkit não tem como saber o + estado original: confira com quem administra a máquina. +4. **Modo Seguro** (se a política também vale nele: A VERIFICAR). +5. **Ambiente de Recuperação do Windows (WinRE)**: prompt de comando, `reg load` do hive `SOFTWARE` offline do Windows instalado, restaurar o `.reg` íntegro ou + (só se confirmado que não havia política anterior) apagar a chave de `Restrictions`, `reg unload`. **A VERIFICAR em VM.** + +## TUI + +Área `3 Segurança`, seção **USB permitidos (experimental)** (o rótulo fica no título). Início: objetivo "Permitir só os USB conhecidos (modo empresa) — +experimental", etiqueta `! só Windows` fora do Windows e `! experimental · pede administrador` (ou `! experimental`, já como administrador) no Windows. + +- Ao abrir a TUI a seção **não** lê nada ("ainda não lido"; tecla `c` lê). Lista dos USB conectados (nome, VID:PID, classe, "essencial"); `espaço` marca/desmarca; `p` plano e prova (só leitura); `a` aplicar… (confirmação única com a + evidência: lista, permitido/bloqueado, risco de trancar, backup, prazo, recuperação; foco em Cancelar; sem administrador o botão fica indisponível); + `n` manter… (confirmação própria); `d` desfazer…; `c` ler de novo. +- Estados: carregando, erro (sem negar alteração depois de uma ação), fora do Windows, edição sem suporte (Home), **aplicado aguardando confirmação** (prazo + estático "reverte às HH:MM", sem contagem viva: `TOOLKIT_REDUCE_MOTION` e goldens determinísticos), aplicado e confirmado, sobra, **estado original + desconhecido**, plano recusado (nunca vira confirmação). +- Plano de uso único por ID (como a Privacidade): a confirmação só age sobre o plano exibido; Esc cancela a preparação; a ação ainda exige que o plano + recalculado seja idêntico ao mostrado. + +## O que NUNCA faz + +Eleva sozinho; escreve fora de `...\DeviceInstall\Restrictions`; usa `DenyUnspecified`, classe ampla ou a opção retroativa; sobrescreve política de outra +origem; aplica sem a prova, sem o backup protegido ou sem a tarefa conferida; restaura às cegas; usa `-Force` ao criar a tarefa; mexe em qualquer outra tarefa. + +## A VERIFICAR em VM (nada disto foi confirmado numa máquina real) + +1. Se o registro local de `DeviceInstall\Restrictions` funciona na edição Home (o toolkit recusa de qualquer forma). +2. Formato exato da lista numerada (`AllowDeviceIDs\1`...) e dos valores de ligação (`AllowDenyLayered`, `AllowDeviceIDs`, `DenyDeviceClasses` = DWORD 1) no + registro; todos os IDs de hardware dos nós de um teclado composto real. +3. **Se as duas classes de USB bastam para impedir um dispositivo HID novo e simples (nó de classe `HIDClass`) e o filho HID de um composto**; efeito sem + `gpupdate`/reinício; se vale no Modo Seguro. (Se não bastarem, a função só barra dispositivos de classe `USB`/`USBDevice`, como armazenamento em massa.) +4. `Get-PnpDevice`/`Get-PnpDeviceProperty` (`DEVPKEY_Device_Parent`): disponibilidade e formato por versão do Windows; leitura completa da árvore (teclado I2C, + PS/2, Bluetooth, NVMe/SATA, composto); codificação da saída do PowerShell. +5. Tarefa agendada: executar sem sessão e com o teclado bloqueado, depois de reboot, `Register-ScheduledTask` com `S-1-5-18`/`ServiceAccount`, a tarefa se + remover enquanto roda, `Get-ScheduledTask`/`Get-ScheduledTaskInfo` (campos, `NextRunTime`) lidos por conta não administradora, comportamento se a máquina + desligar antes do prazo. +6. ACL da pasta protegida: `Set-Acl` com dono Administradores, o SDDL exato que o Windows devolve (`O:BAG:SYD:PAI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)` é o esperado), + criação prévia da pasta por usuário comum. +7. Saída de `reg query /s` e `reg export` (formato, tipos, nomes de valor com espaços, `(Default)`), por idioma. +8. O `usb reverter` como SYSTEM sem sessão (sem a pergunta de administrador), as novas tentativas do Agendador e o `icacls /reset` dos filhos da pasta protegida. +9. WinRE e Modo Seguro: comandos do roteiro de recuperação. +10. Estabilidade do ID de instância (decisão 6: hoje só ID de hardware). + +## Testes + +`internal/usb` (fixtures SINTÉTICAS: `VID_FFFF`/`PID_0001`, nomes inventados; nenhum ID real): árvore e prova (teclado I2C, PS/2, Bluetooth, NVMe, SATA, hub +raiz, composto, árvore incompleta, ciclo), teclado/mouse desmarcado, ordem do aplicar (falha em cada passo = zero chaves), snapshot restaurado exatamente, +outras origens preservadas, snapshot corrompido/ausente, Home, sem administrador, prazo, confirmar, e o **contrato dos comandos** sobre um Windows simulado +(HKLM só em `Restrictions`, tarefa só a do toolkit, nenhum `Elevate`, scripts ASCII). `internal/cli` (comandos, revalidação depois do `[s/N]`, backend da TUI) e +`internal/tui` (estados, plano por ID, goldens 80x24, 120x40 e 60x16). diff --git a/internal/cli/list.go b/internal/cli/list.go index 4729eff..82e7c75 100644 --- a/internal/cli/list.go +++ b/internal/cli/list.go @@ -62,6 +62,8 @@ type Deps struct { Otim OtimDeps // Priv são os pontos injetáveis do `toolkit privacidade` (zero = o Windows real e o backup na pasta de estado). Priv PrivDeps + // Usb são os pontos injetáveis do `toolkit usb` (zero = o Windows real e o backup em C:\ProgramData\toolkit). + Usb UsbDeps // AppsNat são os pontos injetáveis do `toolkit apps-nativos` (zero = o Windows real e o backup por SID na pasta de estado). AppsNat AppsNatDeps // GitHubToken devolve o token da API de releases do GitHub (nil = variável GITHUB_TOKEN). Só vai ao api.github.com. diff --git a/internal/cli/root.go b/internal/cli/root.go index 7d24314..982714a 100644 --- a/internal/cli/root.go +++ b/internal/cli/root.go @@ -46,7 +46,7 @@ func newRoot(out, errOut io.Writer, deps Deps) (*cobra.Command, *updateNotifier) } root.SetOut(out) root.SetErr(errOut) - root.AddCommand(newVersionCmd(), newListCmd(deps), newInstallCmd(deps), newUpdateCmd(deps), newTUICmd(deps, RecipeDeps{}, notifier), newDiagnosticoCmd(deps), newRedeCmd(deps), newPrivacidadeCmd(deps), newAppsNativosCmd(deps), newOtimizacaoCmd(deps)) + root.AddCommand(newVersionCmd(), newListCmd(deps), newInstallCmd(deps), newUpdateCmd(deps), newTUICmd(deps, RecipeDeps{}, notifier), newDiagnosticoCmd(deps), newRedeCmd(deps), newPrivacidadeCmd(deps), newUsbCmd(deps), newAppsNativosCmd(deps), newOtimizacaoCmd(deps)) root.AddCommand(newRecipeCmds(deps)...) return root, notifier } diff --git a/internal/cli/tui.go b/internal/cli/tui.go index 45b90bf..4430fb2 100644 --- a/internal/cli/tui.go +++ b/internal/cli/tui.go @@ -202,6 +202,7 @@ func tuiAreas(ctx context.Context, deps Deps, rd RecipeDeps, th tui.Theme, admin }}, {Key: "seguranca", Title: msg.TUIAreaSeguranca, Short: msg.TUIAreaSegurancaShort, Tabs: []tui.Tab{ newPrivacyTab(ctx, deps, th), + newUsbTab(ctx, deps, th), }}, {Key: "rede", Title: msg.TUIAreaRede, Short: msg.TUIAreaRedeShort, Tabs: []tui.Tab{ newRedeTab(ctx, deps, th), diff --git a/internal/cli/tui_inicio.go b/internal/cli/tui_inicio.go index d554a47..77553a3 100644 --- a/internal/cli/tui_inicio.go +++ b/internal/cli/tui_inicio.go @@ -23,6 +23,7 @@ func newInicioTab(areas []tui.AreaDef, goos string, admin bool, th tui.Theme) tu {msg.TUIInicioNativos, msg.TUIInicioNativosDesc, "maquina", "Apps nativos"}, {msg.TUIInicioOtimizacao, msg.TUIInicioOtimizacaoDesc, "maquina", msg.TUISecaoOtimizacao}, {msg.TUIInicioPrivacidade, msg.TUIInicioPrivDesc, "seguranca", "Privacidade"}, + {msg.TUIInicioUSB, msg.TUIInicioUSBDesc, "seguranca", msg.TUISecaoUSB}, {msg.TUIInicioRede, msg.TUIInicioRedeDesc, "rede", msg.TUISecaoAnalise}, {msg.TUIInicioHistorico, msg.TUIInicioHistoricoDesc, "historico", msg.TUISecaoExecucoes}, } @@ -53,6 +54,14 @@ func inicioTag(section, goos string, admin bool) string { if goos != "windows" { return msg.TUIInicioTagSoWindows } + case msg.TUISecaoUSB: + if goos != "windows" { + return msg.TUIInicioTagSoWindows + } + if admin { + return msg.TUIInicioTagExperimental + } + return msg.TUIInicioTagUSB case "Privacidade": switch { case goos != "windows": diff --git a/internal/cli/tui_inicio_test.go b/internal/cli/tui_inicio_test.go index 7b0b302..fa734d3 100644 --- a/internal/cli/tui_inicio_test.go +++ b/internal/cli/tui_inicio_test.go @@ -43,7 +43,7 @@ func inicioDe(t *testing.T, goos string, admin bool) (*tui.InicioTab, []tui.Area func TestInicioRealApontaParaAsSecoesCertas(t *testing.T) { ini, areas := inicioDe(t, "linux", false) items := ini.Items() - want := []string{"Apps", "Receitas", "Diagnóstico", "Apps nativos", "Otimização", "Privacidade", "Análise", "Execuções"} + want := []string{"Apps", "Receitas", "Diagnóstico", "Apps nativos", "Otimização", "Privacidade", "USB permitidos (experimental)", "Análise", "Execuções"} if len(items) != len(want) { t.Fatalf("%d objetivos, queria %d", len(items), len(want)) } @@ -59,7 +59,7 @@ func TestInicioRealApontaParaAsSecoesCertas(t *testing.T) { } } // a ordem do pedido: Apps e Receitas na área 1, Diagnóstico, Apps nativos e Otimização na 2, Privacidade 3, Análise 4, Execuções 5 - for i, a := range []int{1, 1, 2, 2, 2, 3, 4, 5} { + for i, a := range []int{1, 1, 2, 2, 2, 3, 3, 4, 5} { if items[i].Area != a { t.Errorf("item %d: área %d, queria %d", i, items[i].Area, a) } @@ -70,7 +70,7 @@ func TestInicioRealApontaParaAsSecoesCertas(t *testing.T) { t.Errorf("item %d (%q): Unavailable=%v tag=%q", i, it.Title, it.Unavailable, it.Tag) } } - if r := items[6]; r.Title != "Analisar a rede" || r.Area != 4 || r.Section != 0 || r.Dest != "4 Rede › Análise" { + if r := items[7]; r.Title != "Analisar a rede" || r.Area != 4 || r.Section != 0 || r.Dest != "4 Rede › Análise" { t.Errorf("Analisar a rede: %+v", r) } if items[0].Title != "Instalar programas" || items[1].Title != "Preparar a máquina com uma receita" || items[2].Title != "Ver a saúde da máquina" { @@ -88,16 +88,16 @@ func TestInicioRealEtiquetasPorSOEAdmin(t *testing.T) { return out } join := func(s []string) string { return strings.Join(s, "|") } - if got, want := join(tags("linux", true)), "|||! só Windows|! só Windows|! só Windows||"; got != want { + if got, want := join(tags("linux", true)), "|||! só Windows|! só Windows|! só Windows|! só Windows||"; got != want { t.Errorf("linux: %q", got) } - if got, want := join(tags("darwin", false)), "|||! só Windows|! só Windows|! só Windows||"; got != want { + if got, want := join(tags("darwin", false)), "|||! só Windows|! só Windows|! só Windows|! só Windows||"; got != want { t.Errorf("macOS: %q", got) } - if got, want := join(tags("windows", false)), "|||||! pede administrador para alguns itens||"; got != want { + if got, want := join(tags("windows", false)), "|||||! pede administrador para alguns itens|! experimental · pede administrador||"; got != want { t.Errorf("Windows sem admin: %q", got) } - if got, want := join(tags("windows", true)), "|||||||"; got != want { + if got, want := join(tags("windows", true)), "||||||! experimental||"; got != want { t.Errorf("Windows admin: %q", got) } } diff --git a/internal/cli/tui_test.go b/internal/cli/tui_test.go index f201e29..d664d7e 100644 --- a/internal/cli/tui_test.go +++ b/internal/cli/tui_test.go @@ -88,7 +88,7 @@ func TestRootWithoutArgsOpensTUIOnlyWithTerminal(t *testing.T) { if strings.Join(titles, ",") != "Início,Instalar,Máquina,Segurança,Rede,Histórico" { t.Fatalf("áreas: %v", titles) } - if strings.Join(secs, ",") != "Início,Apps+Receitas,Diagnóstico+Apps nativos+Otimização,Privacidade,Análise,Execuções" { + if strings.Join(secs, ",") != "Início,Apps+Receitas,Diagnóstico+Apps nativos+Otimização,Privacidade+USB permitidos (experimental),Análise,Execuções" { t.Fatalf("seções: %v", secs) } for _, a := range areas { diff --git a/internal/cli/tui_usb.go b/internal/cli/tui_usb.go new file mode 100644 index 0000000..696d98d --- /dev/null +++ b/internal/cli/tui_usb.go @@ -0,0 +1,274 @@ +package cli + +import ( + "context" + "errors" + "fmt" + "reflect" + "strconv" + "strings" + "sync" + + "github.com/PiluTech/toolkit/internal/textsafe" + "github.com/PiluTech/toolkit/internal/tui" + "github.com/PiluTech/toolkit/internal/usb" +) + +// newUsbTab monta a seção "USB permitidos (experimental)" da TUI sobre o mesmo núcleo do `toolkit usb` (mesmo System, mesmo +// Store, mesmas regras: prova antes, backup antes, tarefa de reversão conferida antes da primeira chave, nunca eleva +// sozinho). Fora do Windows (deps.GOOS) a seção só avisa, sem chamar nada. +func newUsbTab(ctx context.Context, deps Deps, th tui.Theme) tui.Tab { + return tui.NewUsbTab(ctx, &usbBackend{deps: deps}, th) +} + +// usbBackend implementa tui.UsbBackend. O ambiente é montado na primeira leitura e reaproveitado. +type usbBackend struct { + deps Deps + mu sync.Mutex + env *usbEnv + // prepared guarda os planos mostrados, por ID opaco. A TUI guarda o ID do plano EXIBIDO e a confirmação chama + // Apply/Keep/Undo(ID): só esse plano é utilizável (uso único) e, ao usar um ID, todos os demais são descartados. Uma + // preparação cancelada (Esc) que termina tarde grava sob o SEU ID, que a TUI nunca usa. A ação ainda exige que o plano + // recalculado agora seja IDÊNTICO ao mostrado; senão ErrUsbStalePlan. + prepared map[string]*usbPrepared + nextID int +} + +type usbPrepared struct { + kind string // "apply", "keep" ou "undo" + text string + excluded []string + prazo int + snapshot *usb.Snapshot +} + +func (b *usbBackend) prepare(p *usbPrepared) string { + b.mu.Lock() + defer b.mu.Unlock() + if b.prepared == nil || len(b.prepared) >= maxPrepared { + b.prepared = map[string]*usbPrepared{} + } + b.nextID++ + id := "plano-usb-" + strconv.Itoa(b.nextID) + b.prepared[id] = p + return id +} + +// take devolve e CONSOME o plano com esse ID (uso único) e descarta todos os outros. +func (b *usbBackend) take(id string) *usbPrepared { + b.mu.Lock() + defer b.mu.Unlock() + p := b.prepared[id] + b.prepared = nil + return p +} + +func (b *usbBackend) getEnv(ctx context.Context) (usbEnv, error) { + b.mu.Lock() + defer b.mu.Unlock() + if b.env != nil { + return *b.env, nil + } + e, err := newUsbEnv(ctx, b.deps) + if err != nil { + return usbEnv{}, err + } + b.env = &e + return e, nil +} + +func (b *usbBackend) Load(ctx context.Context) (tui.UsbInfo, error) { + if b.deps.GOOS != "windows" { + return tui.UsbInfo{OS: printable(b.deps.GOOS)}, nil + } + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbInfo{}, err + } + plan, err := usb.BuildPlan(ctx, e.sys, nil) + if err != nil { + return tui.UsbInfo{}, cleanErr(err) + } + info := tui.UsbInfo{Supported: true, OS: "windows", Edition: plan.Edition, EditionOK: usb.EditionSupported(plan.Edition), IsAdmin: plan.IsAdmin, State: tui.UsbClean} + for _, u := range plan.Units { + info.Devices = append(info.Devices, tui.UsbDevice{Key: u.Key, Name: u.Name, VIDPID: u.VIDPID, Class: u.Class, Essential: u.Essential}) + } + st, err := usb.ReadStatus(ctx, e.sys, e.store) + if err != nil { + return tui.UsbInfo{}, cleanErr(err) + } + info.RevertNote = st.RevertNote + switch st.Kind { + case usb.StatusArmed: + info.State, info.Deadline = tui.UsbArmed, fmtDeadline(st.Task.Next) + case usb.StatusActive: + info.State = tui.UsbActive + case usb.StatusStale: + info.State = tui.UsbStale + case usb.StatusUnknown: + info.State, info.Reason = tui.UsbUnknown, st.Reason + } + return info, nil +} + +func (b *usbBackend) Plan(ctx context.Context, excluded []string) (tui.UsbPlan, error) { + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbPlan{}, err + } + plan, err := usb.BuildPlan(ctx, e.sys, excluded) + if err != nil { + return tui.UsbPlan{}, cleanErr(err) + } + text := plan.Format() + id := b.prepare(&usbPrepared{kind: "apply", text: text, excluded: excluded, prazo: plan.Prazo}) + out := tui.UsbPlan{ID: id, Text: textsafe.Multiline(text + usbExeWarningText()), OK: plan.OK(), Prazo: plan.Prazo, IsAdmin: plan.IsAdmin, Refusal: textsafe.Line(strings.Join(plan.Refusals, "; "))} + for _, u := range plan.Units { + switch { + case u.Selected: + out.Allowed++ + default: + out.Deselected++ + if u.Blocked { + out.Blocked++ + } + } + } + return out, nil +} + +func (b *usbBackend) Apply(ctx context.Context, planID string) (tui.UsbResult, error) { + prep := b.take(planID) + if prep == nil || prep.kind != "apply" { + return tui.UsbResult{}, tui.ErrUsbStalePlan + } + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbResult{}, err + } + plan, err := usb.BuildPlan(ctx, e.sys, prep.excluded) + if err != nil { + return tui.UsbResult{}, cleanErr(err) + } + if !plan.OK() || plan.Format() != prep.text { + return tui.UsbResult{}, tui.ErrUsbStalePlan // o sistema, a seleção ou a prova mudaram desde o plano mostrado + } + if !e.sys.IsAdmin(ctx) { // recusa ANTES de qualquer mudança + return tui.UsbResult{}, tui.ErrUsbNeedsAdmin + } + res, err := usb.Apply(ctx, e.sys, e.store, usb.ApplyOptions{Prazo: prep.prazo, Now: e.now(), Excluded: prep.excluded, ExpectedPlan: prep.text}) + out := tui.UsbResult{} + if res != nil { + out = tui.UsbResult{Entries: res.Entries, BackupPath: res.BackupPath, RestoredNow: res.Restored} + if !res.Deadline.IsZero() { + out.Deadline = fmtDeadline(res.Deadline) + } + } + return out, tuiUsbErr(err) +} + +func (b *usbBackend) KeepPlan(ctx context.Context) (tui.UsbPlan, error) { + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbPlan{}, err + } + st, err := usb.ReadStatus(ctx, e.sys, e.store) + if err != nil { + return tui.UsbPlan{}, cleanErr(err) + } + if st.Kind != usb.StatusArmed { + return tui.UsbPlan{Text: "Não há reversão automática pendente.", Refusal: "não há reversão pendente para confirmar"}, nil + } + text := keepText(st) + id := b.prepare(&usbPrepared{kind: "keep", text: text, snapshot: st.Snapshot}) + return tui.UsbPlan{ID: id, Text: textsafe.Multiline(text), OK: true, IsAdmin: e.sys.IsAdmin(ctx)}, nil +} + +func keepText(st *usb.Status) string { + return fmt.Sprintf("Manter o modo empresa de USB (EXPERIMENTAL)\n\nA tarefa de reversão \"%s%s\" (próximo disparo às %s) será removida: a política continua aplicada e o snapshot continua em %s para o desfazer.\n\n%s\n", usb.TaskPath, usb.TaskName, fmtDeadline(st.Task.Next), usb.ProtectedDir, usb.TextLimit) +} + +func (b *usbBackend) Keep(ctx context.Context, planID string) (tui.UsbResult, error) { + prep := b.take(planID) + if prep == nil || prep.kind != "keep" { + return tui.UsbResult{}, tui.ErrUsbStalePlan + } + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbResult{}, err + } + st, err := usb.ReadStatus(ctx, e.sys, e.store) + if err != nil { + return tui.UsbResult{}, cleanErr(err) + } + if st.Kind != usb.StatusArmed || keepText(st) != prep.text || !reflect.DeepEqual(st.Snapshot, prep.snapshot) { + return tui.UsbResult{}, tui.ErrUsbStalePlan + } + if !e.sys.IsAdmin(ctx) { + return tui.UsbResult{}, tui.ErrUsbNeedsAdmin + } + return tui.UsbResult{}, tuiUsbErr(usb.Confirm(ctx, e.sys, e.store)) +} + +func (b *usbBackend) UndoPlan(ctx context.Context) (tui.UsbPlan, error) { + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbPlan{}, err + } + plan, err := usb.BuildUndo(ctx, e.sys, e.store) + if err != nil { + return tui.UsbPlan{}, cleanErr(err) + } + text := plan.Format() + id := b.prepare(&usbPrepared{kind: "undo", text: text, snapshot: plan.Status.Snapshot}) + out := tui.UsbPlan{ID: id, Text: textsafe.Multiline(text), OK: plan.Kind == usb.UndoRestore, IsAdmin: e.sys.IsAdmin(ctx)} + switch plan.Kind { + case usb.UndoNothing: + out.Refusal = "nunca houve aplicação: nada a desfazer" + case usb.UndoUnknown: + out.Refusal = "ESTADO ORIGINAL DESCONHECIDO: nada é restaurado às cegas (veja a recuperação manual acima)" + case usb.UndoConflict: + out.Refusal = textsafe.Line(plan.Reason) + } + return out, nil +} + +func (b *usbBackend) Undo(ctx context.Context, planID string) (tui.UsbResult, error) { + prep := b.take(planID) + if prep == nil || prep.kind != "undo" { + return tui.UsbResult{}, tui.ErrUsbStalePlan + } + e, err := b.getEnv(ctx) + if err != nil { + return tui.UsbResult{}, err + } + plan, err := usb.BuildUndo(ctx, e.sys, e.store) + if err != nil { + return tui.UsbResult{}, cleanErr(err) + } + if plan.Kind != usb.UndoRestore || plan.Format() != prep.text || !reflect.DeepEqual(plan.Status.Snapshot, prep.snapshot) { + return tui.UsbResult{}, tui.ErrUsbStalePlan // o backup ou o sistema mudou desde o plano mostrado + } + if !e.sys.IsAdmin(ctx) { + return tui.UsbResult{}, tui.ErrUsbNeedsAdmin + } + res, err := usb.Undo(ctx, e.sys, e.store) + out := tui.UsbResult{} + if res != nil { + out = tui.UsbResult{Restored: res.Restored, Nothing: res.Nothing} + } + return out, tuiUsbErr(err) +} + +// tuiUsbErr traduz os erros do núcleo para os que a seção entende e limpa o texto dos demais. +func tuiUsbErr(err error) error { + switch { + case err == nil: + return nil + case errors.Is(err, usb.ErrNeedsAdmin): + return tui.ErrUsbNeedsAdmin + case errors.Is(err, usb.ErrPlanChanged): + return tui.ErrUsbStalePlan + } + return cleanErr(err) +} diff --git a/internal/cli/tui_usb_test.go b/internal/cli/tui_usb_test.go new file mode 100644 index 0000000..52c3e96 --- /dev/null +++ b/internal/cli/tui_usb_test.go @@ -0,0 +1,215 @@ +package cli + +import ( + "context" + "errors" + "strings" + "testing" + + "github.com/PiluTech/toolkit/internal/tui" + "github.com/PiluTech/toolkit/internal/usb" + "github.com/PiluTech/toolkit/internal/usb/usbtest" +) + +func usbBe(t *testing.T, sys *usbtest.Sys, st *usbtest.MemStore) *usbBackend { + t.Helper() + return &usbBackend{deps: usbDeps(t, sys, st, "windows", false, "")} +} + +func TestTUIUsbForaDoWindowsSoAvisa(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "linux", false, "") + d.Usb.System = nil // qualquer comando real falharia o teste + info, err := (&usbBackend{deps: d}).Load(context.Background()) + if err != nil || info.Supported || info.OS != "linux" { + t.Fatalf("info=%#v err=%v", info, err) + } +} + +func TestTUIUsbLoadMostraDispositivosEstadoEEdicao(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + info, err := be.Load(context.Background()) + if err != nil { + t.Fatal(err) + } + if !info.Supported || !info.EditionOK || !info.IsAdmin || info.State != tui.UsbClean || len(info.Devices) != 2 { + t.Fatalf("info = %#v", info) + } + sys.EditionID = usb.EditionHome + info, _ = usbBe(t, sys, st).Load(context.Background()) + if info.EditionOK { + t.Fatal("Home não é suportado") + } + if len(sys.Log) != 0 { + t.Fatalf("Load só lê: %v", sys.Log) + } +} + +func TestTUIUsbAplicarPorIDDeUsoUnico(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + ctx := context.Background() + p, err := be.Plan(ctx, nil) + if err != nil || !p.OK || p.Allowed != 2 || p.Blocked != 0 || p.Prazo != usb.PrazoPadrao { + t.Fatalf("plano = %#v err=%v", p, err) + } + if _, err := be.Apply(ctx, "plano-que-nao-existe"); !errors.Is(err, tui.ErrUsbStalePlan) { + t.Fatalf("ID inexistente: %v", err) + } + if sys.Writes() != 0 { + t.Fatal("ID inválido não pode escrever") + } + // o ID inválido já consumiu (descartou) o plano p: ele não vale mais + if _, err := be.Apply(ctx, p.ID); !errors.Is(err, tui.ErrUsbStalePlan) { + t.Fatalf("o plano descartado não pode ser usado: %v", err) + } + p, _ = be.Plan(ctx, nil) + res, err := be.Apply(ctx, p.ID) + if err != nil || res.Entries == 0 || res.Deadline == "" { + t.Fatalf("res=%#v err=%v", res, err) + } + if _, err := be.Apply(ctx, p.ID); !errors.Is(err, tui.ErrUsbStalePlan) { + t.Fatalf("uso único: %v", err) + } +} + +func TestTUIUsbPlanoVelhoDepoisQueOSistemaMudou(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + ctx := context.Background() + p, _ := be.Plan(ctx, nil) + sys.Devs = usbtest.Devices(false) // o pendrive foi retirado depois do plano + if _, err := be.Apply(ctx, p.ID); !errors.Is(err, tui.ErrUsbStalePlan) { + t.Fatalf("err = %v", err) + } + if sys.Writes() != 0 || sys.Task.Exists { + t.Fatalf("mudou algo com o plano velho: %v", sys.Log) + } +} + +func TestTUIUsbSemAdminRecusaAntesDeMudar(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + ctx := context.Background() + p, _ := be.Plan(ctx, nil) + if p.IsAdmin != true { + t.Fatal("IsAdmin") + } + sys.Admin = false + if _, err := be.Apply(ctx, p.ID); err == nil { + t.Fatal("devia falhar") + } + sys.Admin = true + p, _ = be.Plan(ctx, nil) + sys.Admin = false + _, err := be.Apply(ctx, p.ID) + if !errors.Is(err, tui.ErrUsbStalePlan) && !errors.Is(err, tui.ErrUsbNeedsAdmin) { + t.Fatalf("err = %v", err) + } + if len(sys.Log) != 0 { + t.Fatalf("mudou algo sem administrador: %v", sys.Log) + } +} + +func TestTUIUsbTecladoDesmarcadoRecusaNoPlano(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + p, err := be.Plan(context.Background(), []string{usbtest.KeyboardKey}) + if err != nil { + t.Fatal(err) + } + if p.OK || !strings.Contains(p.Refusal, "Teclado") || p.Blocked != 1 { + t.Fatalf("plano = %#v", p) + } + if _, err := be.Apply(context.Background(), p.ID); err == nil { + t.Fatal("o plano recusado não pode ser aplicado") + } + if len(sys.Log) != 0 { + t.Fatalf("mudou algo: %v", sys.Log) + } +} + +func TestTUIUsbManterEDesfazerPorID(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + ctx := context.Background() + if p, _ := be.KeepPlan(ctx); p.OK { + t.Fatal("sem nada aplicado não há o que manter") + } + p, _ := be.Plan(ctx, nil) + if _, err := be.Apply(ctx, p.ID); err != nil { + t.Fatal(err) + } + info, _ := be.Load(ctx) + if info.State != tui.UsbArmed || info.Deadline == "" { + t.Fatalf("info = %#v", info) + } + kp, _ := be.KeepPlan(ctx) + if !kp.OK || !strings.Contains(kp.Text, "removida") { + t.Fatalf("keep plan = %#v", kp) + } + if _, err := be.Keep(ctx, kp.ID); err != nil { + t.Fatal(err) + } + if sys.Task.Exists { + t.Fatal("manter remove a tarefa") + } + info, _ = be.Load(ctx) + if info.State != tui.UsbActive { + t.Fatalf("info = %#v", info) + } + up, _ := be.UndoPlan(ctx) + if !up.OK { + t.Fatalf("undo plan = %#v", up) + } + // o snapshot some entre o plano e a confirmação: o plano é velho + _ = st.Remove() + if _, err := be.Undo(ctx, up.ID); !errors.Is(err, tui.ErrUsbStalePlan) { + t.Fatalf("err = %v", err) + } +} + +func TestTUIUsbEstadoDesconhecidoNaoViraConfirmacao(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + be := usbBe(t, sys, st) + ctx := context.Background() + p, _ := be.Plan(ctx, nil) + if _, err := be.Apply(ctx, p.ID); err != nil { + t.Fatal(err) + } + _ = st.Remove() + n := sys.Writes() + info, _ := usbBe(t, sys, st).Load(ctx) + if info.State != tui.UsbUnknown || info.Reason == "" { + t.Fatalf("info = %#v", info) + } + up, _ := usbBe(t, sys, st).UndoPlan(ctx) + if up.OK || !strings.Contains(up.Text, "ESTADO ORIGINAL DESCONHECIDO") || !strings.Contains(up.Refusal, "ESTADO ORIGINAL DESCONHECIDO") { + t.Fatalf("undo plan = %#v", up) + } + if _, err := be.Undo(ctx, up.ID); err == nil { + t.Fatal("o desfazer não pode rodar sem snapshot") + } + if sys.Writes() != n { + t.Fatal("escreveu sem snapshot") + } +} + +func TestTUIUsbAbaMontadaNaAreaSeguranca(t *testing.T) { + _, areas := inicioDe(t, "windows", true) + var found bool + for _, a := range areas { + if a.Key != "seguranca" { + continue + } + for _, tb := range a.Tabs { + if tb.Title() == "USB permitidos (experimental)" { + found = true + } + } + } + if !found { + t.Fatal("a seção USB permitidos (experimental) tem de estar na área Segurança") + } +} diff --git a/internal/cli/updatecheck.go b/internal/cli/updatecheck.go index 7b3ab13..50b6eee 100644 --- a/internal/cli/updatecheck.go +++ b/internal/cli/updatecheck.go @@ -71,6 +71,9 @@ func skipsUpdateCheck(cmd *cobra.Command) bool { if cmd.Parent() != nil && cmd.Parent().Name() == "completion" { return true } + if cmd.Name() == "reverter" && cmd.Parent() != nil && cmd.Parent().Name() == "usb" { + return true // a tarefa de reversão (SYSTEM, sem terminal) nunca consulta versão nova + } if f := cmd.Flags().Lookup("json"); f != nil && f.Value.String() == "true" { return true // --json: nem uma linha a mais, nem em stderr } diff --git a/internal/cli/usb.go b/internal/cli/usb.go new file mode 100644 index 0000000..d98d2ed --- /dev/null +++ b/internal/cli/usb.go @@ -0,0 +1,304 @@ +package cli + +import ( + "context" + "errors" + "fmt" + "io" + "os" + "reflect" + "time" + + "github.com/spf13/cobra" + + "github.com/PiluTech/toolkit/internal/msg" + "github.com/PiluTech/toolkit/internal/platform" + "github.com/PiluTech/toolkit/internal/textsafe" + "github.com/PiluTech/toolkit/internal/usb" +) + +// UsbDeps são os pontos injetáveis do `toolkit usb` e da seção USB da TUI (os testes nunca tocam o Windows real). +type UsbDeps struct { + // System é o Windows visto pelo toolkit (nil = usb.NewWindowsSystem sobre o Runner do Deps, com a elevação perguntada + // ao PowerShell). Nada é elevado: sem administrador o aplicar recusa. + System usb.System + // Store guarda o snapshot (nil = usb.FileStore na pasta protegida C:\ProgramData\toolkit). + Store usb.Store + Now func() time.Time +} + +type usbFlags struct { + prazo int + dryRun bool + yes bool +} + +func newUsbCmd(deps Deps) *cobra.Command { + c := &cobra.Command{ + Use: "usb", + Short: msg.UsbShort, + Long: msg.UsbLong, + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + return runUsbState(cmd.Context(), cmd.OutOrStdout(), deps) + }, + } + f := usbFlags{prazo: usb.PrazoPadrao} + apply := &cobra.Command{ + Use: "aplicar", + Short: msg.UsbApplyShort, + Long: msg.UsbApplyLong, + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + return runUsbApply(cmd.Context(), cmd.OutOrStdout(), deps, f) + }, + } + apply.Flags().IntVar(&f.prazo, "prazo", usb.PrazoPadrao, msg.FlagUsbPrazo) + apply.Flags().BoolVar(&f.dryRun, "dry-run", false, msg.FlagPrivDryRun) + apply.Flags().BoolVarP(&f.yes, "yes", "y", false, msg.FlagPrivYes) + + confirm := &cobra.Command{ + Use: "confirmar", + Short: msg.UsbConfirmShort, + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + return runUsbConfirm(cmd.Context(), cmd.OutOrStdout(), deps) + }, + } + + var u usbFlags + undo := &cobra.Command{ + Use: "desfazer", + Short: msg.UsbUndoShort, + Long: msg.UsbUndoLong, + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + return runUsbUndo(cmd.Context(), cmd.OutOrStdout(), deps, u) + }, + } + undo.Flags().BoolVar(&u.dryRun, "dry-run", false, msg.FlagPrivDryRun) + undo.Flags().BoolVarP(&u.yes, "yes", "y", false, msg.FlagPrivYes) + + // subcomando OCULTO executado pela tarefa de reversão (SYSTEM, sem terminal): restaura o snapshot sem perguntar. + revert := &cobra.Command{ + Use: "reverter", + Short: msg.UsbRevertShort, + Hidden: true, + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, _ []string) error { + return runUsbRevert(cmd.Context(), cmd.OutOrStdout(), deps) + }, + } + c.AddCommand(apply, confirm, undo, revert) + return c +} + +// usbEnv junta o que os modos (e a TUI) usam. Fora do Windows devolve o erro ANTES de montar qualquer coisa. +type usbEnv struct { + sys usb.System + store usb.Store + now func() time.Time +} + +func newUsbEnv(ctx context.Context, deps Deps) (usbEnv, error) { + if deps.GOOS != "windows" { + return usbEnv{}, fmt.Errorf(msg.UsbOnlyWindows, printable(deps.GOOS)) + } + e := usbEnv{now: deps.Usb.Now, sys: deps.Usb.System, store: deps.Usb.Store} + if e.now == nil { + e.now = time.Now + } + if e.sys == nil { + r := deps.runner() + e.sys = usb.NewWindowsSystem(r, func() bool { return platform.IsElevatedViaPowerShell(ctx, r) }) + } + if e.store == nil { + e.store = usb.FileStore{Dir: usb.ProtectedDir} + } + return e, nil +} + +func usbErr(err error) error { + if errors.Is(err, usb.ErrNeedsAdmin) { + return errors.New(msg.UsbNeedsAdmin) + } + if errors.Is(err, usb.ErrPlanChanged) { + return errors.New(msg.UsbStale) + } + return cleanErr(err) +} + +func fmtDeadline(t time.Time) string { return t.Local().Format("15:04") } + +func runUsbState(ctx context.Context, out io.Writer, deps Deps) error { + ctx = orBackground(ctx) + e, err := newUsbEnv(ctx, deps) + if err != nil { + return err + } + _, _ = fmt.Fprintln(out, usb.TextExperimental) + st, err := usb.ReadStatus(ctx, e.sys, e.store) + if err != nil { + return usbErr(err) + } + if st.RevertNote != "" { + _, _ = fmt.Fprintln(out, textsafe.Line(st.RevertNote)+".") + } + switch st.Kind { + case usb.StatusClean: + _, _ = fmt.Fprintln(out, msg.UsbStateClean) + case usb.StatusArmed: + _, _ = fmt.Fprintf(out, msg.UsbStateArmed+"\n", fmtDeadline(st.Task.Next)) + case usb.StatusActive: + _, _ = fmt.Fprintln(out, msg.UsbStateActive) + case usb.StatusStale: + _, _ = fmt.Fprintln(out, msg.UsbStateStale) + case usb.StatusUnknown: + _, _ = fmt.Fprintln(out, msg.UsbStateUnknown) + _, _ = fmt.Fprintln(out, textsafe.Line(st.Reason)+".") + } + _, _ = fmt.Fprintln(out, usb.TextLimit) + return nil +} + +func runUsbApply(ctx context.Context, out io.Writer, deps Deps, f usbFlags) error { + ctx = orBackground(ctx) + e, err := newUsbEnv(ctx, deps) + if err != nil { + return err + } + if f.prazo < usb.PrazoMinimo || f.prazo > usb.PrazoMaximo { + return fmt.Errorf("%w: use de %d a %d minutos", usb.ErrPrazo, usb.PrazoMinimo, usb.PrazoMaximo) + } + plan, err := usb.BuildPlan(ctx, e.sys, nil) + if err != nil { + return usbErr(err) + } + plan.Prazo = f.prazo + _, _ = fmt.Fprint(out, textsafe.Multiline(plan.Format()+usbExeWarningText())) + if !plan.OK() { + return fmt.Errorf("recusado, nada foi alterado: %w", usbErr(plan.Err())) + } + if f.dryRun { + _, _ = fmt.Fprintln(out, msg.UsbDryRunApply) + return nil + } + if !e.sys.IsAdmin(ctx) { // recusa ANTES de perguntar e antes de qualquer mudança + return errors.New(msg.UsbNeedsAdmin) + } + if ok, err := privConfirm(ctx, out, deps, f.yes, msg.UsbConfirmApply); !ok || err != nil { + return err + } + // o plano é recalculado DEPOIS da confirmação e antes de qualquer backup, tarefa ou chave: o que será gravado tem de ser + // idêntico ao que foi mostrado (vale também com --yes). + fresh, err := usb.BuildPlan(ctx, e.sys, nil) + if err != nil { + return usbErr(err) + } + fresh.Prazo = f.prazo + if fresh.Format() != plan.Format() { + return errors.New(msg.UsbStale) + } + res, err := usb.Apply(ctx, e.sys, e.store, usb.ApplyOptions{Prazo: f.prazo, Now: e.now(), ExpectedPlan: plan.Format()}) + if err != nil { + if res != nil && res.Restored { + _, _ = fmt.Fprintln(out, msg.UsbAppliedPart) + } + return usbErr(err) + } + _, _ = fmt.Fprintf(out, msg.UsbApplied+"\n", res.Entries, fmtDeadline(res.Deadline), printable(res.BackupPath)) + return nil +} + +func runUsbConfirm(ctx context.Context, out io.Writer, deps Deps) error { + ctx = orBackground(ctx) + e, err := newUsbEnv(ctx, deps) + if err != nil { + return err + } + if err := usb.Confirm(ctx, e.sys, e.store); err != nil { + return usbErr(err) + } + _, _ = fmt.Fprintln(out, msg.UsbConfirmed) + return nil +} + +func runUsbUndo(ctx context.Context, out io.Writer, deps Deps, f usbFlags) error { + ctx = orBackground(ctx) + e, err := newUsbEnv(ctx, deps) + if err != nil { + return err + } + plan, err := usb.BuildUndo(ctx, e.sys, e.store) + if err != nil { + return usbErr(err) + } + _, _ = fmt.Fprint(out, textsafe.Multiline(plan.Format())) + switch plan.Kind { + case usb.UndoNothing: + return nil + case usb.UndoUnknown, usb.UndoConflict: + if f.dryRun { + _, _ = fmt.Fprintln(out, msg.PrivDryRunDone) + return nil + } + _, err := usb.Undo(ctx, e.sys, e.store) // devolve o erro tipado sem escrever nada + return usbErr(err) + } + if f.dryRun { + _, _ = fmt.Fprintln(out, msg.PrivDryRunDone) + return nil + } + if !e.sys.IsAdmin(ctx) { + return errors.New(msg.UsbNeedsAdmin) + } + if ok, err := privConfirm(ctx, out, deps, f.yes, msg.UsbConfirmUndo); !ok || err != nil { + return err + } + // snapshot e sistema são relidos DEPOIS da confirmação e comparados ao que foi mostrado, antes de restaurar. + fresh, err := usb.BuildUndo(ctx, e.sys, e.store) + if err != nil { + return usbErr(err) + } + if fresh.Format() != plan.Format() || fresh.Kind != plan.Kind || !reflect.DeepEqual(fresh.Status.Snapshot, plan.Status.Snapshot) { + return errors.New(msg.UsbStale) + } + res, err := usb.Undo(ctx, e.sys, e.store) + if err != nil { + return usbErr(err) + } + _, _ = fmt.Fprintf(out, msg.UsbRestored+"\n", res.Restored) + return nil +} + +// runUsbRevert é o que a tarefa de reversão executa: o MESMO caminho do desfazer, sem pergunta (não há terminal). +func runUsbRevert(ctx context.Context, out io.Writer, deps Deps) error { + ctx = orBackground(ctx) + e, err := newUsbEnv(ctx, deps) + if err != nil { + return err + } + res, err := usb.Revert(ctx, e.sys, e.store) // SYSTEM, sem IsAdmin; grava o rastro na pasta protegida + if err != nil { + return usbErr(err) + } + if res.Nothing { + _, _ = fmt.Fprintln(out, msg.UsbNothingToUndo) + return nil + } + _, _ = fmt.Fprintf(out, msg.UsbRestored+"\n", res.Restored) + return nil +} + +// usbExeWarningText é o aviso (com quebra de linha na frente) de que o toolkit roda de uma pasta que usuário comum grava; +// vazio quando a pasta é de administrador. Só texto de exibição: nunca entra no plano comparado na confirmação. +func usbExeWarningText() string { + p, err := os.Executable() + if err != nil { + return "" + } + if w := usb.ExeFolderWarning(p); w != "" { + return "\n" + msg.UsbWarnPrefix + w + "\n" + } + return "" +} diff --git a/internal/cli/usb_test.go b/internal/cli/usb_test.go new file mode 100644 index 0000000..86f5a22 --- /dev/null +++ b/internal/cli/usb_test.go @@ -0,0 +1,354 @@ +package cli + +import ( + "bytes" + "context" + "errors" + "strings" + "testing" + "time" + + "github.com/PiluTech/toolkit/internal/exec" + "github.com/PiluTech/toolkit/internal/exec/exectest" + "github.com/PiluTech/toolkit/internal/usb" + "github.com/PiluTech/toolkit/internal/usb/usbtest" +) + +var usbNow = time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC) + +func usbDeps(t *testing.T, sys *usbtest.Sys, st *usbtest.MemStore, goos string, tty bool, input string) Deps { + t.Helper() + return Deps{GOOS: goos, EmbeddedYML: []byte(embedded), NewRunner: func() exec.Runner { return exectest.New(t) }, + UpdateCheck: UpdateCheckDeps{Env: func(string) string { return "" }}, + Stdin: strings.NewReader(input), Interactive: func() bool { return tty }, + Usb: UsbDeps{System: sys, Store: st, Now: func() time.Time { return usbNow }}} +} + +func runUsb(t *testing.T, deps Deps, args ...string) (string, error) { + t.Helper() + var o, e bytes.Buffer + cmd := NewRootCmdWith(&o, &e, deps) + cmd.SetArgs(append([]string{"usb", "--no-update-check"}, args...)) + err := cmd.ExecuteContext(context.Background()) + return o.String(), err +} + +func TestUsbForaDoWindowsNaoTocaEmNada(t *testing.T) { + for _, args := range [][]string{{}, {"aplicar", "--yes"}, {"aplicar", "--dry-run"}, {"confirmar"}, {"desfazer", "--yes"}, {"reverter"}} { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + // Usb.System nil + runner sem roteiro: qualquer comando real falharia o teste + d := usbDeps(t, sys, st, "linux", true, "") + d.Usb.System = nil + _, err := runUsb(t, d, args...) + if err == nil || !strings.Contains(err.Error(), "só existe no Windows") { + t.Errorf("%v: erro = %v", args, err) + } + if sys.Writes() != 0 || len(sys.Log) != 0 { + t.Errorf("%v: nada pode mudar", args) + } + } +} + +func TestUsbEstadoSoLeEMostraExperimentalELimite(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + out, err := runUsb(t, usbDeps(t, sys, st, "windows", false, "")) + if err != nil { + t.Fatal(err) + } + for _, want := range []string{"EXPERIMENTAL", "nunca aplicado", "reduz o risco, não o elimina"} { + if !strings.Contains(out, want) { + t.Errorf("faltou %q:\n%s", want, out) + } + } + if len(sys.Log) != 0 { + t.Errorf("o estado só lê: %v", sys.Log) + } +} + +func TestUsbDryRunMostraPlanoENaoMuda(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + out, err := runUsb(t, usbDeps(t, sys, st, "windows", false, ""), "aplicar", "--dry-run") + if err != nil { + t.Fatal(err) + } + for _, want := range []string{"EXPERIMENTAL", "Teclado USB", "FFFF:0001", "Pendrive USB", "Prova de dispositivos essenciais: OK", "--dry-run: nada foi alterado", "10 minuto(s)"} { + if !strings.Contains(out, want) { + t.Errorf("plano sem %q:\n%s", want, out) + } + } + if len(sys.Log) != 0 || sys.Task.Exists { + t.Errorf("--dry-run mudou algo: %v", sys.Log) + } +} + +func TestUsbDryRunSemAdminFunciona(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + sys.Admin = false + if _, err := runUsb(t, usbDeps(t, sys, st, "windows", false, ""), "aplicar", "--dry-run"); err != nil { + t.Fatalf("o plano não exige administrador: %v", err) + } +} + +func TestUsbAplicarSemAdminRecusaAntesDePerguntar(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + sys.Admin = false + out, err := runUsb(t, usbDeps(t, sys, st, "windows", true, "s\n"), "aplicar") + if err == nil || !strings.Contains(err.Error(), "administrador") || !strings.Contains(err.Error(), "nunca eleva") { + t.Fatalf("err = %v", err) + } + if strings.Contains(out, "[s/N]") || len(sys.Log) != 0 { + t.Errorf("perguntou ou mudou algo sem administrador: %q %v", out, sys.Log) + } +} + +func TestUsbAplicarSemYesESemTerminalErraAntesDeMudar(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + out, err := runUsb(t, usbDeps(t, sys, st, "windows", false, ""), "aplicar") + if err == nil || !strings.Contains(err.Error(), "--yes") { + t.Fatalf("err = %v", err) + } + if !strings.Contains(out, "Prova de dispositivos essenciais") || len(sys.Log) != 0 { + t.Errorf("o plano deve aparecer antes e nada pode mudar: %v", sys.Log) + } +} + +func TestUsbAplicarComYesAplicaComReversao(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + out, err := runUsb(t, usbDeps(t, sys, st, "windows", false, ""), "aplicar", "--yes", "--prazo", "5") + if err != nil { + t.Fatalf("err = %v\n%s", err, out) + } + want := usbNow.Add(5 * time.Minute) + if !sys.Task.Exists || !sys.Task.Next.Equal(want) { + t.Fatalf("tarefa = %#v", sys.Task) + } + for _, w := range []string{"REVERTE SOZINHO às " + want.Local().Format("15:04"), "toolkit usb confirmar", "toolkit usb desfazer", "reduz o risco, não o elimina"} { + if !strings.Contains(out, w) { + t.Errorf("saída sem %q:\n%s", w, out) + } + } + // ordem: a tarefa antes da primeira chave + arm, firstReg := -1, -1 + for i, l := range sys.Log { + if l == "task-arm" && arm < 0 { + arm = i + } + if strings.HasPrefix(l, "reg-write:") && firstReg < 0 { + firstReg = i + } + } + if arm < 0 || firstReg < 0 || arm > firstReg { + t.Fatalf("ordem: %v", sys.Log) + } +} + +func TestUsbPrazoInvalidoRecusaSemMudar(t *testing.T) { + for _, p := range []string{"1", "0", "-3", "61"} { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + _, err := runUsb(t, usbDeps(t, sys, st, "windows", false, ""), "aplicar", "--yes", "--prazo", p) + if !errors.Is(err, usb.ErrPrazo) { + t.Errorf("prazo %s: err = %v", p, err) + } + if len(sys.Log) != 0 { + t.Errorf("prazo %s mudou algo", p) + } + } +} + +func TestUsbTecladoDesmarcadoNaoExisteNoCLIMasSemProvaRecusa(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + // máquina sem disco interno: a prova não fecha, o CLI recusa e nada muda + var keep []usb.Device + for _, d := range sys.Devs { + if d.Class != "DiskDrive" || strings.HasPrefix(d.InstanceID, "USBSTOR") { + keep = append(keep, d) + } + } + sys.Devs = keep + out, err := runUsb(t, usbDeps(t, sys, st, "windows", false, ""), "aplicar", "--yes") + if err == nil || !strings.Contains(err.Error(), "nada foi alterado") { + t.Fatalf("err = %v", err) + } + if !strings.Contains(out, "RECUSADO") || len(sys.Log) != 0 { + t.Errorf("recusa sem aviso ou mudou algo: %v\n%s", sys.Log, out) + } +} + +func TestUsbRevalidaDepoisDoSN(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + reads := 0 + sys.OnRead = func() { + reads++ + if reads == 2 { // a releitura DEPOIS da confirmação: um pendrive foi retirado durante a pergunta + sys.Devs = usbtest.Devices(false) + } + } + out, err := runUsb(t, usbDeps(t, sys, st, "windows", true, "s\n"), "aplicar") + if err == nil || !strings.Contains(err.Error(), "o estado mudou desde o plano mostrado") { + t.Fatalf("err = %v\n%s", err, out) + } + if len(sys.Log) != 0 || sys.Task.Exists { + t.Fatalf("mudou algo apesar do plano velho: %v", sys.Log) + } +} + +func TestUsbConfirmarCancelaAReversao(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + out, err := runUsb(t, d, "confirmar") + if err != nil || !strings.Contains(out, "reversão automática foi cancelada") { + t.Fatalf("%v %s", err, out) + } + if sys.Task.Exists || len(sys.Tree.Entries) == 0 { + t.Fatal("a tarefa deveria sair e a política ficar") + } + if _, err := runUsb(t, d, "confirmar"); err == nil || !strings.Contains(err.Error(), "não há reversão pendente") { + t.Fatalf("segunda confirmação: %v", err) + } + if out, _ := runUsb(t, d); !strings.Contains(out, "aplicado e confirmado") { + t.Fatalf("estado: %s", out) + } +} + +func TestUsbConfirmarSemAdmin(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + sys.Admin = false + if _, err := runUsb(t, d, "confirmar"); err == nil || !strings.Contains(err.Error(), "administrador") { + t.Fatalf("err = %v", err) + } + if !sys.Task.Exists { + t.Fatal("removeu a tarefa sem administrador") + } +} + +func TestUsbDesfazer(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + out, err := runUsb(t, d, "desfazer") + if err != nil || !strings.Contains(out, "Nada a desfazer") { + t.Fatalf("nunca aplicado: %v %s", err, out) + } + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + n := sys.Writes() + out, err = runUsb(t, d, "desfazer", "--dry-run") + if err != nil || !strings.Contains(out, "O que será restaurado") || sys.Writes() != n { + t.Fatalf("dry-run: %v\n%s", err, out) + } + if _, err := runUsb(t, d, "desfazer"); err == nil || !strings.Contains(err.Error(), "--yes") { + t.Fatalf("sem yes e sem terminal: %v", err) + } + out, err = runUsb(t, d, "desfazer", "--yes") + if err != nil || !strings.Contains(out, "Restaurado") { + t.Fatalf("desfazer: %v\n%s", err, out) + } + if len(sys.Tree.Entries) != 0 || sys.Tree.KeyExists || sys.Task.Exists { + t.Fatalf("não restaurou: %v", sys.Tree) + } +} + +func TestUsbDesfazerEstadoOriginalDesconhecido(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + _ = st.Remove() // o backup sumiu depois de aplicar + n := sys.Writes() + out, err := runUsb(t, d, "desfazer", "--yes") + if err == nil || !strings.Contains(out, "ESTADO ORIGINAL DESCONHECIDO") || strings.Contains(out, "Nada a desfazer") { + t.Fatalf("err=%v\n%s", err, out) + } + if !strings.Contains(out, "WinRE") || sys.Writes() != n { + t.Fatalf("recuperação manual ausente ou escreveu: %d != %d", sys.Writes(), n) + } + // --dry-run mostra o mesmo sem erro + if out, err := runUsb(t, d, "desfazer", "--dry-run"); err != nil || !strings.Contains(out, "ESTADO ORIGINAL DESCONHECIDO") { + t.Fatalf("dry-run: %v\n%s", err, out) + } + if out, _ := runUsb(t, d); !strings.Contains(out, "ESTADO ORIGINAL DESCONHECIDO") { + t.Fatalf("o estado deve dizer o mesmo: %s", out) + } +} + +func TestUsbDesfazerRevalidaDepoisDoSN(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + // terminal com resposta "s"; o snapshot some entre o plano e a confirmação + d2 := usbDeps(t, sys, st, "windows", true, "s\n") + d2.Stdin = &swapReader{r: strings.NewReader("s\n"), onRead: func() { _ = st.Remove() }} + n := sys.Writes() + _, err := runUsb(t, d2, "desfazer") + if err == nil || sys.Writes() != n { + t.Fatalf("err=%v writes=%d->%d", err, n, sys.Writes()) + } +} + +type swapReader struct { + r *strings.Reader + onRead func() + done bool +} + +func (s *swapReader) Read(p []byte) (int, error) { + if !s.done { + s.done = true + s.onRead() + } + return s.r.Read(p) +} + +func TestUsbRevertEHidden(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + out, err := runUsb(t, d, "reverter") + if err != nil || !strings.Contains(out, "Restaurado") { + t.Fatalf("%v %s", err, out) + } + if len(sys.Tree.Entries) != 0 || sys.Task.Exists { + t.Fatal("a reversão automática não restaurou") + } + var o, e bytes.Buffer + cmd := NewRootCmdWith(&o, &e, d) + cmd.SetArgs([]string{"usb", "--help"}) + _ = cmd.ExecuteContext(context.Background()) + if strings.Contains(o.String(), "reverter") { + t.Error("o subcomando reverter é de uso interno e não deve aparecer na ajuda") + } + for _, w := range []string{"EXPERIMENTAL", "aplicar", "confirmar", "desfazer", "reduz o risco, não o elimina"} { + if !strings.Contains(o.String(), w) { + t.Errorf("ajuda sem %q", w) + } + } +} + +// A reversão automática que falha deixa rastro e `toolkit usb` o mostra (antes: um erro mudo num processo SYSTEM). +func TestUsbReverterFalhaDeixaRastroNoStatus(t *testing.T) { + sys, st := usbtest.NewSys(), &usbtest.MemStore{} + d := usbDeps(t, sys, st, "windows", false, "") + if _, err := runUsb(t, d, "aplicar", "--yes"); err != nil { + t.Fatal(err) + } + sys.Tree.Entries["AllowDenyLayered"] = usb.DWORD(0) // outra origem mudou um valor gravado: o desfazer recusa + if _, err := runUsb(t, d, "reverter"); err == nil { + t.Fatal("o reverter deveria falhar com o conflito") + } + out, err := runUsb(t, d) + if err != nil || !strings.Contains(out, "a reversão automática rodou e falhou") { + t.Fatalf("o status não mostra a falha da reversão: %v\n%s", err, out) + } +} diff --git a/internal/msg/msg.go b/internal/msg/msg.go index 6309e74..050ae1f 100644 --- a/internal/msg/msg.go +++ b/internal/msg/msg.go @@ -137,6 +137,7 @@ const ( TUIAreaHistoricoShort = "Hist" TUISecaoAnalise = "Análise" TUISecaoAnaliseShort = "Anál" + TUISecaoUSB = "USB permitidos (experimental)" TUISecaoOtimizacao = "Otimização" TUISecaoOtimizacaoShort = "Otim" TUISecaoExecucoes = "Execuções" @@ -147,24 +148,28 @@ const ( // Início da TUI: um objetivo por linha (título, uma frase didática e, quando vale, uma etiqueta de estado ou requisito). const ( - TUIInicioApps = "Instalar programas" - TUIInicioAppsDesc = "Escolha os programas do catálogo e instale todos de uma vez." - TUIInicioReceitas = "Preparar a máquina com uma receita" - TUIInicioReceitasDesc = "Uma receita faz vários passos em sequência e continua após reiniciar." - TUIInicioSaude = "Ver a saúde da máquina" - TUIInicioSaudeDesc = "Diagnóstico só de leitura: hardware, série, UUID, MAC e o que está ruim." - TUIInicioNativos = "Remover apps nativos do Windows" - TUIInicioNativosDesc = "Remove só os apps do Windows que você escolher, depois de ver o plano." - TUIInicioOtimizacao = "Deixar o Windows mais leve" - TUIInicioOtimizacaoDesc = "Lê o que pesa na máquina (CPU, memória, disco, inicialização) e diz o que fazer; e reduz as animações do usuário (experimental), com backup e desfazer." - TUIInicioPrivacidade = "Proteger a privacidade do Windows" - TUIInicioPrivDesc = "Ajustes de privacidade, um por um, com confirmação e como desfazer." - TUIInicioRede = "Analisar a rede" - TUIInicioRedeDesc = "IPs, Wi-Fi, DNS e portas da máquina." - TUIInicioHistorico = "Ver o que já rodou" - TUIInicioHistoricoDesc = "O que já rodou e o que falhou, com o registro de cada execução." - TUIInicioTagSoWindows = "! só Windows" - TUIInicioTagAdmin = "! pede administrador para alguns itens" + TUIInicioApps = "Instalar programas" + TUIInicioAppsDesc = "Escolha os programas do catálogo e instale todos de uma vez." + TUIInicioReceitas = "Preparar a máquina com uma receita" + TUIInicioReceitasDesc = "Uma receita faz vários passos em sequência e continua após reiniciar." + TUIInicioSaude = "Ver a saúde da máquina" + TUIInicioSaudeDesc = "Diagnóstico só de leitura: hardware, série, UUID, MAC e o que está ruim." + TUIInicioNativos = "Remover apps nativos do Windows" + TUIInicioNativosDesc = "Remove só os apps do Windows que você escolher, depois de ver o plano." + TUIInicioOtimizacao = "Deixar o Windows mais leve" + TUIInicioOtimizacaoDesc = "Lê o que pesa na máquina (CPU, memória, disco, inicialização) e diz o que fazer; e reduz as animações do usuário (experimental), com backup e desfazer." + TUIInicioPrivacidade = "Proteger a privacidade do Windows" + TUIInicioPrivDesc = "Ajustes de privacidade, um por um, com confirmação e como desfazer." + TUIInicioRede = "Analisar a rede" + TUIInicioRedeDesc = "IPs, Wi-Fi, DNS e portas da máquina." + TUIInicioUSB = "Permitir só os USB conhecidos (modo empresa) — experimental" + TUIInicioUSBDesc = "Só Windows. Experimental, não testado numa máquina real: libera os USB conectados hoje e bloqueia os demais, com prova dos dispositivos essenciais, reversão automática e desfazer. Reduz o risco, não o elimina." + TUIInicioHistorico = "Ver o que já rodou" + TUIInicioHistoricoDesc = "O que já rodou e o que falhou, com o registro de cada execução." + TUIInicioTagSoWindows = "! só Windows" + TUIInicioTagAdmin = "! pede administrador para alguns itens" + TUIInicioTagUSB = "! experimental · pede administrador" + TUIInicioTagExperimental = "! experimental" ) // Textos do comando diagnostico. @@ -251,6 +256,39 @@ const ( AnimUndoHeader = "O que será restaurado (valor atual -> original):" ) +// Textos de `toolkit usb` (só Windows; EXPERIMENTAL; escreve em HKLM e cria uma tarefa do sistema). +const ( + UsbShort = "Modo empresa: permitir só os USB conhecidos (EXPERIMENTAL, só Windows; mostra o estado)" + UsbLong = "EXPERIMENTAL: ainda não foi executado numa máquina real (A VERIFICAR em VM; veja docs/usb.md). Sem subcomando só LÊ e mostra o estado (nada muda e não exige administrador). `usb aplicar` mostra o plano com a PROVA de que teclado, mouse, disco e controladores continuam permitidos, e só depois do [s/N] grava a política de restrição de instalação de dispositivos, com backup protegido e reversão automática (`usb confirmar` mantém; `usb desfazer` restaura). Limite honesto: um dispositivo que clona o VID/PID de um permitido passa. Isto reduz o risco, não o elimina." + UsbApplyShort = "Mostra o plano e aplica a política de USB permitidos (EXPERIMENTAL; administrador; com reversão automática)" + UsbApplyLong = "Lê o PnP, prova que os dispositivos essenciais continuam permitidos e mostra o plano. Sem prova, RECUSA e não muda nada. Depois da confirmação [s/N] (sem terminal exige --yes): backup protegido -> tarefa de reversão criada e conferida -> política. Se você não rodar `toolkit usb confirmar` dentro do prazo, a tarefa restaura o estado anterior sozinha. Exige administrador (o toolkit nunca eleva sozinho). EXPERIMENTAL." + UsbConfirmShort = "Confirma o modo empresa e cancela a reversão automática (exige administrador)" + UsbUndoShort = "Desfaz o modo empresa de USB (restaura o snapshot; EXPERIMENTAL)" + UsbUndoLong = "Restaura EXATAMENTE o snapshot validado (preservando políticas de outras origens) e remove a tarefa de reversão. Se o snapshot sumiu ou é inválido depois de uma aplicação, diz ESTADO ORIGINAL DESCONHECIDO, não escreve nada e mostra a recuperação manual. Exige administrador." + UsbRevertShort = "Uso interno da tarefa de reversão (restaura o snapshot)" + + FlagUsbPrazo = "minutos até a reversão automática, se você não confirmar (padrão 10, mínimo 2, máximo 60)" + + UsbOnlyWindows = "o comando usb só existe no Windows (este sistema é %s); nada foi alterado" + UsbConfirmApply = "Aplicar o modo empresa de USB (EXPERIMENTAL)? Reverte sozinho se você não confirmar no prazo." + UsbConfirmUndo = "Restaurar o estado anterior do modo empresa de USB?" + UsbWarnPrefix = "! Aviso: " + UsbStale = "o estado mudou desde o plano mostrado; nada foi alterado; veja o plano de novo" + UsbNeedsAdmin = "o modo empresa de USB exige administrador: abra o terminal como administrador (botão direito, \"Executar como administrador\") e rode de novo; nada foi alterado (o toolkit nunca eleva sozinho)" + UsbApplied = "Aplicado: %d entrada(s) na política. REVERTE SOZINHO às %s se você não rodar `toolkit usb confirmar` antes. Backup protegido em %s. Para desfazer: toolkit usb desfazer. Isto reduz o risco, não o elimina." + UsbAppliedPart = "A aplicação falhou no meio e o registro foi restaurado na hora (nada ficou aplicado)." + UsbConfirmed = "Confirmado: a reversão automática foi cancelada e o modo empresa continua aplicado. Para desfazer: toolkit usb desfazer." + UsbRestored = "Restaurado: %d valor(es). A tarefa de reversão e o backup foram removidos." + UsbNothingToUndo = "Nada a desfazer: o toolkit nunca aplicou o modo empresa de USB nesta máquina." + UsbDryRunApply = "--dry-run: nada foi alterado." + + UsbStateClean = "Estado: nunca aplicado nesta máquina." + UsbStateArmed = "Estado: APLICADO, aguardando confirmação. Reverte sozinho às %s (próximo disparo da tarefa) se você não rodar `toolkit usb confirmar`." + UsbStateActive = "Estado: aplicado e confirmado. `toolkit usb desfazer` restaura." + UsbStateStale = "Estado: há um backup de uma aplicação que não chegou ao fim; `toolkit usb desfazer` limpa." + UsbStateUnknown = "Estado: ESTADO ORIGINAL DESCONHECIDO. Rode `toolkit usb desfazer --dry-run` para ver a recuperação manual." +) + // Textos do comando privacidade (só Windows). const ( PrivShort = "Reduz a coleta de dados do Windows (mostra o plano antes, guarda backup e desfaz)" diff --git a/internal/tui/keys.go b/internal/tui/keys.go index 4a915a8..570ca5c 100644 --- a/internal/tui/keys.go +++ b/internal/tui/keys.go @@ -94,6 +94,7 @@ var actionKeys = []KeyDef{ {Key: "f", Label: "seguir o fim", Help: "liga e desliga o seguir o fim do log."}, {Key: "o", Label: "IP público", Confirms: true, Help: "consulta o IP público num serviço que você configurou, depois da confirmação."}, {Key: "w", Label: "portal cativo", Confirms: true, Help: "sonda o portal cativo num endereço que você configurou, depois da confirmação."}, + {Key: "n", Label: "manter", Confirms: true, Help: "mantém o que foi aplicado e cancela a reversão automática, depois da confirmação."}, {Key: "u", Label: "versão nova", Help: "abre as notas da versão nova (quando há)."}, } diff --git a/internal/tui/keys_test.go b/internal/tui/keys_test.go index f87f14b..6447adc 100644 --- a/internal/tui/keys_test.go +++ b/internal/tui/keys_test.go @@ -89,7 +89,7 @@ func TestLegendaSemTeclasDuplicadas(t *testing.T) { } // só as ações que abrem confirmação levam reticências for _, k := range actionKeys { - wantConf := k.Key == "a" || k.Key == "d" || k.Key == "r" || k.Key == "o" || k.Key == "w" // o e w: consultas à internet, sob confirmação + wantConf := k.Key == "a" || k.Key == "d" || k.Key == "r" || k.Key == "n" || k.Key == "o" || k.Key == "w" // o e w: consultas à internet, sob confirmação if k.Confirms != wantConf { t.Errorf("%s: Confirms=%v", k.Key, k.Confirms) } diff --git a/internal/tui/stateview.go b/internal/tui/stateview.go index 30bc710..2c5221a 100644 --- a/internal/tui/stateview.go +++ b/internal/tui/stateview.go @@ -125,6 +125,21 @@ func StateUnsupported(th Theme, w, h int, what, reason string, osName string) [] return b.render(w, h) } +// StateUnsupportedEdition é "a edição X do Windows não é suportada por esta função": o sistema é o Windows, mas a edição não +// consta na documentação da política. reason diz por quê. Leva "Nada foi alterado.". +func StateUnsupportedEdition(th Theme, w, h int, what, edition, reason string) []string { + ed := safe(edition) + if ed == "" { + ed = "desconhecida" + } + lead := upperFirst(safeWhat(what, "Isto")) + ": a edição " + ed + " do Windows não é suportada." + b := stateBlock{title: th.Title().Render(titleUnsupported), lead: []string{lead}, tail: NothingChanged} + if r := safe(reason); r != "" { + b.detail = []string{r} + } + return b.render(w, h) +} + // StateEmpty é "nada por aqui": what é a frase inteira (ex.: "Nenhuma receita para este sistema.") e os passos dizem // o que fazer para ter conteúdo. Não é erro, então não leva "Nada foi alterado.". func StateEmpty(th Theme, w, h int, what string, steps ...string) []string { diff --git a/internal/tui/testdata/usb_armado_120x40.golden b/internal/tui/testdata/usb_armado_120x40.golden new file mode 100644 index 0000000..6a50ace --- /dev/null +++ b/internal/tui/testdata/usb_armado_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa. + edição pro · administrador: sim + ! Aplicado, aguardando confirmação. REVERTE SOZINHO às 12:10. n mantém (cancela a reversão); d desfaz agora. +─ USB conectados agora ───────────────────────────────────────────────────────────────────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro HID) -> conectado + Pendrive USB FFFF:0003 classe USB -> conectado + + A prova de que teclado, mouse, disco e controladores continuam permitidos aparece no plano (tecla p ou a). Sem prova, o + toolkit recusa e não muda nada. + + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + n manter… d desfazer… p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_armado_60x16.golden b/internal/tui/testdata/usb_armado_60x16.golden new file mode 100644 index 0000000..7c19a43 --- /dev/null +++ b/internal/tui/testdata/usb_armado_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a + verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o + elimina: um dispositivo que clona o VID/PID de um + permitido passa. + edição pro · administrador: sim + ! Aplicado, aguardando confirmação. REVERTE SOZINHO às + 12:10. n mantém (cancela a reversão); d desfaz agora. +─ USB conectados agora ───────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial +─────────────────────────────────────────── ↓ mais 6 linhas + USB permitidos (experimental) — nada muda antes de confir… + n manter… d desfazer… p ver plano ? ajuda q sair diff --git a/internal/tui/testdata/usb_armado_80x24.golden b/internal/tui/testdata/usb_armado_80x24.golden new file mode 100644 index 0000000..fd89955 --- /dev/null +++ b/internal/tui/testdata/usb_armado_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). + Nada se aplica por padrão e nada muda antes de você confirmar. Isto reduz o + risco, não o elimina: um dispositivo que clona o VID/PID de um permitido + passa. + edição pro · administrador: sim + ! Aplicado, aguardando confirmação. REVERTE SOZINHO às 12:10. n mantém (cancela + a reversão); d desfaz agora. +─ USB conectados agora ───────────────────────────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro + HID) -> conectado + Pendrive USB FFFF:0003 classe USB -> conectado + + A prova de que teclado, mouse, disco e controladores continuam permitidos + aparece no plano (tecla p ou a). Sem prova, o toolkit recusa e não muda nada. + + + + +──────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + n manter… d desfazer… p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_confirma_120x40.golden b/internal/tui/testdata/usb_confirma_120x40.golden new file mode 100644 index 0000000..bc02a9c --- /dev/null +++ b/internal/tui/testdata/usb_confirma_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + PERMITIR SÓ OS USB CONHECIDOS? (EXPERIMENTAL) + Libera 1 dispositivo(s) USB conectado(s) agora; 1 desmarcado(s) ficam fora da lista (a política bloquearia 1 ao + reconectar). Reverte SOZINHO em 10 minuto(s) se você não manter (tecla n). + ! aviso: EXPERIMENTAL, não testado numa máquina real. RISCO: se algo der errado o teclado pode travar; tenha um segundo + teclado ou mouse de reserva já permitido. Reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um + permitido passa. + Backup: snapshot protegido em C:\ProgramData\toolkit (só SYSTEM e Administradores), relido e conferido; a tarefa de + reversão é criada e conferida ANTES da primeira chave. Falha em qualquer passo = nenhuma alteração. + Como desfazer: n mantém (cancela a reversão); sem ação, volta sozinho em 10 min; d desfaz. Recuperação manual (WinRE, + outra conta de administrador) abaixo. + + Modo empresa: permitir só os USB conhecidos (Windows) [EXPERIMENTAL] + + Dispositivos USB conectados agora: + [x] Teclado USB FFFF:0001 classe USB conectado agora · essencial -> permitido + [ ] Pendrive USB FFFF:0003 classe USB conectado agora -> BLOQUEADO ao reconectar (desmarcado) + + Prova de dispositivos essenciais: OK (nenhum fica bloqueado, nem os pais deles) + OK Teclado PS/2 padrão (Keyboard, PS/2): nenhuma regra o nega + OK Disco NVMe (DiskDrive, SCSI): nenhuma regra o nega + + Reversão automática em 10 minuto(s): se você não confirmar (toolkit usb confirmar), a tarefa restaura o snapshot + sozinha. + + Se o teclado travar mesmo assim: (1) espere o prazo; (2) use outro teclado; (3) outra conta de administrador restaura o + .reg; (5) WinRE (comandos A VERIFICAR em VM). + + >[ Cancelar ]< [ Aplicar ] + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + Confirmação aberta: nada muda até você confirmar. + Tab botão Enter ativa s confirma Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_confirma_60x16.golden b/internal/tui/testdata/usb_confirma_60x16.golden new file mode 100644 index 0000000..9299c75 --- /dev/null +++ b/internal/tui/testdata/usb_confirma_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + PERMITIR SÓ OS USB CONHECIDOS? (EXPERIMENTAL) + Libera 1 dispositivo(s) USB conectado(s) agora; 1 + desmarcado(s) ficam fora da lista (a política bloquearia + 1 ao reconectar). Reverte SOZINHO em 10 minuto(s) se você + não manter (tecla n). + ! aviso: EXPERIMENTAL, não testado numa máquina real. + RISCO: se algo der errado o teclado pode travar; tenha um + segundo teclado ou mouse de reserva já permitido. Reduz o + risco, não o elimina: um dispositivo que clona o VID/PID + ↓ mais 31 linhas + >[ Cancelar ]< [ Aplicar ] +──────────────────────────────────────────────────────────── + Confirmação aberta: nada muda até você confirmar. + Tab botão Enter ativa s confirma ? ajuda q sair diff --git a/internal/tui/testdata/usb_confirma_80x24.golden b/internal/tui/testdata/usb_confirma_80x24.golden new file mode 100644 index 0000000..69d0a24 --- /dev/null +++ b/internal/tui/testdata/usb_confirma_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + PERMITIR SÓ OS USB CONHECIDOS? (EXPERIMENTAL) + Libera 1 dispositivo(s) USB conectado(s) agora; 1 desmarcado(s) ficam fora da + lista (a política bloquearia 1 ao reconectar). Reverte SOZINHO em 10 + minuto(s) se você não manter (tecla n). + ! aviso: EXPERIMENTAL, não testado numa máquina real. RISCO: se algo der errado + o teclado pode travar; tenha um segundo teclado ou mouse de reserva já + permitido. Reduz o risco, não o elimina: um dispositivo que clona o VID/PID + de um permitido passa. + Backup: snapshot protegido em C:\ProgramData\toolkit (só SYSTEM e + Administradores), relido e conferido; a tarefa de reversão é criada e + conferida ANTES da primeira chave. Falha em qualquer passo = nenhuma + alteração. + Como desfazer: n mantém (cancela a reversão); sem ação, volta sozinho em 10 + min; d desfaz. Recuperação manual (WinRE, outra conta de administrador) + abaixo. + + Modo empresa: permitir só os USB conhecidos (Windows) [EXPERIMENTAL] + ↓ mais 16 linhas + >[ Cancelar ]< [ Aplicar ] +──────────────────────────────────────────────────────────────────────────────── + Confirmação aberta: nada muda até você confirmar. + Tab botão Enter ativa s confirma Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_confirma_semadmin_120x40.golden b/internal/tui/testdata/usb_confirma_semadmin_120x40.golden new file mode 100644 index 0000000..22fe04a --- /dev/null +++ b/internal/tui/testdata/usb_confirma_semadmin_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + PERMITIR SÓ OS USB CONHECIDOS? (EXPERIMENTAL) + Libera 1 dispositivo(s) USB conectado(s) agora; 1 desmarcado(s) ficam fora da lista (a política bloquearia 1 ao + reconectar). Reverte SOZINHO em 10 minuto(s) se você não manter (tecla n). + ! aviso: Sem administrador: nada será alterado. Cancele, abra o terminal como administrador (botão direito, "Executar + como administrador") e tente de novo. O toolkit nunca eleva sozinho. EXPERIMENTAL, não testado numa máquina real. + RISCO: se algo der errado o teclado pode travar; tenha um segundo teclado ou mouse de reserva já permitido. Reduz o + risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa. + Backup: snapshot protegido em C:\ProgramData\toolkit (só SYSTEM e Administradores), relido e conferido; a tarefa de + reversão é criada e conferida ANTES da primeira chave. Falha em qualquer passo = nenhuma alteração. + Como desfazer: n mantém (cancela a reversão); sem ação, volta sozinho em 10 min; d desfaz. Recuperação manual (WinRE, + outra conta de administrador) abaixo. + + Modo empresa: permitir só os USB conhecidos (Windows) [EXPERIMENTAL] + + Dispositivos USB conectados agora: + [x] Teclado USB FFFF:0001 classe USB conectado agora · essencial -> permitido + [ ] Pendrive USB FFFF:0003 classe USB conectado agora -> BLOQUEADO ao reconectar (desmarcado) + + Prova de dispositivos essenciais: OK (nenhum fica bloqueado, nem os pais deles) + OK Teclado PS/2 padrão (Keyboard, PS/2): nenhuma regra o nega + OK Disco NVMe (DiskDrive, SCSI): nenhuma regra o nega + + Reversão automática em 10 minuto(s): se você não confirmar (toolkit usb confirmar), a tarefa restaura o snapshot + sozinha. + + Se o teclado travar mesmo assim: (1) espere o prazo; (2) use outro teclado; (3) outra conta de administrador restaura o + .reg; (5) WinRE (comandos A VERIFICAR em VM). + + >[ Cancelar ]< ( Aplicar: sem administrador ) + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + Confirmação aberta: não dá para confirmar agora, só cancelar. + Enter cancela Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_confirma_semadmin_60x16.golden b/internal/tui/testdata/usb_confirma_semadmin_60x16.golden new file mode 100644 index 0000000..48718fc --- /dev/null +++ b/internal/tui/testdata/usb_confirma_semadmin_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + PERMITIR SÓ OS USB CONHECIDOS? (EXPERIMENTAL) + Libera 1 dispositivo(s) USB conectado(s) agora; 1 + desmarcado(s) ficam fora da lista (a política bloquearia + 1 ao reconectar). Reverte SOZINHO em 10 minuto(s) se você + não manter (tecla n). + ! aviso: Sem administrador: nada será alterado. Cancele, + abra o terminal como administrador (botão direito, + "Executar como administrador") e tente de novo. O toolkit + nunca eleva sozinho. EXPERIMENTAL, não testado numa + ↓ mais 34 linhas + >[ Cancelar ]< ( Aplicar: sem administrador ) +──────────────────────────────────────────────────────────── + Confirmação aberta: não dá para confirmar agora, só cance… + Enter cancela Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_confirma_semadmin_80x24.golden b/internal/tui/testdata/usb_confirma_semadmin_80x24.golden new file mode 100644 index 0000000..179341b --- /dev/null +++ b/internal/tui/testdata/usb_confirma_semadmin_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + PERMITIR SÓ OS USB CONHECIDOS? (EXPERIMENTAL) + Libera 1 dispositivo(s) USB conectado(s) agora; 1 desmarcado(s) ficam fora da + lista (a política bloquearia 1 ao reconectar). Reverte SOZINHO em 10 + minuto(s) se você não manter (tecla n). + ! aviso: Sem administrador: nada será alterado. Cancele, abra o terminal como + administrador (botão direito, "Executar como administrador") e tente de novo. + O toolkit nunca eleva sozinho. EXPERIMENTAL, não testado numa máquina real. + RISCO: se algo der errado o teclado pode travar; tenha um segundo teclado ou + mouse de reserva já permitido. Reduz o risco, não o elimina: um dispositivo + que clona o VID/PID de um permitido passa. + Backup: snapshot protegido em C:\ProgramData\toolkit (só SYSTEM e + Administradores), relido e conferido; a tarefa de reversão é criada e + conferida ANTES da primeira chave. Falha em qualquer passo = nenhuma + alteração. + Como desfazer: n mantém (cancela a reversão); sem ação, volta sozinho em 10 + min; d desfaz. Recuperação manual (WinRE, outra conta de administrador) + abaixo. + ↓ mais 18 linhas + >[ Cancelar ]< ( Aplicar: sem administrador ) +──────────────────────────────────────────────────────────────────────────────── + Confirmação aberta: não dá para confirmar agora, só cancelar. + Enter cancela Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_desconhecido_120x40.golden b/internal/tui/testdata/usb_desconhecido_120x40.golden new file mode 100644 index 0000000..262ad72 --- /dev/null +++ b/internal/tui/testdata/usb_desconhecido_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa. + edição pro · administrador: sim + ! ESTADO ORIGINAL DESCONHECIDO. o backup não existe, mas há sinais de aplicação. O toolkit não restaura nada às cegas; + p mostra a recuperação manual. +─ USB conectados agora ───────────────────────────────────────────────────────────────────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro HID) -> conectado + Pendrive USB FFFF:0003 classe USB -> conectado + + A prova de que teclado, mouse, disco e controladores continuam permitidos aparece no plano (tecla p ou a). Sem prova, o + toolkit recusa e não muda nada. + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_desconhecido_60x16.golden b/internal/tui/testdata/usb_desconhecido_60x16.golden new file mode 100644 index 0000000..6e5f960 --- /dev/null +++ b/internal/tui/testdata/usb_desconhecido_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a + verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o + elimina: um dispositivo que clona o VID/PID de um + permitido passa. + edição pro · administrador: sim + ! ESTADO ORIGINAL DESCONHECIDO. o backup não existe, mas há + sinais de aplicação. O toolkit não restaura nada às + cegas; p mostra a recuperação manual. +─ USB conectados agora ───────────────────────────────────── +─────────────────────────────────────────── ↓ mais 7 linhas + USB permitidos (experimental) — nada muda antes de confir… + p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_desconhecido_80x24.golden b/internal/tui/testdata/usb_desconhecido_80x24.golden new file mode 100644 index 0000000..1a580e2 --- /dev/null +++ b/internal/tui/testdata/usb_desconhecido_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). + Nada se aplica por padrão e nada muda antes de você confirmar. Isto reduz o + risco, não o elimina: um dispositivo que clona o VID/PID de um permitido + passa. + edição pro · administrador: sim + ! ESTADO ORIGINAL DESCONHECIDO. o backup não existe, mas há sinais de + aplicação. O toolkit não restaura nada às cegas; p mostra a recuperação + manual. +─ USB conectados agora ───────────────────────────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro + HID) -> conectado + Pendrive USB FFFF:0003 classe USB -> conectado + + A prova de que teclado, mouse, disco e controladores continuam permitidos + aparece no plano (tecla p ou a). Sem prova, o toolkit recusa e não muda nada. + + + +──────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_faixa_aplicado_120x40.golden b/internal/tui/testdata/usb_faixa_aplicado_120x40.golden new file mode 100644 index 0000000..d2a7d66 --- /dev/null +++ b/internal/tui/testdata/usb_faixa_aplicado_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + ! pendente Aplicado, aguardando confirmação [x] fechar + 8 entrada(s) na política + REVERTE SOZINHO às 12:10 se você não manter (tecla n) + Backup protegido em C:\ProgramData\toolkit + Teste o teclado e o mouse agora. Para desfazer: tecla d +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa. + edição pro · administrador: sim + ! Aplicado, aguardando confirmação. REVERTE SOZINHO às 12:10. n mantém (cancela a reversão); d desfaz agora. +─ USB conectados agora ───────────────────────────────────────────────────────────────────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro HID) -> conectado + Pendrive USB FFFF:0003 classe USB -> conectado + + A prova de que teclado, mouse, disco e controladores continuam permitidos aparece no plano (tecla p ou a). Sem prova, o + toolkit recusa e não muda nada. + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + Aplicado: aguardando a sua confirmação. + n manter… d desfazer… p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_faixa_aplicado_60x16.golden b/internal/tui/testdata/usb_faixa_aplicado_60x16.golden new file mode 100644 index 0000000..504526b --- /dev/null +++ b/internal/tui/testdata/usb_faixa_aplicado_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + ! Aplicado, aguardando confirmação [x] fechar + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a + verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o + elimina: um dispositivo que clona o VID/PID de um + permitido passa. + edição pro · administrador: sim + ! Aplicado, aguardando confirmação. REVERTE SOZINHO às + 12:10. n mantém (cancela a reversão); d desfaz agora. +─ USB conectados agora ───────────────────────────────────── +─────────────────────────────────────────── ↓ mais 7 linhas + Aplicado: aguardando a sua confirmação. + n manter… d desfazer… p ver plano ? ajuda q sair diff --git a/internal/tui/testdata/usb_faixa_aplicado_80x24.golden b/internal/tui/testdata/usb_faixa_aplicado_80x24.golden new file mode 100644 index 0000000..9b3c01f --- /dev/null +++ b/internal/tui/testdata/usb_faixa_aplicado_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + ! pendente Aplicado, aguardando confirmação [x] fechar + 8 entrada(s) na política + REVERTE SOZINHO às 12:10 se você não manter (tecla n) + Backup protegido em C:\ProgramData\toolkit + Teste o teclado e o mouse agora. Para desfazer: tecla d +──────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). + Nada se aplica por padrão e nada muda antes de você confirmar. Isto reduz o + risco, não o elimina: um dispositivo que clona o VID/PID de um permitido + passa. + edição pro · administrador: sim + ! Aplicado, aguardando confirmação. REVERTE SOZINHO às 12:10. n mantém (cancela + a reversão); d desfaz agora. +─ USB conectados agora ───────────────────────────────────────────────────────── + > Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro + HID) -> conectado + Pendrive USB FFFF:0003 classe USB -> conectado + +─────────────────────────────────────────────────────────────── ↓ mais 2 linhas + Aplicado: aguardando a sua confirmação. + n manter… d desfazer… p ver plano c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_home_120x40.golden b/internal/tui/testdata/usb_home_120x40.golden new file mode 100644 index 0000000..e4816b7 --- /dev/null +++ b/internal/tui/testdata/usb_home_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + i Não disponível neste sistema + O modo empresa de USB: a edição home do Windows não é suportada. + A Microsoft não documenta a política de restrição de instalação de dispositivos para esta edição (só Pro, Enterprise e + Education): o toolkit recusa em vez de prometer o que não está documentado. + Nada foi alterado. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + ? ajuda q sair diff --git a/internal/tui/testdata/usb_home_60x16.golden b/internal/tui/testdata/usb_home_60x16.golden new file mode 100644 index 0000000..068fe42 --- /dev/null +++ b/internal/tui/testdata/usb_home_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + i Não disponível neste sistema + O modo empresa de USB: a edição home do Windows não é + suportada. + A Microsoft não documenta a política de restrição de + instalação de dispositivos para esta edição (só Pro, + Enterprise e Education): o toolkit recusa em vez de + prometer o que não está documentado. + Nada foi alterado. + + + +──────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confir… + ? ajuda q sair diff --git a/internal/tui/testdata/usb_home_80x24.golden b/internal/tui/testdata/usb_home_80x24.golden new file mode 100644 index 0000000..ab43f01 --- /dev/null +++ b/internal/tui/testdata/usb_home_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + i Não disponível neste sistema + O modo empresa de USB: a edição home do Windows não é suportada. + A Microsoft não documenta a política de restrição de instalação de dispositivos + para esta edição (só Pro, Enterprise e Education): o toolkit recusa em vez de + prometer o que não está documentado. + Nada foi alterado. + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + ? ajuda q sair diff --git a/internal/tui/testdata/usb_linux_120x40.golden b/internal/tui/testdata/usb_linux_120x40.golden new file mode 100644 index 0000000..6493284 --- /dev/null +++ b/internal/tui/testdata/usb_linux_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + i Não disponível neste sistema + O modo empresa de USB: só existe no Windows (este sistema é Linux). + No Linux a política de restrição de instalação de dispositivos não usam o registro nem as políticas do Windows. + Nada foi alterado. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + ? ajuda q sair diff --git a/internal/tui/testdata/usb_linux_60x16.golden b/internal/tui/testdata/usb_linux_60x16.golden new file mode 100644 index 0000000..2850537 --- /dev/null +++ b/internal/tui/testdata/usb_linux_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + i Não disponível neste sistema + O modo empresa de USB: só existe no Windows (este sistema é + Linux). + No Linux a política de restrição de instalação de + dispositivos não usam o registro nem as políticas do + Windows. + Nada foi alterado. + + + + +──────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confir… + ? ajuda q sair diff --git a/internal/tui/testdata/usb_linux_80x24.golden b/internal/tui/testdata/usb_linux_80x24.golden new file mode 100644 index 0000000..0786b58 --- /dev/null +++ b/internal/tui/testdata/usb_linux_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + i Não disponível neste sistema + O modo empresa de USB: só existe no Windows (este sistema é Linux). + No Linux a política de restrição de instalação de dispositivos não usam o + registro nem as políticas do Windows. + Nada foi alterado. + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + ? ajuda q sair diff --git a/internal/tui/testdata/usb_manter_120x40.golden b/internal/tui/testdata/usb_manter_120x40.golden new file mode 100644 index 0000000..132ee95 --- /dev/null +++ b/internal/tui/testdata/usb_manter_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + MANTER O MODO EMPRESA DE USB? (EXPERIMENTAL) + Cancela a reversão automática: a política continua aplicada e só sai quando você desfizer (tecla d). + ! aviso: Só mantenha depois de testar o teclado e o mouse e de ver que os USB de que você precisa funcionam. Isto reduz + o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa. + Backup: o snapshot protegido continua em C:\ProgramData\toolkit; é ele que o desfazer restaura. + Como desfazer: tecla d desfaz a qualquer hora. + + Manter o modo empresa de USB (EXPERIMENTAL) + + A tarefa de reversão será removida. + + >[ Cancelar ]< [ Manter ] + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + Confirmação aberta: nada muda até você confirmar. + Tab botão Enter ativa s confirma Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_manter_60x16.golden b/internal/tui/testdata/usb_manter_60x16.golden new file mode 100644 index 0000000..4e3c3e4 --- /dev/null +++ b/internal/tui/testdata/usb_manter_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + MANTER O MODO EMPRESA DE USB? (EXPERIMENTAL) + Cancela a reversão automática: a política continua aplicada + e só sai quando você desfizer (tecla d). + ! aviso: Só mantenha depois de testar o teclado e o mouse e + de ver que os USB de que você precisa funcionam. Isto + reduz o risco, não o elimina: um dispositivo que clona o + VID/PID de um permitido passa. + Backup: o snapshot protegido continua em + C:\ProgramData\toolkit; é ele que o desfazer restaura. + ↓ mais 5 linhas + >[ Cancelar ]< [ Manter ] +──────────────────────────────────────────────────────────── + Confirmação aberta: nada muda até você confirmar. + Tab botão Enter ativa s confirma ? ajuda q sair diff --git a/internal/tui/testdata/usb_manter_80x24.golden b/internal/tui/testdata/usb_manter_80x24.golden new file mode 100644 index 0000000..bed7eec --- /dev/null +++ b/internal/tui/testdata/usb_manter_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + MANTER O MODO EMPRESA DE USB? (EXPERIMENTAL) + Cancela a reversão automática: a política continua aplicada e só sai quando + você desfizer (tecla d). + ! aviso: Só mantenha depois de testar o teclado e o mouse e de ver que os USB + de que você precisa funcionam. Isto reduz o risco, não o elimina: um + dispositivo que clona o VID/PID de um permitido passa. + Backup: o snapshot protegido continua em C:\ProgramData\toolkit; é ele que o + desfazer restaura. + Como desfazer: tecla d desfaz a qualquer hora. + + Manter o modo empresa de USB (EXPERIMENTAL) + + A tarefa de reversão será removida. + + >[ Cancelar ]< [ Manter ] + + + + +──────────────────────────────────────────────────────────────────────────────── + Confirmação aberta: nada muda até você confirmar. + Tab botão Enter ativa s confirma Esc cancela ↑↓ rolar ? ajuda q sair diff --git a/internal/tui/testdata/usb_principal_120x40.golden b/internal/tui/testdata/usb_principal_120x40.golden new file mode 100644 index 0000000..4a6f5e3 --- /dev/null +++ b/internal/tui/testdata/usb_principal_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa. + edição pro · administrador: sim + Estado: nunca aplicado nesta máquina. espaço marca ou desmarca; p mostra o plano. +─ USB conectados agora ───────────────────────────────────────────────────────────────────────────────────────────────── + [x] Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro HID) -> entra na lista + > [ ] Pendrive USB FFFF:0003 classe USB -> desmarcado, fora da lista (o plano diz se será bloqueado) + + A prova de que teclado, mouse, disco e controladores continuam permitidos aparece no plano (tecla p ou a). Sem prova, o + toolkit recusa e não muda nada. + + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + ↑↓ dispositivo espaço marcar p ver plano a aplicar… c ler de novo ? ajuda q sair diff --git a/internal/tui/testdata/usb_principal_60x16.golden b/internal/tui/testdata/usb_principal_60x16.golden new file mode 100644 index 0000000..2b557e0 --- /dev/null +++ b/internal/tui/testdata/usb_principal_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a + verificar em VM). Nada se aplica por padrão e nada muda + antes de você confirmar. Isto reduz o risco, não o + elimina: um dispositivo que clona o VID/PID de um + permitido passa. + edição pro · administrador: sim + Estado: nunca aplicado nesta máquina. espaço marca ou + desmarca; p mostra o plano. +─ USB conectados agora ───────────────────────────────────── + [x] Teclado USB FFFF:0001 classe USB · essencial +─────────────────────────────────────────── ↓ mais 7 linhas + USB permitidos (experimental) — nada muda antes de confir… + ↑↓ dispositivo espaço marcar p ver plano ? ajuda q sair diff --git a/internal/tui/testdata/usb_principal_80x24.golden b/internal/tui/testdata/usb_principal_80x24.golden new file mode 100644 index 0000000..31ea61a --- /dev/null +++ b/internal/tui/testdata/usb_principal_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + MODO EMPRESA: USB PERMITIDOS · [experimental] · só Windows + ! experimental: ainda não foi testado numa máquina real (a verificar em VM). + Nada se aplica por padrão e nada muda antes de você confirmar. Isto reduz o + risco, não o elimina: um dispositivo que clona o VID/PID de um permitido + passa. + edição pro · administrador: sim + Estado: nunca aplicado nesta máquina. espaço marca ou desmarca; p mostra o + plano. +─ USB conectados agora ───────────────────────────────────────────────────────── + [x] Teclado USB FFFF:0001 classe USB · essencial (teclado, mouse ou outro + HID) -> entra na lista + > [ ] Pendrive USB FFFF:0003 classe USB -> desmarcado, fora da lista (o plano + diz se será bloqueado) + + A prova de que teclado, mouse, disco e controladores continuam permitidos + aparece no plano (tecla p ou a). Sem prova, o toolkit recusa e não muda nada. + + + +──────────────────────────────────────────────────────────────────────────────── + USB permitidos (experimental) — nada muda antes de confirmar + ↑↓ dispositivo espaço marcar p ver plano a aplicar… ? ajuda q sair diff --git a/internal/tui/testdata/usb_recusado_120x40.golden b/internal/tui/testdata/usb_recusado_120x40.golden new file mode 100644 index 0000000..04191ff --- /dev/null +++ b/internal/tui/testdata/usb_recusado_120x40.golden @@ -0,0 +1,40 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + PLANO DO MODO EMPRESA (EXPERIMENTAL) + Prova de dispositivos essenciais: RECUSADO, nada será alterado + NÃO Teclado USB (USB, USB): a classe USB é negada pela política e o dispositivo não está na lista de IDs + RECUSADO: Teclado USB ficaria BLOQUEADO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + ! Recusado: Teclado USB ficaria BLOQUEADO. Nada foi alterado. Esc volta. + ↑↓ rolar Esc voltar ? ajuda q sair diff --git a/internal/tui/testdata/usb_recusado_60x16.golden b/internal/tui/testdata/usb_recusado_60x16.golden new file mode 100644 index 0000000..b468195 --- /dev/null +++ b/internal/tui/testdata/usb_recusado_60x16.golden @@ -0,0 +1,16 @@ + toolkit [1 USB] v0.1.0 +──────────────────────────────────────────────────────────── + PLANO DO MODO EMPRESA (EXPERIMENTAL) + Prova de dispositivos essenciais: RECUSADO, nada será + alterado + NÃO Teclado USB (USB, USB): a classe USB é negada pela + política e o dispositivo não está na lista de IDs + RECUSADO: Teclado USB ficaria BLOQUEADO + + + + + +──────────────────────────────────────────────────────────── + ! Recusado: Teclado USB ficaria BLOQUEADO. Nada foi alter… + ↑↓ rolar Esc voltar ? ajuda q sair diff --git a/internal/tui/testdata/usb_recusado_80x24.golden b/internal/tui/testdata/usb_recusado_80x24.golden new file mode 100644 index 0000000..4ab1129 --- /dev/null +++ b/internal/tui/testdata/usb_recusado_80x24.golden @@ -0,0 +1,24 @@ + toolkit [1 USB permitidos (experimental)] v0.1.0 +──────────────────────────────────────────────────────────────────────────────── + PLANO DO MODO EMPRESA (EXPERIMENTAL) + Prova de dispositivos essenciais: RECUSADO, nada será alterado + NÃO Teclado USB (USB, USB): a classe USB é negada pela política e o + dispositivo não está na lista de IDs + RECUSADO: Teclado USB ficaria BLOQUEADO + + + + + + + + + + + + + + +──────────────────────────────────────────────────────────────────────────────── + ! Recusado: Teclado USB ficaria BLOQUEADO. Nada foi alterado. Esc volta. + ↑↓ rolar Esc voltar ? ajuda q sair diff --git a/internal/tui/usb_tab.go b/internal/tui/usb_tab.go new file mode 100644 index 0000000..69e6127 --- /dev/null +++ b/internal/tui/usb_tab.go @@ -0,0 +1,764 @@ +package tui + +import ( + "context" + "errors" + "fmt" + "strings" + + tea "charm.land/bubbletea/v2" + "charm.land/lipgloss/v2" + + "github.com/PiluTech/toolkit/internal/textsafe" +) + +// Erros que o backend de USB devolve para a seção mostrar a instrução certa. +var ( + // ErrUsbNeedsAdmin: aplicar, manter e desfazer exigem administrador (nada foi mudado). + ErrUsbNeedsAdmin = errors.New("usb: exige administrador") + // ErrUsbStalePlan: a ação não corresponde ao plano mostrado (o sistema, o backup ou a seleção mudou, ou não há plano + // preparado): nada foi alterado e é preciso ver o plano de novo. + ErrUsbStalePlan = errors.New("usb: o plano mudou") +) + +// Estados do modo empresa lidos do sistema. +const ( + UsbClean = "clean" // nunca aplicado + UsbArmed = "armed" // aplicado, aguardando confirmação (a reversão automática está armada) + UsbActive = "active" // aplicado e confirmado + UsbStale = "stale" // sobra de uma aplicação que não chegou ao fim + UsbUnknown = "unknown" // houve aplicação e o snapshot sumiu: ESTADO ORIGINAL DESCONHECIDO +) + +// UsbDevice é um USB conectado agora. Key identifica a instância (a seleção é por ela). +type UsbDevice struct { + Key string + Name string + VIDPID string + Class string + Essential bool // teclado, mouse ou outro HID: desmarcar recusa +} + +// UsbInfo é o que a seção carrega. Supported=false fora do Windows. EditionOK=false no Home e nas edições sem suporte. +type UsbInfo struct { + Supported bool + OS string + Edition string + EditionOK bool + IsAdmin bool + State string + Reason string // motivo do estado desconhecido + // RevertNote é o rastro da última reversão automática ("a reversão automática rodou e falhou: ..."); vazio = nenhum. + RevertNote string + Deadline string // "HH:MM" da reversão automática (estado armed) + Devices []UsbDevice +} + +// UsbPlan é um plano pronto para mostrar (texto já formatado). OK=false quando recusado (sem prova, edição, política +// existente) ou quando o desfazer não pode restaurar (estado desconhecido, conflito): só leitura, nunca vira confirmação. +type UsbPlan struct { + ID string // ID opaco do plano: a confirmação age SÓ sobre o plano com esse ID + Text string + OK bool + Refusal string + Prazo int + Allowed int // dispositivos marcados (entram na lista) + Deselected int // dispositivos desmarcados (ficam fora da lista) + Blocked int // dos desmarcados, quantos a política bloquearia ao reconectar + IsAdmin bool +} + +// UsbResult é o que uma ação fez. +type UsbResult struct { + Entries int + Restored int + Deadline string // "HH:MM" da reversão automática (depois de aplicar) + BackupPath string + RestoredNow bool // a falha no meio foi desfeita na hora + Nothing bool +} + +// UsbBackend liga a seção ao pacote usb. Load e Plan/UndoPlan/KeepPlan só leem; Apply, Keep e Undo mudam o sistema e só são +// chamados depois da confirmação dentro da seção, sempre com o ID do plano mostrado (uso único). +type UsbBackend interface { + Load(ctx context.Context) (UsbInfo, error) + Plan(ctx context.Context, excluded []string) (UsbPlan, error) + Apply(ctx context.Context, planID string) (UsbResult, error) + KeepPlan(ctx context.Context) (UsbPlan, error) + Keep(ctx context.Context, planID string) (UsbResult, error) + UndoPlan(ctx context.Context) (UsbPlan, error) + Undo(ctx context.Context, planID string) (UsbResult, error) +} + +type usbKind int + +const ( + usbView usbKind = iota + usbApply + usbKeep + usbUndo +) + +type usbLoadedMsg struct { + info UsbInfo + err error +} + +type usbPlanMsg struct { + seq int + kind usbKind + plan UsbPlan + err error +} + +type usbDoneMsg struct { + kind usbKind + res UsbResult + err error +} + +// UsbTab é a seção "USB permitidos (experimental)" da área Segurança (só Windows). +type UsbTab struct { + be UsbBackend + ctx context.Context + theme Theme + + loading bool + loaded bool + loadErr error + info UsbInfo + + cur int + excluded map[string]bool // desmarcados (por Key) + scroll int + lastW int + lastH int + frame int + + busy privBusy + seq int + changed bool // alguma ação já mudou o sistema nesta sessão: o erro de releitura não pode dizer "Nada foi alterado" + cancel context.CancelFunc + view bool + kind usbKind + plan UsbPlan + asking bool + conf *Confirm + notice string + warn bool + res *Result +} + +// NewUsbTab cria a seção. O backend decide o que é "suportado" (no real, GOOS == windows). +func NewUsbTab(ctx context.Context, be UsbBackend, th Theme) *UsbTab { + return &UsbTab{be: be, ctx: ctx, theme: th, excluded: map[string]bool{}} +} + +// SetContext troca o contexto das chamadas ao backend. +func (t *UsbTab) SetContext(ctx context.Context) { t.ctx = ctx } + +// Title implementa Tab. O rótulo de experimental fica SEMPRE no título da seção. +func (t *UsbTab) Title() string { return "USB permitidos (experimental)" } + +// Short implementa Tab. +func (t *UsbTab) Short() string { return "USB" } + +// Init NÃO lê nada: a leitura do PnP varre todos os dispositivos e levaria vários segundos em TODA abertura da TUI no +// Windows. A primeira leitura é pedida com a tecla c (como na Otimização). +func (t *UsbTab) Init() tea.Cmd { return nil } + +// Reload relê o estado depois de uma execução. +func (t *UsbTab) Reload() tea.Cmd { return t.loadCmd() } + +func (t *UsbTab) loadCmd() tea.Cmd { + be, ctx := t.be, t.ctx + return func() tea.Msg { + info, err := be.Load(ctx) + return usbLoadedMsg{info: info, err: err} + } +} + +// Capturing implementa Tab: durante a confirmação e a aplicação todas as teclas são da seção. +func (t *UsbTab) Capturing() bool { return t.asking || t.busy == busyApply } + +// Selected implementa Tab. +func (t *UsbTab) Selected() int { return 0 } + +func (t *UsbTab) usable() bool { + return t.loaded && !t.loading && t.loadErr == nil && t.info.Supported && t.info.EditionOK +} + +// Result implementa Resulter. +func (t *UsbTab) Result() *Result { return t.res } + +// Dismiss implementa Resulter. +func (t *UsbTab) Dismiss() { t.res = nil } + +func (t *UsbTab) setNotice(s string, warn bool) { t.notice, t.warn = textsafe.Line(s), warn } + +func cleanUsbInfo(i UsbInfo) UsbInfo { + i.OS, i.Edition, i.Reason, i.Deadline = textsafe.Line(i.OS), textsafe.Line(i.Edition), textsafe.Line(i.Reason), textsafe.Line(i.Deadline) + i.RevertNote = textsafe.Line(i.RevertNote) + ds := make([]UsbDevice, len(i.Devices)) + for k, d := range i.Devices { + ds[k] = UsbDevice{Key: d.Key, Name: textsafe.Line(d.Name), VIDPID: textsafe.Line(d.VIDPID), Class: textsafe.Line(d.Class), Essential: d.Essential} + } + i.Devices = ds + return i +} + +// Update trata dados carregados, planos, resultados, o spinner e as teclas. +func (t *UsbTab) Update(msg tea.Msg) (Tab, tea.Cmd) { + switch m := msg.(type) { + case usbLoadedMsg: + t.loading = false + if m.err != nil { + t.loadErr = m.err + return t, nil + } + t.loadErr, t.loaded = nil, true + t.info = cleanUsbInfo(m.info) + keep := map[string]bool{} + for _, d := range t.info.Devices { // a seleção só vale para o que ainda está conectado + if t.excluded[d.Key] { + keep[d.Key] = true + } + } + t.excluded = keep + t.cur = max(min(t.cur, len(t.info.Devices)-1), 0) + case usbPlanMsg: + if m.seq != t.seq || t.busy != busyPlan { + return t, nil // plano atrasado de uma tecla anterior + } + t.busy = busyNone + if t.cancel != nil { + t.cancel() + t.cancel = nil + } + t.onPlan(m) + case usbDoneMsg: + // qualquer ação que terminou, ou que falhou depois de poder ter mexido no sistema, impede a tela de dizer "Nada foi + // alterado" se a releitura falhar; só a recusa (plano velho, sem administrador) garante que nada mudou. + if m.err == nil || m.res.Entries > 0 || m.res.Restored > 0 || m.res.RestoredNow || + (!errors.Is(m.err, ErrUsbStalePlan) && !errors.Is(m.err, ErrUsbNeedsAdmin)) { + t.changed = true + } + t.onDone(m) + return t, t.loadCmd() + case tickMsg: + t.frame++ + if t.loading || t.busy != busyNone { + return t, t.theme.Tick() + } + case tea.KeyPressMsg: + return t, t.key(m.String()) + } + return t, nil +} + +func (t *UsbTab) onPlan(m usbPlanMsg) { + if !t.usable() { // sem tela utilizável o plano não vira confirmação + t.asking, t.view, t.conf = false, false, nil + return + } + t.scroll, t.asking = 0, false + if m.err != nil { + t.view = false + t.setNotice("erro: "+m.err.Error(), true) + return + } + t.view, t.kind, t.plan = true, m.kind, m.plan + t.plan.Text = textsafe.Multiline(m.plan.Text) + if !m.plan.OK { // recusado ou sem como restaurar: só leitura, nunca confirmação + reason := textsafe.Line(m.plan.Refusal) + if reason == "" { + reason = "o plano foi recusado" + } + t.setNotice("Recusado: "+reason+". "+NothingChanged+" Esc volta.", true) + return + } + if m.kind == usbView { + t.setNotice("Só leitura: nada foi alterado. Esc volta.", false) + return + } + t.asking, t.conf, t.notice = true, t.buildConfirm(), "" +} + +// buildConfirm monta a confirmação única com a EVIDÊNCIA: a lista de dispositivos (no texto do plano), o que será +// permitido e bloqueado, o risco de trancar, o prazo e o roteiro de recuperação. Sem administrador o botão de confirmar fica +// indisponível com o motivo. +func (t *UsbTab) buildConfirm() *Confirm { + p := t.plan + reason := "" + if !p.IsAdmin { + reason = "sem administrador" + } + var c *Confirm + switch t.kind { + case usbKeep: + c = NewConfirm("Manter", reason) + c.Title = "Manter o modo empresa de USB? (experimental)" + c.Summary = "Cancela a reversão automática: a política continua aplicada e só sai quando você desfizer (tecla d)." + c.Warn = "Só mantenha depois de testar o teclado e o mouse e de ver que os USB de que você precisa funcionam. Isto reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa." + c.Backup = "o snapshot protegido continua em C:\\ProgramData\\toolkit; é ele que o desfazer restaura." + c.Undo = "tecla d desfaz a qualquer hora." + case usbUndo: + c = NewConfirm("Restaurar", reason) + c.Title = "Desfazer o modo empresa de USB? (experimental)" + c.Summary = "Restaura EXATAMENTE o snapshot validado (valores de outras origens ficam como estão) e remove a tarefa de reversão e o backup." + c.Backup = "os valores originais vêm do snapshot protegido; ele é removido depois de restaurar." + c.Undo = "para voltar ao modo empresa, aplique de novo (tecla a)." + default: + c = NewConfirm("Aplicar", reason) + c.Title = "Permitir só os USB conhecidos? (experimental)" + c.Summary = fmt.Sprintf("Libera %d dispositivo(s) USB conectado(s) agora; %d desmarcado(s) ficam fora da lista (a política bloquearia %d ao reconectar). Reverte SOZINHO em %d minuto(s) se você não manter (tecla n).", p.Allowed, p.Deselected, p.Blocked, p.Prazo) + c.Warn = "EXPERIMENTAL, não testado numa máquina real. RISCO: se algo der errado o teclado pode travar; tenha um segundo teclado ou mouse de reserva já permitido. Reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa." + c.Backup = "snapshot protegido em C:\\ProgramData\\toolkit (só SYSTEM e Administradores), relido e conferido; a tarefa de reversão é criada e conferida ANTES da primeira chave. Falha em qualquer passo = nenhuma alteração." + c.Undo = fmt.Sprintf("n mantém (cancela a reversão); sem ação, volta sozinho em %d min; d desfaz. Recuperação manual (WinRE, outra conta de administrador) abaixo.", p.Prazo) + } + if !p.IsAdmin { + c.Warn = "Sem administrador: nada será alterado. Cancele, abra o terminal como administrador (botão direito, \"Executar como administrador\") e tente de novo. " + NeverElevates + " " + c.Warn + } + c.Text = strings.TrimRight(p.Text, "\n") + return c +} + +func (t *UsbTab) onDone(m usbDoneMsg) { + t.busy, t.asking, t.view, t.scroll, t.conf = busyNone, false, false, 0, nil + what := map[usbKind]string{usbApply: "aplicar", usbKeep: "manter", usbUndo: "restaurar"}[m.kind] + bk := "" + if m.res.BackupPath != "" { + bk = "Backup protegido em " + textsafe.Line(m.res.BackupPath) + } + switch { + case m.err != nil && errors.Is(m.err, ErrUsbStalePlan): + t.setNotice("O plano mudou: nada foi alterado.", true) + t.res = &Result{Kind: ResultInfo, Title: "O plano mudou", Lines: []string{"O sistema, o backup ou a seleção mudou desde o plano mostrado: nada foi alterado.", "Veja o plano de novo (p, a, n ou d) antes de confirmar."}} + case m.err != nil && errors.Is(m.err, ErrUsbNeedsAdmin): + t.setNotice("Precisa de administrador: nada foi alterado.", true) + t.res = &Result{Kind: ResultError, Title: "Precisa de administrador", Lines: adminResultLines()} + case m.err != nil && m.res.RestoredNow: + t.setNotice("erro: "+m.err.Error(), true) + t.res = &Result{Kind: ResultError, Title: "Não foi possível aplicar", Lines: []string{"Erro: " + m.err.Error(), "A falha aconteceu no meio e o registro foi restaurado na hora: nada ficou aplicado."}} + case m.err != nil: + t.setNotice("erro: "+m.err.Error(), true) + lines := []string{"Erro: " + m.err.Error()} + if m.kind == usbApply { + lines = append(lines, "Se algo ficou aplicado, a reversão automática restaura sozinha; ou use d (desfazer).") + } else { + lines = append(lines, "Veja o estado (tecla c) antes de tentar de novo.") + } + t.res = &Result{Kind: ResultError, Title: "Não foi possível " + what, Lines: lines} + case m.res.Nothing: + t.setNotice("Nada a fazer.", false) + t.res = &Result{Kind: ResultInfo, Title: "Nada a fazer", Lines: []string{"Não havia nada aplicado nem pendente."}} + case m.kind == usbUndo: + t.setNotice(fmt.Sprintf("Restaurado: %d valor(es).", m.res.Restored), false) + t.res = &Result{Kind: ResultOK, Title: "Modo empresa desfeito", Lines: []string{fmt.Sprintf("%d valor(es) voltaram ao original", m.res.Restored), "A tarefa de reversão e o backup foram removidos."}} + case m.kind == usbKeep: + t.setNotice("Modo empresa mantido.", false) + t.res = &Result{Kind: ResultOK, Title: "Modo empresa mantido", Lines: []string{"A reversão automática foi cancelada; a política continua aplicada.", "Para desfazer: tecle d nesta seção."}} + default: + t.setNotice("Aplicado: aguardando a sua confirmação.", false) + lines := []string{fmt.Sprintf("%d entrada(s) na política", m.res.Entries)} + if m.res.Deadline != "" { + lines = append(lines, "REVERTE SOZINHO às "+textsafe.Line(m.res.Deadline)+" se você não manter (tecla n)") + } + if bk != "" { + lines = append(lines, bk) + } + lines = append(lines, "Teste o teclado e o mouse agora. Para desfazer: tecla d") + t.res = &Result{Kind: ResultPending, Title: "Aplicado, aguardando confirmação", Lines: lines} + } + t.res = cleanResult(t.res) +} + +// key trata as teclas. Mudar o sistema só acontece depois do plano na tela e do "s" (ou "y") na confirmação. +func (t *UsbTab) key(k string) tea.Cmd { + if t.busy == busyPlan && (k == "esc" || k == "escape") { + // Esc cancela a PREPARAÇÃO do plano: invalida a resposta (seq) e o contexto; uma ação já iniciada não é cancelável. + t.seq++ + if t.cancel != nil { + t.cancel() + t.cancel = nil + } + t.busy, t.asking, t.view = busyNone, false, false + t.setNotice("Preparação do plano cancelada: nada foi alterado.", false) + return nil + } + if t.loading || t.busy != busyNone { + return nil + } + if !t.usable() { + // Carregando, com erro, vazio ou não suportado: nada que arme confirmação ou aja. Só reler (c). + t.asking, t.view, t.conf = false, false, nil + if k == "c" && (t.loadErr != nil || !t.loaded) { + t.loading = true + return tea.Batch(t.loadCmd(), t.theme.Tick()) + } + return nil + } + if t.asking { + switch t.conf.Update(k) { + case ConfirmAccept: + return t.confirmed() + case ConfirmCancel: + t.asking, t.view, t.conf, t.scroll = false, false, nil, 0 + t.setNotice("Cancelado: nada foi alterado.", false) + } + return nil + } + if t.view { + switch k { + case "up", "down", "pgup", "pgdown": + t.scrollKey(k) + case "esc", "enter", "left", "backspace": + t.view, t.scroll, t.notice = false, 0, "" + } + return nil + } + t.notice = "" + switch k { + case "up", "k": + t.cur = max(t.cur-1, 0) + case "down", "j": + t.cur = max(min(t.cur+1, len(t.info.Devices)-1), 0) + case "pgup", "pgdown": + t.scrollKey(k) + case " ", "space": + if t.info.State == UsbClean && t.cur < len(t.info.Devices) { + key := t.info.Devices[t.cur].Key + if t.excluded[key] { + delete(t.excluded, key) + } else { + t.excluded[key] = true + } + } + case "c": + t.loading = true + return tea.Batch(t.loadCmd(), t.theme.Tick()) + case "p": + if t.info.State == UsbClean { + return t.planCmd(usbView) + } + return t.planCmd(usbUndo) // fora do estado limpo, "ver plano" mostra o que o desfazer faria + case "a": + if t.info.State != UsbClean { + t.setNotice("Já há modo empresa aplicado (ou uma sobra dele): veja o estado acima; d desfaz.", true) + return nil + } + return t.planCmd(usbApply) + case "n": + if t.info.State != UsbArmed { + t.setNotice("Não há reversão automática pendente para cancelar.", false) + return nil + } + return t.planCmd(usbKeep) + case "d": + if t.info.State == UsbClean { + t.setNotice("Nada a desfazer: o modo empresa de USB nunca foi aplicado aqui.", false) + return nil + } + return t.planCmd(usbUndo) + } + return nil +} + +func (t *UsbTab) scrollKey(k string) { + page := max(t.lastH/2, 1) + switch k { + case "up": + t.scroll = max(t.scroll-1, 0) + case "down": + t.scroll++ + case "pgup": + t.scroll = max(t.scroll-page, 0) + case "pgdown": + t.scroll += page + } +} + +func (t *UsbTab) excludedKeys() []string { + var out []string + for _, d := range t.info.Devices { // na ordem da lista: determinístico + if t.excluded[d.Key] { + out = append(out, d.Key) + } + } + return out +} + +func (t *UsbTab) planCmd(kind usbKind) tea.Cmd { + t.busy = busyPlan + t.seq++ + pctx, cancel := context.WithCancel(t.ctx) + t.cancel = cancel + seq, be, ex := t.seq, t.be, t.excludedKeys() + return tea.Batch(func() tea.Msg { + var plan UsbPlan + var err error + switch kind { + case usbUndo: + plan, err = be.UndoPlan(pctx) + case usbKeep: + plan, err = be.KeepPlan(pctx) + default: + plan, err = be.Plan(pctx, ex) + } + return usbPlanMsg{seq: seq, kind: kind, plan: plan, err: err} + }, t.theme.Tick()) +} + +func (t *UsbTab) confirmed() tea.Cmd { + if !t.usable() || !t.asking || t.conf == nil { + t.asking, t.view, t.conf = false, false, nil + return nil + } + t.asking, t.conf, t.busy, t.notice, t.res = false, nil, busyApply, "", nil + be, ctx, kind, id := t.be, t.ctx, t.kind, t.plan.ID + return tea.Batch(func() tea.Msg { + var res UsbResult + var err error + switch kind { + case usbUndo: + res, err = be.Undo(ctx, id) + case usbKeep: + res, err = be.Keep(ctx, id) + default: + res, err = be.Apply(ctx, id) + } + return usbDoneMsg{kind: kind, res: res, err: err} + }, t.theme.Tick()) +} + +// Keys implementa Tab (vocabulário único de keys.go). +func (t *UsbTab) Keys() []KeyHint { + switch { + case !t.loaded && !t.loading && t.loadErr == nil: + return []KeyHint{act("c").Hint()} + case t.loading || t.loadErr != nil || !t.usable(): + return nil + case t.busy == busyApply: + return nil + case t.busy == busyPlan: + return []KeyHint{{"Esc", "cancelar"}} + case t.asking: + return t.conf.keyHints() + case t.view: + return []KeyHint{{"↑↓", "rolar"}, {"Esc", "voltar"}} + } + switch t.info.State { + case UsbClean: + return []KeyHint{{"↑↓", "dispositivo"}, act("espaço").Hint(), act("p").Hint(), act("a").Hint(), act("c").Hint()} + case UsbArmed: + return []KeyHint{act("n").Hint(), act("d").Hint(), act("p").Hint(), act("c").Hint()} + case UsbUnknown: + return []KeyHint{act("p").Hint(), act("c").Hint()} + } + return []KeyHint{act("d").Hint(), act("p").Hint(), act("c").Hint()} +} + +// HelpKeys implementa SectionHelper. +func (t *UsbTab) HelpKeys() []KeyDef { + if !t.loaded && !t.loading && t.loadErr == nil { + return []KeyDef{act("c").says("lê os dispositivos USB e o estado (a primeira leitura varre o PnP e leva alguns segundos).")} + } + if !t.usable() { + return noActionsHelp(t.loading || t.loadErr != nil) + } + switch t.info.State { + case UsbClean: + return []KeyDef{ + navDef("↑↓", "dispositivo", "escolhe o dispositivo USB da lista."), + act("espaço").says("marca ou desmarca o dispositivo: desmarcado fica bloqueado ao reconectar (teclado e mouse desmarcados são recusados)."), + act("p").says("mostra o plano e a prova dos dispositivos essenciais, sem alterar nada."), + act("a").says("aplica a política depois da confirmação (administrador); reverte sozinha se você não manter."), + act("c").says("lê o estado outra vez."), + } + case UsbArmed: + return []KeyDef{ + act("n").says("mantém o modo empresa e cancela a reversão automática, depois da confirmação."), + act("d").says("desfaz agora, a partir do snapshot protegido, depois da confirmação."), + act("p").says("mostra o que o desfazer restauraria, sem alterar nada."), + act("c").says("lê o estado outra vez."), + } + case UsbUnknown: + return []KeyDef{ + act("p").says("mostra a recuperação manual: sem snapshot o toolkit não restaura nada às cegas."), + act("c").says("lê o estado outra vez."), + } + } + return []KeyDef{ + act("d").says("desfaz o modo empresa, a partir do snapshot protegido, depois da confirmação."), + act("p").says("mostra o que o desfazer restauraria, sem alterar nada."), + act("c").says("lê o estado outra vez."), + } +} + +// Status implementa Tab. +func (t *UsbTab) Status() string { + switch { + case t.asking && t.conf != nil: + return t.conf.Hint() + case t.busy == busyApply: + return t.theme.Spin(t.frame) + " Aplicando… não feche a janela." + case t.busy == busyPlan: + return t.theme.Spin(t.frame) + " Preparando o plano… Esc cancela." + case t.loading: + return "Lendo os dispositivos USB…" + case !t.loaded && t.loadErr == nil: + return "Ainda não lido. Tecle c para ler." + case t.loadErr != nil: + return "Falhou. c lê de novo." + case t.notice != "" && t.warn: + return SymWarn + " " + t.notice + case t.notice != "": + return t.notice + } + return "USB permitidos (experimental) — nada muda antes de confirmar" +} + +// More implementa Tab. +func (t *UsbTab) More() int { + if !t.usable() || t.asking { + return 0 // a confirmação mostra o próprio "↓ mais N linhas" + } + if t.view { + return max(len(t.planLines(t.lastW))-(t.scroll+t.lastH-1), 0) + } + return max(len(t.mainLines(t.lastW))-(t.scroll+t.lastH), 0) +} + +// View desenha o corpo. +func (t *UsbTab) View(w, h int) string { + t.lastW, t.lastH = w, h + switch { + case t.loading: + return strings.Join(StateLoading(t.theme, w, h, "os dispositivos USB", t.frame), "\n") + case !t.loaded && t.loadErr == nil: + return strings.Join(StateEmpty(t.theme, w, h, "Os dispositivos USB ainda não foram lidos (a leitura varre todos os dispositivos e leva alguns segundos).", "Tecle c para ler. Nada muda: a leitura é só leitura."), "\n") + case t.loadErr != nil && t.changed: + return strings.Join(StateErrorAfterChange(t.theme, w, h, "os USB permitidos", t.loadErr, "Tecle c para reler o estado."), "\n") + case t.loadErr != nil: + return strings.Join(StateError(t.theme, w, h, "os USB permitidos", t.loadErr, "Tente de novo (c)."), "\n") + case !t.info.Supported: + return strings.Join(StateUnsupported(t.theme, w, h, "o modo empresa de USB", unsupportedWhy(t.info.OS, "a política de restrição de instalação de dispositivos"), osName(t.info.OS)), "\n") + case !t.info.EditionOK: + return strings.Join(StateUnsupportedEdition(t.theme, w, h, "o modo empresa de USB", t.info.Edition, "A Microsoft não documenta a política de restrição de instalação de dispositivos para esta edição (só Pro, Enterprise e Education): o toolkit recusa em vez de prometer o que não está documentado."), "\n") + } + if t.asking && t.conf != nil { + return strings.Join(t.conf.View(t.theme, w, h), "\n") + } + var lines []string + if t.view { + lines = t.fitPlan(w, h) + } else { + all := t.mainLines(w) + t.scroll = max(min(t.scroll, max(len(all)-h, 0)), 0) + lines = all[min(t.scroll, len(all)):min(t.scroll+h, len(all))] + } + for i := range lines { + lines[i] = clip(lines[i], w) + } + return strings.Join(lines, "\n") +} + +func (t *UsbTab) fitPlan(w, h int) []string { + all := t.planLines(w) + room := max(h-1, 1) + t.scroll = max(min(t.scroll, max(len(all)-room, 0)), 0) + title := "Plano do modo empresa (experimental)" + switch t.kind { + case usbUndo: + title = "O que o desfazer faria" + case usbKeep: + title = "Manter o modo empresa" + } + head := " " + t.theme.Title().Render(titleCase(t.theme, title)) + return append([]string{head}, all[min(t.scroll, len(all)):min(t.scroll+room, len(all))]...) +} + +func (t *UsbTab) planLines(w int) []string { + var out []string + for _, l := range strings.Split(strings.TrimRight(t.plan.Text, "\n"), "\n") { + if strings.TrimSpace(l) == "" { + out = append(out, "") + continue + } + out = append(out, wrapLine(" "+l, w)...) + } + return out +} + +func (t *UsbTab) mainLines(w int) []string { + var out []string + out = append(out, " "+t.theme.Title().Render(titleCase(t.theme, "Modo empresa: USB permitidos"))+" · "+t.theme.Warn().Render("[experimental]")+" · só Windows") + out = append(out, wrapLine(" "+t.theme.Warn().Render(SymWarn+" experimental:")+" ainda não foi testado numa máquina real (a verificar em VM). Nada se aplica por padrão e nada muda antes de você confirmar. Isto reduz o risco, não o elimina: um dispositivo que clona o VID/PID de um permitido passa.", w)...) + adm := "administrador: não (aplicar exige; o toolkit nunca eleva sozinho)" + if t.info.IsAdmin { + adm = "administrador: sim" + } + out = append(out, wrapLine(" edição "+t.info.Edition+" · "+adm, w)...) + out = append(out, t.stateLines(w)...) + title := " USB conectados agora " + out = append(out, SymRule+t.theme.Title().Render(title)+strings.Repeat(SymRule, max(w-lipgloss.Width(title)-1, 1))) + if len(t.info.Devices) == 0 { + out = append(out, " Nenhum dispositivo USB externo conectado.") + } + for i, d := range t.info.Devices { + cursor := " " + if i == t.cur { + cursor = ">" + } + mark, word := "[x]", "entra na lista" + if t.info.State != UsbClean { + mark, word = " ", "conectado" + } else if t.excluded[d.Key] { + mark, word = "[ ]", "desmarcado, fora da lista (o plano diz se será bloqueado)" + } + ess := "" + if d.Essential { + ess = " · essencial (teclado, mouse ou outro HID)" + } + prefix := " " + cursor + " " + mark + " " + out = append(out, hangLines(prefix, lipgloss.Width(prefix), fmt.Sprintf("%s %s classe %s%s -> %s", d.Name, d.VIDPID, dash(d.Class), ess, word), w)...) + } + out = append(out, "") + out = append(out, wrapLine(" A prova de que teclado, mouse, disco e controladores continuam permitidos aparece no plano (tecla p ou a). Sem prova, o toolkit recusa e não muda nada.", w)...) + return out +} + +func dash(s string) string { + if s == "" { + return "-" + } + return s +} + +// stateLines é o estado e, se a reversão automática já rodou, o que ela fez (sucesso ou falha). +func (t *UsbTab) stateLines(w int) []string { + out := t.stateBase(w) + if t.info.RevertNote != "" { + out = append(out, wrapLine(" "+t.theme.Warn().Render(SymWarn+" ")+t.info.RevertNote+".", w)...) + } + return out +} + +func (t *UsbTab) stateBase(w int) []string { + switch t.info.State { + case UsbArmed: + when := "" + if t.info.Deadline != "" { + when = " REVERTE SOZINHO às " + t.info.Deadline + "." + } + return wrapLine(" "+t.theme.Warn().Render(SymWarn+" Aplicado, aguardando confirmação.")+when+" n mantém (cancela a reversão); d desfaz agora.", w) + case UsbActive: + return wrapLine(" "+t.theme.OK().Render(SymOK+" Aplicado e confirmado.")+" d desfaz.", w) + case UsbStale: + return wrapLine(" "+t.theme.Warn().Render(SymWarn+" Sobra de uma aplicação que não chegou ao fim.")+" d limpa o backup e a tarefa.", w) + case UsbUnknown: + out := wrapLine(" "+t.theme.Warn().Render(SymWarn+" ESTADO ORIGINAL DESCONHECIDO.")+" "+t.info.Reason+". O toolkit não restaura nada às cegas; p mostra a recuperação manual.", w) + return out + } + return wrapLine(" Estado: nunca aplicado nesta máquina. espaço marca ou desmarca; p mostra o plano.", w) +} diff --git a/internal/tui/usb_tab_test.go b/internal/tui/usb_tab_test.go new file mode 100644 index 0000000..252902b --- /dev/null +++ b/internal/tui/usb_tab_test.go @@ -0,0 +1,808 @@ +package tui + +import ( + "context" + "errors" + "fmt" + "strings" + "testing" + "unicode" + + tea "charm.land/bubbletea/v2" +) + +// fakeUsb é o backend de mentira: nenhum teste da seção toca o Windows. +type fakeUsb struct { + info UsbInfo + loadErr error + plan UsbPlan + keepPlan UsbPlan + undoPlan UsbPlan + planErr error + + applyRes, keepRes, undoRes UsbResult + applyErr, keepErr, undoErr error + + loads int + plans [][]string // as exclusões recebidas por cada Plan + applies []string // IDs aplicados + keeps []string + undos []string + seq int + lastID string + issued map[string]bool // todo ID emitido (uma resposta tardia também emite o seu) +} + +func (f *fakeUsb) issue() string { + f.seq++ + f.lastID = fmt.Sprintf("plano-usb-%d", f.seq) + if f.issued == nil { + f.issued = map[string]bool{} + } + f.issued[f.lastID] = true + return f.lastID +} +func (f *fakeUsb) Load(context.Context) (UsbInfo, error) { f.loads++; return f.info, f.loadErr } +func (f *fakeUsb) Plan(_ context.Context, ex []string) (UsbPlan, error) { + f.plans = append(f.plans, append([]string(nil), ex...)) + p := f.plan + p.ID = f.issue() + return p, f.planErr +} +func (f *fakeUsb) Apply(_ context.Context, id string) (UsbResult, error) { + if !f.issued[id] { + return UsbResult{}, ErrUsbStalePlan // só um plano emitido é aplicável + } + f.applies = append(f.applies, id) + return f.applyRes, f.applyErr +} +func (f *fakeUsb) KeepPlan(context.Context) (UsbPlan, error) { + p := f.keepPlan + p.ID = f.issue() + return p, nil +} +func (f *fakeUsb) Keep(_ context.Context, id string) (UsbResult, error) { + if !f.issued[id] { + return UsbResult{}, ErrUsbStalePlan + } + f.keeps = append(f.keeps, id) + return f.keepRes, f.keepErr +} +func (f *fakeUsb) UndoPlan(context.Context) (UsbPlan, error) { + p := f.undoPlan + p.ID = f.issue() + return p, nil +} +func (f *fakeUsb) Undo(_ context.Context, id string) (UsbResult, error) { + if !f.issued[id] { + return UsbResult{}, ErrUsbStalePlan + } + f.undos = append(f.undos, id) + return f.undoRes, f.undoErr +} + +const ( + usbKbKey = `USB\VID_FFFF&PID_0001\1` + usbPenKey = `USB\VID_FFFF&PID_0003\2` + usbText = "Modo empresa: permitir só os USB conhecidos (Windows) [EXPERIMENTAL]\n\n" + + "Dispositivos USB conectados agora:\n [x] Teclado USB FFFF:0001 classe USB conectado agora · essencial -> permitido\n [ ] Pendrive USB FFFF:0003 classe USB conectado agora -> BLOQUEADO ao reconectar (desmarcado)\n\n" + + "Prova de dispositivos essenciais: OK (nenhum fica bloqueado, nem os pais deles)\n OK Teclado PS/2 padrão (Keyboard, PS/2): nenhuma regra o nega\n OK Disco NVMe (DiskDrive, SCSI): nenhuma regra o nega\n\n" + + "Reversão automática em 10 minuto(s): se você não confirmar (toolkit usb confirmar), a tarefa restaura o snapshot sozinha.\n\n" + + "Se o teclado travar mesmo assim: (1) espere o prazo; (2) use outro teclado; (3) outra conta de administrador restaura o .reg; (5) WinRE (comandos A VERIFICAR em VM).\n" +) + +func usbSample(state string, admin bool) UsbInfo { + return UsbInfo{Supported: true, OS: "windows", Edition: "pro", EditionOK: true, IsAdmin: admin, State: state, Deadline: "12:10", Reason: "o backup não existe, mas há sinais de aplicação", + Devices: []UsbDevice{ + {Key: usbKbKey, Name: "Teclado USB", VIDPID: "FFFF:0001", Class: "USB", Essential: true}, + {Key: usbPenKey, Name: "Pendrive USB", VIDPID: "FFFF:0003", Class: "USB"}, + }} +} + +func newFakeUsb(state string, admin bool) *fakeUsb { + return &fakeUsb{info: usbSample(state, admin), + plan: UsbPlan{Text: usbText, OK: true, Prazo: 10, Allowed: 1, Deselected: 1, Blocked: 1, IsAdmin: admin}, + keepPlan: UsbPlan{Text: "Manter o modo empresa de USB (EXPERIMENTAL)\n\nA tarefa de reversão será removida.\n", OK: true, IsAdmin: admin}, + undoPlan: UsbPlan{Text: "O que será restaurado (snapshot validado):\n - DenyDeviceClasses: remove (não existia antes)\n", OK: true, IsAdmin: admin}, + } +} + +func urun(tab *UsbTab, cmd tea.Cmd) { + if cmd == nil { + return + } + switch m := cmd().(type) { + case nil: + case tea.BatchMsg: + for _, c := range m { + urun(tab, c) + } + default: + _, next := tab.Update(m) + urun(tab, next) + } +} + +func usbTab(t *testing.T, be *fakeUsb) *UsbTab { + t.Helper() + tab := NewUsbTab(context.Background(), be, Theme{Mono: true, NoMotion: true}) + if cmd := tab.Init(); cmd != nil || be.loads != 0 { + t.Fatal("Init não pode ler nada: a leitura do PnP é lenta e só acontece com a tecla c") + } + ukey(tab, "c") // a primeira leitura é pedida pela pessoa + return tab +} + +func ukey(tab *UsbTab, keys ...string) { + for _, k := range keys { + var msg tea.KeyPressMsg + switch k { + case "up": + msg = tea.KeyPressMsg{Code: tea.KeyUp} + case "down": + msg = tea.KeyPressMsg{Code: tea.KeyDown} + case "esc": + msg = tea.KeyPressMsg{Code: tea.KeyEscape} + case "enter": + msg = tea.KeyPressMsg{Code: tea.KeyEnter} + case "tab": + msg = tea.KeyPressMsg{Code: tea.KeyTab} + case "space": + msg = tea.KeyPressMsg{Code: tea.KeySpace, Text: " "} + default: + msg = tea.KeyPressMsg{Code: rune(k[0]), Text: k} + } + _, cmd := tab.Update(msg) + urun(tab, cmd) + } +} + +func uview(tab *UsbTab, w, h int) string { return stripANSI(tab.View(w, h)) } + +func TestUsbTabIdentidadeExperimentalNoTitulo(t *testing.T) { + tab := NewUsbTab(context.Background(), &fakeUsb{}, Theme{Mono: true}) + if tab.Title() != "USB permitidos (experimental)" || tab.Short() != "USB" { + t.Fatalf("%q %q", tab.Title(), tab.Short()) + } +} + +func TestUsbTabEstados(t *testing.T) { + // ainda não lido (Init não lê) e carregando (depois do c) + fb := newFakeUsb(UsbClean, true) + tab := NewUsbTab(context.Background(), fb, Theme{Mono: true, NoMotion: true}) + if out := uview(tab, 80, 24); !strings.Contains(out, "ainda não foram lidos") || !strings.Contains(out, "Tecle c") { + t.Errorf("antes da primeira leitura:\n%s", out) + } + ukeys := tab.Keys() + if len(ukeys) != 1 || ukeys[0].Key != "c" { + t.Errorf("antes da primeira leitura só o c: %v", ukeys) + } + ukey(tab, "a", "s", "p") + if len(fb.plans) != 0 || len(fb.applies) != 0 { + t.Fatal("antes da leitura nada pode ser chamado") + } + tab.Update(tea.KeyPressMsg{Code: 'c', Text: "c"}) // comando sem executar: a leitura está em andamento + if out := uview(tab, 80, 24); !strings.Contains(out, "Carregando") { + t.Errorf("carregando:\n%s", out) + } + // fora do Windows + be := &fakeUsb{info: UsbInfo{OS: "linux"}} + tab = usbTab(t, be) + out := uview(tab, 80, 24) + if !strings.Contains(out, "Não disponível") || !strings.Contains(out, "Linux") { + t.Errorf("fora do Windows:\n%s", out) + } + if tab.Keys() != nil { + t.Error("fora do Windows não há teclas") + } + ukey(tab, "a", "s", "y", "p", "d", "n") + if len(be.plans) != 0 || len(be.applies) != 0 || len(be.undos) != 0 || len(be.keeps) != 0 { + t.Fatal("fora do Windows nada pode ser chamado") + } + // Windows Home (edição sem suporte) + home := newFakeUsb(UsbClean, true) + home.info.EditionOK, home.info.Edition = false, "home" + tab = usbTab(t, home) + out = uview(tab, 80, 24) + if !strings.Contains(out, "home") || !strings.Contains(out, "não documenta") { + t.Errorf("Home:\n%s", out) + } + ukey(tab, "a", "s", "y") + if len(home.plans) != 0 || len(home.applies) != 0 { + t.Fatal("Home: nada pode ser chamado") + } + // erro de leitura + bad := &fakeUsb{loadErr: errors.New("powershell: acesso negado")} + tab = usbTab(t, bad) + out = uview(tab, 80, 24) + if !strings.Contains(out, "Erro") || !strings.Contains(out, "Nada foi alterado") { + t.Errorf("erro:\n%s", out) + } + ukey(tab, "a", "s", "y") + if len(bad.plans) != 0 || len(bad.applies) != 0 { + t.Fatal("com erro de leitura nada pode ser chamado") + } +} + +func TestUsbTabTelaPrincipalListaOsDispositivosEDizExperimental(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbClean, false)) + out := uview(tab, 100, 30) + for _, want := range []string{"[experimental]", "Teclado USB", "FFFF:0001", "Pendrive USB", "essencial", "permitido", "reduz o risco, não o elimina", "administrador: não", "nunca eleva sozinho"} { + if !strings.Contains(out, want) { + t.Errorf("tela sem %q:\n%s", want, out) + } + } +} + +func TestUsbTabEspacoMarcaEDesmarcaEPlanoLevaAsExclusoes(t *testing.T) { + be := newFakeUsb(UsbClean, true) + tab := usbTab(t, be) + ukey(tab, "down", "space") + if out := uview(tab, 100, 30); !strings.Contains(out, "[ ] Pendrive USB") || !strings.Contains(out, "fora da lista") { + t.Fatalf("desmarcado não aparece:\n%s", out) + } + ukey(tab, "p") + if len(be.plans) != 1 || len(be.plans[0]) != 1 || be.plans[0][0] != usbPenKey { + t.Fatalf("exclusões enviadas = %v", be.plans) + } + ukey(tab, "esc", "space") // marca de novo + ukey(tab, "p") + if len(be.plans[1]) != 0 { + t.Fatalf("depois de marcar de novo não há exclusão: %v", be.plans[1]) + } +} + +func TestUsbTabVerPlanoEhSoLeituraESNuncaAplica(t *testing.T) { + be := newFakeUsb(UsbClean, true) + tab := usbTab(t, be) + ukey(tab, "p") + if !tab.view || tab.asking { + t.Fatalf("p devia abrir o plano em modo leitura (view=%v asking=%v)", tab.view, tab.asking) + } + if out := uview(tab, 100, 30); !strings.Contains(out, "EXPERIMENTAL") || !strings.Contains(tab.Status(), "Só leitura") { + t.Errorf("plano:\n%s\nstatus=%q", out, tab.Status()) + } + ukey(tab, "s", "y") + if len(be.applies) != 0 { + t.Fatal("s/y no modo leitura não aplicam") + } + ukey(tab, "enter") // Enter só volta + if tab.view || len(be.applies) != 0 { + t.Fatal("Enter no modo leitura só volta") + } +} + +func TestUsbTabConfirmacaoUnicaComEvidenciaEFocoEmCancelar(t *testing.T) { + be := newFakeUsb(UsbClean, true) + tab := usbTab(t, be) + ukey(tab, "a") + if !tab.asking || tab.conf == nil { + t.Fatal("a devia abrir a confirmação") + } + if tab.conf.Focus != 0 || tab.conf.Buttons[0].Label != "Cancelar" { + t.Fatalf("o foco inicial tem de ser Cancelar: %+v", tab.conf) + } + if len(be.applies) != 0 { + t.Fatal("abrir a confirmação não aplica") + } + // Enter no foco inicial (Cancelar) cancela + ukey(tab, "enter") + if tab.asking || len(be.applies) != 0 { + t.Fatal("Enter em Cancelar não pode aplicar") + } + ukey(tab, "a") + // evidência: tudo rolável, em qualquer altura, está no corpo da confirmação + var all strings.Builder + for _, sz := range [][2]int{{80, 24}, {120, 40}, {60, 16}} { + all.WriteString(uview(tab, sz[0], sz[1]) + "\n") + } + tab.conf.scroll = 0 + conf := tab.conf + body := strings.Join(append(conf.headLines(tab.theme, 100), conf.planLines(tab.theme, 100)...), "\n") + body = strings.ToLower(strings.Join(strings.Fields(stripANSI(body)), " ")) + for _, want := range []string{ + "experimental", "teclado usb", "ffff:0001", "pendrive usb", "bloqueado", "permitido", + "risco", "teclado pode travar", "segundo teclado", "reverte sozinho em 10 minuto(s)", "prova de dispositivos essenciais", "winre", + "reduz o risco, não o elimina", "snapshot protegido", "antes da primeira chave", + } { + if !strings.Contains(body, want) { + t.Errorf("a confirmação não traz %q:\n%s", want, body) + } + } + if len(be.applies) != 0 { + t.Fatal("nada foi aplicado ainda") + } + ukey(tab, "esc") + if tab.asking || len(be.applies) != 0 { + t.Fatal("Esc cancela sem aplicar") + } +} + +func TestUsbTabAplicaOIDExibidoEMostraFaixaPendente(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.applyRes = UsbResult{Entries: 8, Deadline: "12:10", BackupPath: `C:\ProgramData\toolkit`} + tab := usbTab(t, be) + ukey(tab, "a", "s") + if len(be.applies) != 1 || be.applies[0] != be.lastID { + t.Fatalf("applies=%v último=%q", be.applies, be.lastID) + } + r := tab.Result() + if r == nil || r.Kind != ResultPending || !strings.Contains(r.Title, "aguardando confirmação") { + t.Fatalf("faixa = %#v", r) + } + joined := strings.Join(r.Lines, "\n") + for _, want := range []string{"REVERTE SOZINHO às 12:10", "tecla n", "Backup protegido", "tecla d"} { + if !strings.Contains(joined, want) { + t.Errorf("faixa sem %q: %s", want, joined) + } + } + tab.Dismiss() + if tab.Result() != nil { + t.Fatal("x fecha a faixa") + } + if be.loads < 2 { + t.Error("depois de aplicar a seção relê o estado") + } +} + +func TestUsbTabSemAdminBotaoIndisponivelENuncaAplica(t *testing.T) { + be := newFakeUsb(UsbClean, false) + be.plan.IsAdmin = false + tab := usbTab(t, be) + ukey(tab, "a") + if !tab.asking || !tab.conf.Buttons[1].Disabled || tab.conf.Buttons[1].Reason != "sem administrador" { + t.Fatalf("o botão de confirmar deve ficar indisponível sem administrador: %+v", tab.conf.Buttons) + } + if !strings.Contains(tab.conf.Warn, "nunca eleva sozinho") { + t.Errorf("o aviso deve explicar o administrador: %q", tab.conf.Warn) + } + ukey(tab, "s", "y", "enter", "tab", "enter") + if len(be.applies) != 0 { + t.Fatal("sem administrador nada é aplicado") + } +} + +func TestUsbTabPlanoRecusadoNaoViraConfirmacao(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.plan.OK = false + be.plan.Refusal = "Teclado USB ficaria BLOQUEADO" + be.plan.Text = "RECUSADO: Teclado USB ficaria BLOQUEADO\n" + tab := usbTab(t, be) + ukey(tab, "a") + if tab.asking { + t.Fatal("plano recusado (sem prova) nunca vira confirmação") + } + if !tab.view || !strings.Contains(tab.Status(), "Recusado") || !strings.Contains(tab.Status(), "Nada foi alterado") { + t.Fatalf("status = %q", tab.Status()) + } + ukey(tab, "s", "y", "enter") + if len(be.applies) != 0 { + t.Fatal("recusa: s/y/enter não aplicam") + } +} + +func TestUsbTabTecladoDesmarcadoVaiNoPlanoERecusaPeloBackend(t *testing.T) { + be := newFakeUsb(UsbClean, true) + tab := usbTab(t, be) + ukey(tab, "space", "a") // desmarca o teclado + if len(be.plans) != 1 || be.plans[0][0] != usbKbKey { + t.Fatalf("o teclado desmarcado tem de ir ao backend: %v", be.plans) + } +} + +// Plano de uso único por ID: A (lento) -> Esc -> B -> a resposta tardia de A não vira confirmação nem aplica. +type blockUsb struct { + fakeUsb + started chan struct{} + release chan struct{} + block bool +} + +func (b *blockUsb) Plan(ctx context.Context, ex []string) (UsbPlan, error) { + if b.block { + b.block = false + b.started <- struct{}{} + <-b.release + } + return b.fakeUsb.Plan(ctx, ex) +} + +func usbFirstPlanMsg(cmd tea.Cmd) tea.Msg { + if cmd == nil { + return nil + } + switch m := cmd().(type) { + case tea.BatchMsg: + for _, c := range m { + if r := c(); r != nil { + if _, ok := r.(usbPlanMsg); ok { + return r + } + } + } + return nil + default: + return m + } +} + +func TestUsbTabPlanoPorIDEscDescartaARespostaTardia(t *testing.T) { + be := &blockUsb{fakeUsb: *newFakeUsb(UsbClean, true), started: make(chan struct{}, 1), release: make(chan struct{}), block: true} + tab := NewUsbTab(context.Background(), be, Theme{Mono: true, NoMotion: true}) + ukey(tab, "c") + _, cmd := tab.Update(tea.KeyPressMsg{Code: 'a', Text: "a"}) // A, bloqueado + done := make(chan tea.Msg, 1) + go func() { done <- usbFirstPlanMsg(cmd) }() + <-be.started + ukey(tab, "esc") // cancela a preparação de A + if tab.busy != busyNone { + t.Fatalf("Esc devia cancelar a preparação: busy=%v", tab.busy) + } + ukey(tab, "a") // B, rápido: abre a confirmação com o ID de B + if !tab.asking { + t.Fatal("B devia abrir a confirmação") + } + idB := tab.plan.ID + close(be.release) + if m := <-done; m != nil { + tab.Update(m) // A chega TARDE + } + if tab.plan.ID != idB { + t.Fatalf("a resposta tardia de A trocou o plano exibido: %q != %q", tab.plan.ID, idB) + } + ukey(tab, "s") + if len(be.applies) != 1 || be.applies[0] != idB { + t.Fatalf("só o plano exibido (B=%s) pode ser aplicado: %v", idB, be.applies) + } +} + +func TestUsbTabEscDuranteOPlanoNaoAbreNada(t *testing.T) { + be := &blockUsb{fakeUsb: *newFakeUsb(UsbClean, true), started: make(chan struct{}, 1), release: make(chan struct{}), block: true} + tab := NewUsbTab(context.Background(), be, Theme{Mono: true, NoMotion: true}) + ukey(tab, "c") + _, cmd := tab.Update(tea.KeyPressMsg{Code: 'a', Text: "a"}) + done := make(chan tea.Msg, 1) + go func() { done <- usbFirstPlanMsg(cmd) }() + <-be.started + ukey(tab, "esc") + close(be.release) + if m := <-done; m != nil { + tab.Update(m) + } + if tab.asking || tab.view || len(be.applies) != 0 { + t.Fatalf("a resposta tardia não pode abrir nada (asking=%v view=%v)", tab.asking, tab.view) + } +} + +func TestUsbTabPlanoVelhoDaAvisoENaoMuda(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.applyErr = ErrUsbStalePlan + tab := usbTab(t, be) + ukey(tab, "a", "s") + r := tab.Result() + if r == nil || r.Kind != ResultInfo || !strings.Contains(r.Title, "plano mudou") { + t.Fatalf("faixa = %#v", r) + } +} + +func TestUsbTabFalhaNoMeioDizQueRestaurou(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.applyRes = UsbResult{RestoredNow: true} + be.applyErr = errors.New("falha ao gravar DenyDeviceClasses\\2; o registro foi restaurado na hora") + tab := usbTab(t, be) + ukey(tab, "a", "s") + r := tab.Result() + if r == nil || r.Kind != ResultError || !strings.Contains(strings.Join(r.Lines, " "), "restaurado na hora") { + t.Fatalf("faixa = %#v", r) + } +} + +func TestUsbTabReleituraFalhaDepoisDeAcaoNaoDizNadaFoiAlterado(t *testing.T) { + for _, applyErr := range []error{nil, errors.New("falhou no meio")} { + be := newFakeUsb(UsbClean, true) + be.applyRes = UsbResult{Entries: 8, Deadline: "12:10"} + be.applyErr = applyErr + tab := usbTab(t, be) + be.loadErr = errors.New("reg.exe: acesso negado") // a releitura pós-ação falha + ukey(tab, "a", "s") + out := uview(tab, 80, 24) + if strings.Contains(out, "Nada foi alterado") || !strings.Contains(out, "atualizar a leitura") { + t.Errorf("a tela nega as alterações ou não avisa da releitura (err=%v):\n%s", applyErr, out) + } + } +} + +func TestUsbTabManterTemConfirmacaoPropriaComFocoEmCancelar(t *testing.T) { + be := newFakeUsb(UsbArmed, true) + tab := usbTab(t, be) + if out := uview(tab, 100, 30); !strings.Contains(out, "REVERTE SOZINHO às 12:10") { + t.Errorf("o prazo da reversão tem de aparecer (estático, sem contagem viva):\n%s", out) + } + ukey(tab, "n") + if !tab.asking || tab.conf.Focus != 0 || !strings.Contains(tab.conf.Title, "Manter") { + t.Fatalf("n devia abrir a confirmação de manter com foco em Cancelar: %+v", tab.conf) + } + ukey(tab, "enter") + if len(be.keeps) != 0 { + t.Fatal("Enter em Cancelar não mantém") + } + ukey(tab, "n", "s") + if len(be.keeps) != 1 || be.keeps[0] != be.lastID { + t.Fatalf("keeps = %v", be.keeps) + } + if r := tab.Result(); r == nil || r.Kind != ResultOK || !strings.Contains(r.Title, "mantido") { + t.Fatalf("faixa = %#v", r) + } +} + +func TestUsbTabManterForaDoEstadoArmadoNaoAbreNada(t *testing.T) { + for _, st := range []string{UsbClean, UsbActive, UsbUnknown} { + be := newFakeUsb(st, true) + tab := usbTab(t, be) + ukey(tab, "n") + if tab.asking || len(be.keeps) != 0 { + t.Errorf("%s: n não pode abrir confirmação", st) + } + } +} + +func TestUsbTabDesfazerComConfirmacao(t *testing.T) { + be := newFakeUsb(UsbActive, true) + be.undoRes = UsbResult{Restored: 8} + tab := usbTab(t, be) + ukey(tab, "d") + if !tab.asking || tab.conf.Focus != 0 || !strings.Contains(tab.conf.Title, "Desfazer") { + t.Fatalf("d devia abrir a confirmação com foco em Cancelar: %+v", tab.conf) + } + ukey(tab, "esc") + if len(be.undos) != 0 { + t.Fatal("Esc não desfaz") + } + ukey(tab, "d", "s") + if len(be.undos) != 1 || be.undos[0] != be.lastID { + t.Fatalf("undos = %v", be.undos) + } + if r := tab.Result(); r == nil || r.Kind != ResultOK || !strings.Contains(r.Title, "desfeito") { + t.Fatalf("faixa = %#v", r) + } +} + +func TestUsbTabEstadoOriginalDesconhecidoSoMostraARecuperacao(t *testing.T) { + be := newFakeUsb(UsbUnknown, true) + be.undoPlan = UsbPlan{Text: "ESTADO ORIGINAL DESCONHECIDO\nRecuperação manual: WinRE\n", OK: false, Refusal: "ESTADO ORIGINAL DESCONHECIDO: nada é restaurado às cegas"} + tab := usbTab(t, be) + out := uview(tab, 100, 30) + if !strings.Contains(out, "ESTADO ORIGINAL DESCONHECIDO") || strings.Contains(out, "Nada a desfazer") { + t.Errorf("tela:\n%s", out) + } + ukey(tab, "d") + if tab.asking || !strings.Contains(tab.Status(), "Recusado") { + t.Fatalf("estado desconhecido nunca vira confirmação (asking=%v status=%q)", tab.asking, tab.Status()) + } + ukey(tab, "s", "y", "enter") + if len(be.undos) != 0 { + t.Fatal("estado desconhecido: s/y/enter não restauram") + } + ukey(tab, "p") + if !tab.view || !strings.Contains(tab.plan.Text, "Recuperação manual") { + t.Fatal("p mostra a recuperação manual") + } +} + +func TestUsbTabAplicarComEstadoJaAplicadoAvisa(t *testing.T) { + for _, st := range []string{UsbArmed, UsbActive, UsbStale, UsbUnknown} { + be := newFakeUsb(st, true) + tab := usbTab(t, be) + ukey(tab, "a") + if tab.asking || len(be.plans) != 0 || !strings.Contains(tab.Status(), "Já há modo empresa") { + t.Errorf("%s: asking=%v plans=%d status=%q", st, tab.asking, len(be.plans), tab.Status()) + } + } +} + +func TestUsbTabNadaADesfazerQuandoNuncaAplicado(t *testing.T) { + be := newFakeUsb(UsbClean, true) + tab := usbTab(t, be) + ukey(tab, "d") + if tab.asking || !strings.Contains(tab.Status(), "Nada a desfazer") { + t.Fatalf("status = %q", tab.Status()) + } +} + +func TestUsbTabCapturingSoNaConfirmacaoEAplicacao(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbClean, true)) + if tab.Capturing() { + t.Fatal("na tela principal as teclas globais valem") + } + ukey(tab, "a") + if !tab.Capturing() { + t.Fatal("na confirmação todas as teclas são da seção (q, Tab e números não saem)") + } +} + +func TestUsbTabTextoMaliciosoNeutralizado(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.info.Devices[0].Name = "Teclado\x1b[31m\u202eevil" + be.plan.Text = "Plano\x1b]0;x\x07 mal\n" + tab := usbTab(t, be) + out := tab.View(100, 30) + if strings.ContainsRune(out, 0x202e) || strings.Contains(out, "\x1b]0;") { + t.Fatalf("texto do sistema não foi neutralizado: %q", out) + } + ukey(tab, "p") + out = tab.View(100, 30) + if strings.Contains(out, "\x1b]0;") { + t.Fatalf("plano com OSC: %q", out) + } +} + +// --- vocabulário único de teclas (keys.go) nos estados da seção --- + +func TestUsbTabTeclasNoVocabularioUnico(t *testing.T) { + check := func(state string, hints []KeyHint) { + for _, h := range hints { + r := []rune(h.Key) + if len(r) != 1 || !unicode.IsLower(r[0]) && h.Key != "espaço" { + continue + } + def := act(h.Key) + if def.Label == "" { + t.Errorf("%s: a tecla %q não está na legenda", state, h.Key) + continue + } + ok := baseLabel(h.Label) == def.Label + for _, a := range def.Alt { + ok = ok || baseLabel(h.Label) == a + } + if !ok { + t.Errorf("%s: %q com o rótulo %q; a legenda diz %q (variantes %v)", state, h.Key, baseLabel(h.Label), def.Label, def.Alt) + } + if strings.HasSuffix(h.Label, "…") != def.Confirms { + t.Errorf("%s: %q reticências=%v, legenda diz %v", state, h.Key, strings.HasSuffix(h.Label, "…"), def.Confirms) + } + } + } + for _, st := range []string{UsbClean, UsbArmed, UsbActive, UsbStale, UsbUnknown} { + tab := usbTab(t, newFakeUsb(st, true)) + check(st, tab.Keys()) + ukey(tab, "p") + check(st+"/plano", tab.Keys()) + ukey(tab, "esc") + if st == UsbClean { + ukey(tab, "a") + check(st+"/confirma", tab.Keys()) + } + // a ajuda da seção usa as mesmas letras + for _, d := range tab.HelpKeys() { + if len([]rune(d.Key)) == 1 && d.Key != "" && act(d.Key).Label == "" && !unicode.IsUpper([]rune(d.Key)[0]) { + t.Errorf("%s: a ajuda lista %q fora da legenda", st, d.Key) + } + } + } + if k := act("n"); k.Label != "manter" || !k.Confirms { + t.Errorf("n = %+v", k) + } + // o título de aplicar tem as reticências (abre confirmação) e o de ver plano não + hs := usbTab(t, newFakeUsb(UsbClean, true)).Keys() + var a, p string + for _, h := range hs { + switch h.Key { + case "a": + a = h.Label + case "p": + p = h.Label + } + } + if a != "aplicar…" || p != "ver plano" { + t.Errorf("a=%q p=%q", a, p) + } + hs = usbTab(t, newFakeUsb(UsbArmed, true)).Keys() + if hs[0].Key != "n" || hs[0].Label != "manter…" { + t.Errorf("armado: %v", hs) + } +} + +func TestUsbTabNaoEstaNoTextoDaLegendaSemEstarNaTabela(t *testing.T) { + // "manter" só existe na seção de USB; a tabela documenta o sentido + if !strings.Contains(act("n").Help, "reversão automática") { + t.Error("a ajuda de n deve falar da reversão automática") + } +} + +// --- goldens (80x24, 120x40 e 60x16) --- + +func usbGolden(t *testing.T, name string, tab *UsbTab) { + t.Helper() + for _, sz := range [][2]int{{80, 24}, {120, 40}, {60, 16}} { + m := sized(Options{Version: "v0.1.0", Mono: true, NoMotion: true}, sz[0], sz[1], tab) + golden(t, fmt.Sprintf("usb_%s_%dx%d", name, sz[0], sz[1]), m.render()) + } +} + +func TestGoldenUsbPrincipal(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbClean, true)) + ukey(tab, "down", "space") + usbGolden(t, "principal", tab) +} + +func TestGoldenUsbConfirmacao(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbClean, true)) + ukey(tab, "a") + usbGolden(t, "confirma", tab) +} + +func TestGoldenUsbConfirmacaoSemAdmin(t *testing.T) { + be := newFakeUsb(UsbClean, false) + be.plan.IsAdmin = false + tab := usbTab(t, be) + ukey(tab, "a") + usbGolden(t, "confirma_semadmin", tab) +} + +func TestGoldenUsbPlanoRecusado(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.plan = UsbPlan{Text: "Prova de dispositivos essenciais: RECUSADO, nada será alterado\n NÃO Teclado USB (USB, USB): a classe USB é negada pela política e o dispositivo não está na lista de IDs\nRECUSADO: Teclado USB ficaria BLOQUEADO\n", OK: false, Refusal: "Teclado USB ficaria BLOQUEADO"} + tab := usbTab(t, be) + ukey(tab, "space", "a") + usbGolden(t, "recusado", tab) +} + +func TestGoldenUsbArmado(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbArmed, true)) + usbGolden(t, "armado", tab) +} + +func TestGoldenUsbManterConfirmacao(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbArmed, true)) + ukey(tab, "n") + usbGolden(t, "manter", tab) +} + +func TestGoldenUsbEstadoDesconhecido(t *testing.T) { + tab := usbTab(t, newFakeUsb(UsbUnknown, true)) + usbGolden(t, "desconhecido", tab) +} + +func TestGoldenUsbForaDoWindowsEHome(t *testing.T) { + linux := usbTab(t, &fakeUsb{info: UsbInfo{OS: "linux"}}) + usbGolden(t, "linux", linux) + home := newFakeUsb(UsbClean, true) + home.info.EditionOK, home.info.Edition = false, "home" + usbGolden(t, "home", usbTab(t, home)) +} + +func TestGoldenUsbFaixaAplicado(t *testing.T) { + be := newFakeUsb(UsbClean, true) + be.applyRes = UsbResult{Entries: 8, Deadline: "12:10", BackupPath: `C:\ProgramData\toolkit`} + tab := usbTab(t, be) + be.info.State = UsbArmed // a releitura depois de aplicar mostra o estado armado + ukey(tab, "a", "s") + usbGolden(t, "faixa_aplicado", tab) +} + +// A releitura que falha COM a confirmação aberta deixa a tela sem estado utilizável: s/y nunca aplicam o plano invisível. +func TestUsbTabSemEstadoUtilizavelSENuncaAplica(t *testing.T) { + be := newFakeUsb(UsbClean, true) + tab := usbTab(t, be) + ukey(tab, "a") + if !tab.asking { + t.Fatal("a devia abrir a confirmação") + } + tab.Update(usbLoadedMsg{err: errors.New("reg.exe: acesso negado")}) // a leitura falhou com a confirmação na tela + ukey(tab, "s", "y", "enter") + if len(be.applies) != 0 { + t.Fatal("sem estado utilizável s/y/enter nunca aplicam") + } + if tab.asking { + t.Fatal("a confirmação invisível tem de ser fechada") + } +} + +func TestUsbTabMostraORastroDaReversaoAutomatica(t *testing.T) { + be := newFakeUsb(UsbActive, true) + be.info.RevertNote = "a reversão automática rodou e falhou: um valor gravado pelo toolkit foi alterado por outra origem" + out := uview(usbTab(t, be), 100, 28) + if !strings.Contains(strings.Join(strings.Fields(out), " "), "a reversão automática rodou e falhou") { + t.Fatalf("a TUI não mostra o rastro da reversão:\n%s", out) + } +} diff --git a/internal/usb/apply.go b/internal/usb/apply.go new file mode 100644 index 0000000..7a4e4fd --- /dev/null +++ b/internal/usb/apply.go @@ -0,0 +1,593 @@ +package usb + +import ( + "context" + "errors" + "fmt" + "reflect" + "strings" + "time" + + "github.com/PiluTech/toolkit/internal/textsafe" +) + +// ApplyOptions são os parâmetros do Apply. Excluded são as instâncias desmarcadas (as mesmas do plano mostrado). +type ApplyOptions struct { + Prazo int + Now time.Time + Excluded []string + // ExpectedPlan é o texto do plano que foi MOSTRADO e confirmado (Plan.Format com o mesmo Prazo). Vazio = não confere. O + // Apply recalcula o plano e recusa (ErrPlanChanged) ANTES do backup se ele for diferente: o que é gravado é o que foi mostrado. + ExpectedPlan string +} + +// ApplyResult é o que o Apply fez. Restored=true quando uma falha no meio foi desfeita na hora. +type ApplyResult struct { + Deadline time.Time + Entries int + Restored bool + BackupPath string +} + +// ExeFolderWarning avisa quando o toolkit em execução está numa pasta que usuário comum pode gravar: é a cópia DELE que +// a tarefa de reversão (SYSTEM) executa daqui a minutos. Vazio = pasta de administrador (Program Files, Windows). +func ExeFolderWarning(exePath string) string { + p := strings.ToLower(strings.ReplaceAll(exePath, "/", `\`)) + for _, ok := range []string{`c:\program files\`, `c:\program files (x86)\`, `c:\windows\`} { + if strings.HasPrefix(p, ok) { + return "" + } + } + return "o toolkit foi iniciado de " + textsafe.Line(exePath) + ", uma pasta que um usuário comum pode alterar: a tarefa de reversão (SYSTEM) executa uma CÓPIA dele. Rode de Program Files ou de uma pasta só de administradores." +} + +func taskExe() string { return ProtectedDir + `\` + RevertBinary } + +var systemUsers = []string{"SYSTEM", "S-1-5-18", `NT AUTHORITY\SYSTEM`} + +// verifyTask confere a tarefa lida contra o que o toolkit armou: existe, habilitada, o comando EXATO, como SYSTEM e com o +// próximo disparo dentro do prazo (no futuro e até o prazo mais uma folga). +func verifyTask(ti TaskInfo, exe string, now time.Time, prazo int) error { + bad := func(format string, a ...any) error { + return fmt.Errorf("%w: %s", ErrTaskUnexpected, fmt.Sprintf(format, a...)) + } + switch { + case !ti.Exists: + return bad("a tarefa não existe") + case !ti.Enabled: + return bad("a tarefa está desabilitada") + case !strings.EqualFold(ti.Exe, exe): + return bad("o programa da tarefa não é o esperado") + case ti.Args != RevertArgs: + return bad("o comando da tarefa não é o esperado") + } + sys := false + for _, u := range systemUsers { + if strings.EqualFold(ti.User, u) { + sys = true + } + } + if !sys { + return bad("a tarefa não roda como SYSTEM") + } + if ti.Next.IsZero() || !ti.Next.After(now) { + return bad("o próximo disparo não é no futuro") + } + if ti.Next.After(now.Add(time.Duration(prazo)*time.Minute + 2*time.Minute)) { + return bad("o próximo disparo passa do prazo") + } + return nil +} + +// Apply aplica a política, nesta ORDEM obrigatória: prazo -> edição -> administrador -> (sem backup nem tarefa anteriores) -> +// plano com a PROVA dos essenciais -> pasta protegida e backup (relido e conferido) -> cópia do binário -> tarefa de +// reversão criada e CONFERIDA -> só então as chaves. Falha em qualquer passo antes da primeira chave = nenhuma alteração +// (a tarefa e o backup deste Apply são removidos). Falha no meio das chaves tenta restaurar na hora; se não conseguir, a +// tarefa e o backup ficam como reserva. A confirmação do usuário é de quem chama; o Apply nunca pergunta e nunca eleva. +func Apply(ctx context.Context, sys System, st Store, o ApplyOptions) (*ApplyResult, error) { + res := &ApplyResult{} + if o.Prazo < PrazoMinimo || o.Prazo > PrazoMaximo { + return res, fmt.Errorf("%w: use de %d a %d minutos", ErrPrazo, PrazoMinimo, PrazoMaximo) + } + ed, err := sys.Edition(ctx) + if err != nil { + return res, fmt.Errorf("não deu para descobrir a edição do Windows: %w", err) + } + if !EditionSupported(ed) { + return res, fmt.Errorf("%w (%s)", ErrEdition, textsafe.Line(ed)) + } + if !sys.IsAdmin(ctx) { + return res, ErrNeedsAdmin + } + if sn, lerr := st.Load(); sn != nil || lerr != nil { + return res, fmt.Errorf("%w: já existe um backup de uma aplicação anterior; veja `toolkit usb` e desfaça antes de aplicar de novo", ErrExistingPolicy) + } + if ti, terr := sys.ReadTask(ctx); terr != nil { + return res, fmt.Errorf("não deu para ler a tarefa de reversão: %w", terr) + } else if ti.Exists { + return res, fmt.Errorf("%w: já existe a tarefa de reversão do toolkit; veja `toolkit usb`", ErrExistingPolicy) + } + plan, err := BuildPlan(ctx, sys, o.Excluded) + if err != nil { + return res, err + } + if !plan.OK() { + return res, plan.Err() + } + plan.Prazo = o.Prazo + if o.ExpectedPlan != "" && plan.Format() != o.ExpectedPlan { + return res, ErrPlanChanged + } + tr, err := sys.ReadTree(ctx) + if err != nil { + return res, fmt.Errorf("não deu para ler a chave Restrictions: %w", err) + } + entries := plan.Policy.Entries() + sn := &Snapshot{Version: 1, Created: o.Now.UTC(), KeyExisted: tr.KeyExists, SubkeysExisted: []string{}, TaskExe: taskExe(), Prazo: o.Prazo} + for _, e := range entries { + if err := checkWrite(e.Path, e.Value); err != nil { + return res, err + } + sn.Targets = append(sn.Targets, Target{Path: e.Path, Existed: false, Want: e.Value}) + } + + if rl, ok := st.(RevertLogger); ok { + _ = rl.SaveRevertResult("") // rastro de uma reversão anterior não vale para esta aplicação + } + + // (b) backup protegido, relido e conferido + abort := func(cause error) (*ApplyResult, error) { + _ = sys.DeleteTask(ctx) + _ = st.Remove() + return res, cause + } + if err := sys.ProtectDir(ctx, st.Folder()); err != nil { + return res, fmt.Errorf("não deu para proteger a pasta do backup (nada foi alterado): %w", err) + } + if tr.KeyExists { + if err := sys.ExportReg(ctx, st.RegPath()); err != nil { + return abort(fmt.Errorf("não deu para exportar o .reg de segurança (nada foi alterado): %w", err)) + } + h, err := st.FileSHA256(st.RegPath()) + if err != nil { + return abort(fmt.Errorf("não deu para conferir o .reg exportado (nada foi alterado): %w", err)) + } + sn.RegFile, sn.RegSHA256 = RegFile, h + } + if err := st.Save(sn); err != nil { + return abort(fmt.Errorf("não deu para gravar o backup (nada foi alterado): %w", err)) + } + back, err := st.Load() + if err != nil { + return abort(fmt.Errorf("o backup relido é inválido (nada foi alterado): %w", err)) + } + if back == nil || !reflect.DeepEqual(back, normalize(sn)) { + return abort(errors.New("o backup relido não confere com o gravado (nada foi alterado)")) + } + res.BackupPath = st.Folder() + + // (c) cópia do binário e tarefa de reversão, conferida ANTES da primeira chave + sb, err := sys.StageBinary(ctx, st.Folder()) + if err != nil { + return abort(fmt.Errorf("não deu para copiar o toolkit para a pasta protegida (nada foi alterado): %w", err)) + } + if !strings.EqualFold(sb.Path, sn.TaskExe) || sb.SourceSHA == "" || sb.SourceSHA != sb.CopySHA { + return abort(fmt.Errorf("a cópia do toolkit na pasta protegida não confere com o original (nada foi alterado)")) + } + if err := sys.ArmTask(ctx, TaskSpec{Exe: sb.Path, Args: RevertArgs, Minutes: o.Prazo}); err != nil { + return abort(fmt.Errorf("não deu para criar a tarefa de reversão (nada foi alterado): %w", err)) + } + ti, err := sys.ReadTask(ctx) + if err != nil { + return abort(fmt.Errorf("não deu para conferir a tarefa de reversão (nada foi alterado): %w", err)) + } + if err := verifyTask(ti, sb.Path, o.Now, o.Prazo); err != nil { + return abort(fmt.Errorf("tarefa de reversão não conferida (nada foi alterado): %w", err)) + } + res.Deadline = ti.Next + + // (d) a árvore é relida logo antes da primeira escrita: a preparação leva segundos (vários powershell.exe) e uma + // GPO/MDM pode ter gravado na janela; o snapshot diz que o valor não existia e o desfazer o apagaria. + if tr2, rerr := sys.ReadTree(ctx); rerr != nil { + return abort(fmt.Errorf("não deu para reler a chave antes de gravar (nada foi alterado): %w", rerr)) + } else if !reflect.DeepEqual(tr2, tr) { + return abort(fmt.Errorf("%w: a chave Restrictions mudou durante a preparação (nada foi alterado)", ErrExistingPolicy)) + } + + // (e) as chaves, na ordem segura + for _, e := range entries { + if err := sys.RegWrite(ctx, e.Path, e.Value); err != nil { + return res, failMidway(ctx, sys, st, res, fmt.Errorf("falha ao gravar %s: %w", e.Path, err)) + } + } + got, err := sys.ReadTree(ctx) + if err != nil { + return res, failMidway(ctx, sys, st, res, fmt.Errorf("não deu para reler a chave depois de gravar: %w", err)) + } + for _, e := range entries { + if v, ok := got.Entries[e.Path]; !ok || v != e.Value { + return res, failMidway(ctx, sys, st, res, fmt.Errorf("a releitura não encontrou %s como gravado", e.Path)) + } + } + res.Entries = len(entries) + return res, nil +} + +// normalize devolve o snapshot como ele volta do JSON (nil vs vazio, tempo em UTC) para a comparação do relido. +func normalize(sn *Snapshot) *Snapshot { + cp := *sn + cp.Created = sn.Created.UTC() + if cp.SubkeysExisted == nil { + cp.SubkeysExisted = []string{} + } + return &cp +} + +// failMidway tenta restaurar na hora depois de uma falha no meio das chaves. Se restaurar, a tarefa e o backup saem +// (Undo); se não, ficam como reserva. +func failMidway(ctx context.Context, sys System, st Store, res *ApplyResult, cause error) error { + if _, err := Undo(ctx, sys, st); err != nil { + return fmt.Errorf("%w; a restauração imediata também falhou (%w): a tarefa de reversão e o backup ficam como reserva", cause, err) + } + res.Restored = true + return fmt.Errorf("%w; o registro foi restaurado na hora", cause) +} + +// --- estado --- + +// StatusKind é o estado do modo empresa nesta máquina. +type StatusKind int + +// Estados. +const ( + StatusClean StatusKind = iota // nunca houve aplicação + StatusArmed // aplicado e aguardando confirmação (a tarefa de reversão está armada) + StatusActive // aplicado e confirmado + StatusStale // há backup mas nada aplicado nem tarefa (sobra de uma falha) + StatusUnknown // houve aplicação e o snapshot sumiu ou é inválido: ESTADO ORIGINAL DESCONHECIDO +) + +// Status é o estado lido (só leitura). +type Status struct { + Kind StatusKind + Snapshot *Snapshot + Task TaskInfo + Tree RegTree + Reason string + // RevertNote é o resultado da última execução da reversão automática ("a reversão automática rodou e falhou: ..."); + // vazio = ela nunca rodou (ou o Apply seguinte apagou o rastro). + RevertNote string +} + +// ReadStatus lê o registro, a tarefa e o backup. Falha de leitura é ERRO (nunca vira "limpo"). +func ReadStatus(ctx context.Context, sys System, st Store) (*Status, error) { + tr, err := sys.ReadTree(ctx) + if err != nil { + return nil, fmt.Errorf("não deu para ler a chave Restrictions: %w", err) + } + ti, err := sys.ReadTask(ctx) + if err != nil { + return nil, fmt.Errorf("não deu para ler a tarefa de reversão: %w", err) + } + s := &Status{Task: ti, Tree: tr} + if rl, ok := st.(RevertLogger); ok { + s.RevertNote = rl.LoadRevertResult() + } + sn, lerr := st.Load() + switch { + case lerr != nil && errors.Is(lerr, ErrBackupInvalid): + s.Kind, s.Reason = StatusUnknown, "o backup está corrompido, adulterado ou inválido: "+textsafe.Line(lerr.Error()) + case lerr != nil: + return nil, fmt.Errorf("não deu para ler o backup: %w", lerr) + case sn == nil && (ti.Exists || namespacePresent(tr)): + s.Kind, s.Reason = StatusUnknown, "o backup não existe, mas há sinais de aplicação (a tarefa de reversão existe ou há chaves da lista do toolkit)" + case sn == nil: + s.Kind = StatusClean + case ti.Exists: + s.Kind, s.Snapshot = StatusArmed, sn + case namespacePresent(tr): + s.Kind, s.Snapshot = StatusActive, sn + default: + s.Kind, s.Snapshot = StatusStale, sn + } + return s, nil +} + +// --- desfazer --- + +// UndoKind é o que o desfazer faria. +type UndoKind int + +// Tipos de desfazer. +const ( + UndoNothing UndoKind = iota // nunca houve aplicação + UndoRestore // restaura o snapshot validado + UndoUnknown // ESTADO ORIGINAL DESCONHECIDO: nada é escrito + UndoConflict // um valor gravado pelo toolkit foi alterado por fora: nada é escrito +) + +// UndoPlan é o plano do desfazer (só leitura). +type UndoPlan struct { + Kind UndoKind + Reason string + Actions []string // texto: o que será restaurado + Preserved int // valores de outras origens que ficam como estão + Status *Status + actions []undoAction +} + +type undoAction struct { + path string + del bool + value RegValue + target Target +} + +// BuildUndo calcula o desfazer sem escrever nada. Snapshot ausente/corrompido depois de uma aplicação = UndoUnknown; +// "nada a desfazer" só quando nunca houve aplicação. +func BuildUndo(ctx context.Context, sys System, st Store) (*UndoPlan, error) { + s, err := ReadStatus(ctx, sys, st) + if err != nil { + return nil, err + } + p := &UndoPlan{Status: s} + switch s.Kind { + case StatusClean: + p.Kind = UndoNothing + return p, nil + case StatusUnknown: + p.Kind, p.Reason = UndoUnknown, s.Reason + return p, nil + } + sn := s.Snapshot + var conflicts []string + for i := len(sn.Targets) - 1; i >= 0; i-- { // ordem inversa da escrita: a negação sai primeiro + t := sn.Targets[i] + cur, exists := s.Tree.Entries[t.Path] + switch { + case exists && cur == t.Want: + if t.Existed { + p.actions = append(p.actions, undoAction{path: t.Path, value: t.Orig, target: t}) + p.Actions = append(p.Actions, fmt.Sprintf("%s: devolve o valor original", t.Path)) + } else { + p.actions = append(p.actions, undoAction{path: t.Path, del: true, target: t}) + p.Actions = append(p.Actions, fmt.Sprintf("%s: remove (não existia antes)", t.Path)) + } + case !exists && t.Existed: + p.actions = append(p.actions, undoAction{path: t.Path, value: t.Orig, target: t}) + p.Actions = append(p.Actions, fmt.Sprintf("%s: devolve o valor original (foi apagado)", t.Path)) + case !exists, exists && t.Existed && cur == t.Orig: + // já está como antes + default: + conflicts = append(conflicts, t.Path) + } + } + inSnapshot := map[string]bool{} + for _, t := range sn.Targets { + inSnapshot[t.Path] = true + } + for k := range s.Tree.Entries { + if !inSnapshot[k] { + p.Preserved++ + } + } + if len(conflicts) > 0 { + p.Kind = UndoConflict + p.Reason = fmt.Sprintf("o valor de %s foi alterado por outra origem depois da aplicação (GPO, MDM ou outra ferramenta); o toolkit não sobrescreve", strings.Join(conflicts, ", ")) + return p, nil + } + p.Kind = UndoRestore + return p, nil +} + +// Format escreve o plano do desfazer em texto. +func (p *UndoPlan) Format() string { + var b strings.Builder + w := func(format string, a ...any) { fmt.Fprintf(&b, format+"\n", a...) } + switch p.Kind { + case UndoNothing: + w("Nada a desfazer: o toolkit nunca aplicou o modo empresa de USB nesta máquina.") + case UndoUnknown: + w("ESTADO ORIGINAL DESCONHECIDO") + w("%s.", textsafe.Line(p.Reason)) + w("Nada será escrito no registro: restaurar às cegas poderia apagar uma política que não é do toolkit. O arquivo de backup (se existir) é mantido para análise.") + w("") + w("Recuperação manual (por uma conta de administrador):") + for _, s := range RecoverySteps { + w(" %s", s) + } + w(" Antes de apagar qualquer chave, confirmar que não havia política anterior com quem administra a máquina (por exemplo, GPO de domínio). Sem o .reg íntegro, o toolkit não tem como saber o estado original.") + case UndoConflict: + w("Não dá para restaurar: %s.", textsafe.Line(p.Reason)) + w("Nada será escrito. Confira com quem administra a máquina.") + case UndoRestore: + w("O que será restaurado (snapshot validado; só a lista fechada de valores do toolkit):") + for _, a := range p.Actions { + w(" - %s", a) + } + if len(p.Actions) == 0 { + w(" (nada a mudar no registro: tudo já está como antes; só o backup e a tarefa de reversão saem)") + } + if p.Preserved > 0 { + w("Preservados (de outras origens, não são do toolkit): %d valor(es).", p.Preserved) + } + w("A chave Restrictions só é removida se estiver vazia e o snapshot registrar que ela não existia.") + } + return b.String() +} + +// UndoResult é o que o Undo fez. +type UndoResult struct { + Nothing bool + Restored int +} + +// Undo restaura EXATAMENTE o snapshot validado (o mesmo caminho do `usb desfazer` e da tarefa de reversão). Nunca apaga a +// chave Restrictions às cegas; só remove o que o toolkit criou. Estado original desconhecido ou conflito = erro, sem escrever. +// Exige administrador (conferido antes de qualquer escrita). +func Undo(ctx context.Context, sys System, st Store) (*UndoResult, error) { + return undo(ctx, sys, st, true) +} + +// Revert é o desfazer que a TAREFA de reversão executa (como SYSTEM, sem terminal): o mesmo caminho do Undo, mas SEM a +// pergunta IsAdmin (outro powershell.exe que pode falhar no contexto SYSTEM e devolveria ErrNeedsAdmin sem escrever +// nada; a própria tarefa já prova o SYSTEM, e sem direito o reg.exe falha sozinho). O resultado (sucesso ou erro) é +// gravado na pasta protegida: `toolkit usb` e a TUI mostram "a reversão rodou e falhou: ...". +func Revert(ctx context.Context, sys System, st Store) (*UndoResult, error) { + res, err := undo(ctx, sys, st, false) + note := "" + switch { + case err != nil: + note = "a reversão automática rodou e falhou: " + textsafe.Line(err.Error()) + case res.Nothing: + note = "a reversão automática rodou: nada a restaurar" + default: + note = fmt.Sprintf("a reversão automática rodou e restaurou %d valor(es)", res.Restored) + } + if rl, ok := st.(RevertLogger); ok { + _ = rl.SaveRevertResult(note) + } + return res, err +} + +func undo(ctx context.Context, sys System, st Store, needAdmin bool) (*UndoResult, error) { + p, err := BuildUndo(ctx, sys, st) + if err != nil { + return nil, err + } + switch p.Kind { + case UndoNothing: + return &UndoResult{Nothing: true}, nil + case UndoUnknown: + return nil, fmt.Errorf("%w: %s", ErrOriginalUnknown, textsafe.Line(p.Reason)) + case UndoConflict: + return nil, fmt.Errorf("%w: %s", ErrConflict, textsafe.Line(p.Reason)) + } + if needAdmin && !sys.IsAdmin(ctx) { + return nil, ErrNeedsAdmin + } + sn := p.Status.Snapshot + res := &UndoResult{} + for _, a := range p.actions { + var err error + if a.del { + err = sys.RegDelete(ctx, a.path) + } else { + err = checkRestore(a.path, a.value) + if err == nil { + err = sys.RegWrite(ctx, a.path, a.value) + } + } + if err != nil { + return res, fmt.Errorf("falha ao restaurar %s: %w (o backup e a tarefa de reversão ficam)", a.path, err) + } + res.Restored++ + } + // subchaves e chave que o toolkit criou: só depois de conferir que ficaram vazias + for _, sub := range []string{nameDeny, nameAllow} { + tr, err := sys.ReadTree(ctx) + if err != nil { + return res, fmt.Errorf("não deu para reler a chave: %w", err) + } + if hasString(tr.Subkeys, sub) && !hasString(sn.SubkeysExisted, sub) && !hasEntriesUnder(tr, sub) { + if err := sys.KeyDelete(ctx, sub); err != nil { + return res, fmt.Errorf("falha ao remover a subchave %s: %w", sub, err) + } + } + } + tr, err := sys.ReadTree(ctx) + if err != nil { + return res, fmt.Errorf("não deu para reler a chave: %w", err) + } + if tr.KeyExists && !sn.KeyExisted && len(tr.Entries) == 0 && len(tr.Subkeys) == 0 { + if err := sys.KeyDelete(ctx, ""); err != nil { + return res, fmt.Errorf("falha ao remover a chave Restrictions: %w", err) + } + } + // conferência final: cada alvo voltou ao original + tr, err = sys.ReadTree(ctx) + if err != nil { + return res, fmt.Errorf("não deu para reler a chave: %w", err) + } + for _, t := range sn.Targets { + cur, exists := tr.Entries[t.Path] + if (t.Existed && (!exists || cur != t.Orig)) || (!t.Existed && exists) { + return res, fmt.Errorf("depois de restaurar, %s não voltou ao original (o backup e a tarefa ficam)", t.Path) + } + } + if ti, err := sys.ReadTask(ctx); err != nil { + return res, fmt.Errorf("não deu para ler a tarefa de reversão: %w", err) + } else if ti.Exists { + if err := sys.DeleteTask(ctx); err != nil { + return res, fmt.Errorf("o registro foi restaurado, mas não deu para remover a tarefa de reversão: %w", err) + } + } + if err := st.Remove(); err != nil { + return res, fmt.Errorf("o registro foi restaurado, mas não deu para remover o backup: %w", err) + } + return res, nil +} + +func checkRestore(path string, v RegValue) error { + if err := checkRel(path); err != nil { + return err + } + return checkOrigText(v) +} + +func hasString(l []string, s string) bool { + for _, x := range l { + if x == s { + return true + } + } + return false +} + +func hasEntriesUnder(tr RegTree, sub string) bool { + for k := range tr.Entries { + if strings.HasPrefix(k, sub+`\`) { + return true + } + } + return false +} + +// Confirm cancela a reversão automática (remove a tarefa) e mantém a política e o backup. Só remove a tarefa do toolkit, +// depois de conferir que ela é exatamente a esperada. Sem snapshot válido recusa (cancelar a reversão tornaria o desfazer +// impossível). Exige administrador. +func Confirm(ctx context.Context, sys System, st Store) error { + s, err := ReadStatus(ctx, sys, st) + if err != nil { + return err + } + switch s.Kind { + case StatusUnknown: + return fmt.Errorf("%w: %s; não dá para confirmar", ErrOriginalUnknown, textsafe.Line(s.Reason)) + case StatusArmed: + default: + return ErrNothingToConfirm + } + if !strings.EqualFold(s.Task.Exe, s.Snapshot.TaskExe) || s.Task.Args != RevertArgs { + return fmt.Errorf("%w: o programa ou o comando não conferem; nada foi removido", ErrTaskUnexpected) + } + if !sys.IsAdmin(ctx) { + return ErrNeedsAdmin + } + if err := sys.DeleteTask(ctx); err != nil { + return fmt.Errorf("não deu para remover a tarefa de reversão: %w", err) + } + if ti, err := sys.ReadTask(ctx); err != nil || ti.Exists { + return fmt.Errorf("a tarefa de reversão continua existindo depois de removida") + } + // remover a tarefa não para uma execução que já começou: confere que a política AINDA está aplicada antes de dizer + // "confirmado" + after, err := ReadStatus(ctx, sys, st) + if err != nil { + return fmt.Errorf("a tarefa foi removida, mas não deu para conferir a política: %w", err) + } + if after.Kind != StatusActive { + return fmt.Errorf("a tarefa foi removida, mas a política já não está aplicada (a reversão automática estava rodando): veja `toolkit usb`") + } + return nil +} diff --git a/internal/usb/apply_test.go b/internal/usb/apply_test.go new file mode 100644 index 0000000..6c8082c --- /dev/null +++ b/internal/usb/apply_test.go @@ -0,0 +1,408 @@ +package usb + +import ( + "context" + "errors" + "slices" + "strings" + "testing" + "time" +) + +func TestAplicarOrdemObrigatoria(t *testing.T) { + f := newFake(t) + st := newSpy(f) + // no instante da PRIMEIRA chave, o backup já existe e a tarefa já está armada E conferida + var firstWriteChecked bool + f.hook = func(op string) { + if !strings.HasPrefix(op, "reg-write:") || firstWriteChecked { + return + } + firstWriteChecked = true + if sn, err := st.Load(); err != nil || sn == nil { + t.Errorf("a primeira chave foi escrita sem backup válido (%v)", err) + } + if !f.task.Exists || !f.task.Enabled { + t.Error("a primeira chave foi escrita sem a tarefa de reversão armada") + } + } + res := mustApply(t, f, st) + if !firstWriteChecked { + t.Fatal("nenhuma chave foi escrita") + } + order := []string{"protect-dir", "backup-save", "stage-binary", "task-arm:10:" + RevertArgs, "reg-write:AllowDenyLayered"} + last := -1 + for _, op := range order { + i := f.first(op) + if i < 0 || i <= last { + t.Fatalf("ordem errada em %q (índice %d, anterior %d): %v", op, i, last, f.log) + } + last = i + } + if f.first("reg-write:DenyDeviceClasses") < f.first("reg-write:AllowDeviceIDs") { + t.Fatalf("a negação foi gravada antes da liberação: %v", f.log) + } + if !res.Deadline.Equal(t0.Add(10 * time.Minute)) { + t.Fatalf("prazo = %v", res.Deadline) + } + if !f.tree.KeyExists || f.tree.Entries["AllowDenyLayered"].DWORD != 1 { + t.Fatalf("política não gravada: %v", treeKeys(f.tree)) + } +} + +func TestAplicarFalhaAntesDaPrimeiraChaveNaoEscreveNada(t *testing.T) { + type tc struct { + name string + setup func(f *fakeSys, st *spyStore) + } + cases := []tc{ + {"leitura do PnP falha", func(f *fakeSys, _ *spyStore) { f.devsErr = errors.New("powershell falhou") }}, + {"arvore incompleta", func(f *fakeSys, _ *spyStore) { f.devs = f.devs[1:] }}, + {"teclado desmarcado", func(*fakeSys, *spyStore) {}}, // tratado abaixo via Excluded + {"pasta protegida falha", func(f *fakeSys, _ *spyStore) { f.failOn = "protect-dir" }}, + {"backup falha", func(_ *fakeSys, s *spyStore) { s.failSav = true }}, + {"copia do binario falha", func(f *fakeSys, _ *spyStore) { f.failOn = "stage-binary" }}, + {"hash da copia diverge", func(f *fakeSys, _ *spyStore) { f.staged.CopySHA = strings.Repeat("b", 64) }}, + {"armar a tarefa falha", func(f *fakeSys, _ *spyStore) { f.failOn = "task-arm" }}, + {"tarefa desabilitada", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.Enabled = false } }}, + {"comando da tarefa diferente", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.Args = "usb desfazer --yes" } }}, + {"binario da tarefa diferente", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.Exe = `C:\Users\Public\x.exe` } }}, + {"tarefa nao e do SYSTEM", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.User = "BUILTIN\\Users" } }}, + {"proximo disparo no passado", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.Next = t0.Add(-time.Minute) } }}, + {"proximo disparo zerado", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.Next = time.Time{} } }}, + {"proximo disparo alem do prazo", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { ti.Next = t0.Add(3 * time.Hour) } }}, + {"tarefa some apos armar", func(f *fakeSys, _ *spyStore) { f.armSkew = func(ti *TaskInfo) { *ti = TaskInfo{} } }}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + f := newFake(t) + st := newSpy(f) + c.setup(f, st) + opts := applyOpts(f) + if c.name == "teclado desmarcado" { + opts.Excluded = []string{`USB\VID_FFFF&PID_0001\6&9999&0&1`} + } + _, err := Apply(context.Background(), f, st, opts) + if err == nil { + t.Fatal("Apply devia falhar") + } + if n := f.writes(); n != 0 { + t.Fatalf("ZERO alterações no registro esperadas, houve %d: %v", n, f.log) + } + if f.task.Exists { + t.Error("a tarefa criada foi deixada para trás (zero alterações inclui a tarefa)") + } + if sn, _ := st.Load(); sn != nil { + t.Error("o backup deste Apply foi deixado para trás") + } + }) + } +} + +func TestAplicarSemProvaDizOMotivo(t *testing.T) { + f := newFake(t) + opts := applyOpts(f) + opts.Excluded = []string{`USB\VID_FFFF&PID_0001\6&9999&0&1`} + _, err := Apply(context.Background(), f, newSpy(f), opts) + if !errors.Is(err, ErrNoProof) { + t.Fatalf("err = %v, queria ErrNoProof", err) + } + if !strings.Contains(err.Error(), "Teclado") { + t.Fatalf("a mensagem não diz qual dispositivo: %v", err) + } +} + +func TestAplicarSemAdminRecusaAntesDeTudo(t *testing.T) { + f := newFake(t) + f.admin = false + _, err := Apply(context.Background(), f, newSpy(f), applyOpts(f)) + if !errors.Is(err, ErrNeedsAdmin) { + t.Fatalf("err = %v", err) + } + if len(f.log) != 0 || f.protectCalls != 0 { + t.Fatalf("nada podia ser tentado sem administrador: %v", f.log) + } +} + +func TestAplicarEdicoes(t *testing.T) { + for ed, ok := range map[string]bool{EditionPro: true, EditionEnterprise: true, EditionEducation: true, EditionHome: false, EditionOther: false, "": false} { + f := newFake(t) + f.edition = ed + _, err := Apply(context.Background(), f, newSpy(f), applyOpts(f)) + if ok && err != nil { + t.Errorf("%q deveria aplicar: %v", ed, err) + } + if !ok { + if !errors.Is(err, ErrEdition) { + t.Errorf("%q: err = %v, queria ErrEdition", ed, err) + } + if len(f.log) != 0 { + t.Errorf("%q: mudou algo antes de recusar: %v", ed, f.log) + } + } + } +} + +func TestAplicarPrazo(t *testing.T) { + for p, ok := range map[int]bool{-1: false, 0: false, 1: false, 2: true, 10: true, 60: true, 61: false} { + f := newFake(t) + opts := applyOpts(f) + opts.Prazo = p + _, err := Apply(context.Background(), f, newSpy(f), opts) + if ok != (err == nil) { + t.Errorf("prazo %d: err = %v", p, err) + } + if !ok && (!errors.Is(err, ErrPrazo) || len(f.log) != 0) { + t.Errorf("prazo %d: %v / %v", p, err, f.log) + } + } +} + +func TestAplicarRecusaPoliticaExistente(t *testing.T) { + cases := map[string]func(f *fakeSys){ + "valor de outra origem": func(f *fakeSys) { + f.tree = RegTree{KeyExists: true, Entries: map[string]RegValue{"DenyUnspecified": DWORD(1)}} + }, + "lista de IDs de outra origem": func(f *fakeSys) { + f.tree = RegTree{KeyExists: true, Subkeys: []string{"AllowDeviceIDs"}, Entries: map[string]RegValue{`AllowDeviceIDs\1`: String(`USB\VID_AAAA&PID_0001`)}} + }, + "colide com valor do toolkit": func(f *fakeSys) { + f.tree = RegTree{KeyExists: true, Entries: map[string]RegValue{"AllowDenyLayered": DWORD(0)}} + }, + "subchave vazia de outra origem": func(f *fakeSys) { + f.tree = RegTree{KeyExists: true, Subkeys: []string{"DenyDeviceIDs"}, Entries: map[string]RegValue{}} + }, + } + for name, setup := range cases { + f := newFake(t) + setup(f) + _, err := Apply(context.Background(), f, newSpy(f), applyOpts(f)) + if !errors.Is(err, ErrExistingPolicy) { + t.Errorf("%s: err = %v, queria ErrExistingPolicy", name, err) + } + if f.writes() != 0 || f.task.Exists { + t.Errorf("%s: mudou algo: %v", name, f.log) + } + } +} + +func TestAplicarAceitaChaveRestrictionsVazia(t *testing.T) { + f := newFake(t) + f.tree = RegTree{KeyExists: true, Entries: map[string]RegValue{}} + st := newSpy(f) + mustApply(t, f, st) + sn, _ := st.Load() + if sn == nil || !sn.KeyExisted { + t.Fatalf("o snapshot tem de registrar que a chave JÁ existia (vazia): %#v", sn) + } + if f.first("export-reg") < 0 { + t.Error("com a chave existente, o .reg de segurança tem de ser exportado") + } + if sn.RegSHA256 == "" { + t.Error("o hash do .reg não foi gravado") + } +} + +func TestAplicarDuasVezesRecusa(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + n := len(f.log) + _, err := Apply(context.Background(), f, st, applyOpts(f)) + if !errors.Is(err, ErrExistingPolicy) { + t.Fatalf("segunda aplicação: %v", err) + } + if len(f.log) != n { + t.Fatalf("a segunda aplicação mexeu em algo: %v", f.log[n:]) + } +} + +func TestAplicarFalhaNoMeioRestauraTudoELimpa(t *testing.T) { + f := newFake(t) + st := newSpy(f) + f.failOn = "reg-write:DenyDeviceClasses\\2" + res, err := Apply(context.Background(), f, st, applyOpts(f)) + if err == nil { + t.Fatal("devia falhar") + } + if res == nil || !res.Restored { + t.Fatalf("o Apply devia tentar a restauração imediata: %#v", res) + } + if len(f.tree.Entries) != 0 || f.tree.KeyExists || len(f.tree.Subkeys) != 0 { + t.Fatalf("a restauração imediata não devolveu o registro ao original: %v %v", treeKeys(f.tree), f.tree.Subkeys) + } + if f.task.Exists { + t.Error("com o registro restaurado a tarefa não precisa ficar") + } + if sn, _ := st.Load(); sn != nil { + t.Error("o backup deste Apply não deveria ficar com o registro já restaurado") + } +} + +func TestAplicarFalhaNoMeioSeARestauracaoFalhaTarefaEBackupFicamDeReserva(t *testing.T) { + f := newFake(t) + st := newSpy(f) + f.failOn = "reg-write:DenyDeviceClasses\\2" + f.failAfter = "reg-delete:" // a restauração imediata também falha + res, err := Apply(context.Background(), f, st, applyOpts(f)) + if err == nil || res == nil || res.Restored { + t.Fatalf("res=%#v err=%v", res, err) + } + if !f.task.Exists { + t.Error("a tarefa de reversão tem de ficar armada como reserva") + } + if sn, _ := st.Load(); sn == nil { + t.Error("o backup tem de ficar: é o que a reserva restaura") + } +} + +func TestAplicarReleituraPosAcaoDetectaEscritaPerdida(t *testing.T) { + f := newFake(t) + f.dropWrite = "AllowDenyLayered" // o reg.exe "funcionou" mas o valor não ficou + res, err := Apply(context.Background(), f, newSpy(f), applyOpts(f)) + if err == nil { + t.Fatal("a releitura devia notar que a camada não foi gravada") + } + if res == nil || !res.Restored { + t.Fatalf("devia restaurar: %#v", res) + } + if len(f.tree.Entries) != 0 { + t.Fatalf("sobrou: %v", treeKeys(f.tree)) + } +} + +func TestPlanoDeterministicoEListaOsDispositivos(t *testing.T) { + f := newFake(t) + p1, err := BuildPlan(context.Background(), f, nil) + if err != nil { + t.Fatal(err) + } + p2, _ := BuildPlan(context.Background(), f, nil) + if p1.Format() != p2.Format() { + t.Fatal("mesma entrada, planos diferentes") + } + txt := p1.Format() + for _, want := range []string{"Teclado USB composto", "FFFF:0001", "Pendrive USB", "FFFF:0003", "conectado agora", "EXPERIMENTAL", "reduz o risco, não o elimina", "Teclado PS/2 padrão", "Disco NVMe"} { + if !strings.Contains(txt, want) { + t.Errorf("plano sem %q:\n%s", want, txt) + } + } + if !p1.OK() { + t.Fatalf("plano deveria estar OK: %v", p1.Refusals) + } + if f.writes() != 0 || len(f.log) != 0 { + t.Fatalf("o plano só lê: %v", f.log) + } +} + +func TestPlanoSemAdminFunciona(t *testing.T) { + f := newFake(t) + f.admin = false + p, err := BuildPlan(context.Background(), f, nil) + if err != nil || !p.OK() { + t.Fatalf("plano sem admin: %v %v", err, p) + } + if !strings.Contains(p.Format(), "administrador") { + t.Error("o plano deve avisar que aplicar exige administrador") + } +} + +func TestPlanoRecusaHomeEPoliticaExistente(t *testing.T) { + f := newFake(t) + f.edition = EditionHome + p, err := BuildPlan(context.Background(), f, nil) + if err != nil { + t.Fatal(err) + } + if p.OK() || !strings.Contains(strings.Join(p.Refusals, " "), "edição") { + t.Fatalf("Home devia ser recusada: %v", p.Refusals) + } + f = newFake(t) + f.tree = RegTree{KeyExists: true, Entries: map[string]RegValue{"DenyUnspecified": DWORD(1)}} + p, _ = BuildPlan(context.Background(), f, nil) + if p.OK() { + t.Fatal("política existente devia ser recusada no plano") + } +} + +func TestPlanoTecladoDesmarcadoMostraARecusa(t *testing.T) { + f := newFake(t) + p, err := BuildPlan(context.Background(), f, []string{`USB\VID_FFFF&PID_0001\6&9999&0&1`}) + if err != nil { + t.Fatal(err) + } + if p.OK() { + t.Fatal("teclado desmarcado: o plano não pode estar OK") + } + if !strings.Contains(p.Format(), "RECUSADO") { + t.Errorf("o plano devia dizer RECUSADO:\n%s", p.Format()) + } +} + +func TestPlanoNaoContemClasseAmplaNemDenyUnspecified(t *testing.T) { + f := newFake(t) + p, _ := BuildPlan(context.Background(), f, nil) + txt := strings.ToLower(p.Format()) + for _, bad := range []string{"denyunspecified", guidKeyboard, guidMouse, guidHID, guidDisk} { + if strings.Contains(txt, bad) { + t.Errorf("o plano menciona %q", bad) + } + } + if !slices.Contains(p.Policy.DenyClasses, denyClassGUIDs[0]) { + t.Error("as classes de USB faltam") + } +} + +func TestAplicarComPlanoMostradoDiferenteDoRecalculadoRecusaAntesDoBackup(t *testing.T) { + f := newFake(t) + st := newSpy(f) + shown, err := BuildPlan(context.Background(), f, nil) + if err != nil { + t.Fatal(err) + } + opts := applyOpts(f) + opts.ExpectedPlan = shown.Format() + // o plano mostrado foi calculado com o Prazo padrão (10) e o Apply com o mesmo: confere + if _, err := Apply(context.Background(), f, st, opts); err != nil { + t.Fatalf("plano idêntico deve passar: %v", err) + } + + // um pendrive entra durante a pergunta: o plano recalculado é outro + f2 := newFake(t) + st2 := newSpy(f2) + shown2, _ := BuildPlan(context.Background(), f2, nil) + f2.devs = machine(usbKeyboard("0001")) // o pendrive saiu + o2 := applyOpts(f2) + o2.ExpectedPlan = shown2.Format() + if _, err := Apply(context.Background(), f2, st2, o2); !errors.Is(err, ErrPlanChanged) { + t.Fatalf("err = %v, queria ErrPlanChanged", err) + } + if len(f2.log) != 0 || f2.task.Exists { + t.Fatalf("nenhum passo (nem backup, pasta ou tarefa) antes de recusar: %v", f2.log) + } + + // o prazo diferente também muda o plano mostrado + f3 := newFake(t) + shown3, _ := BuildPlan(context.Background(), f3, nil) + o3 := applyOpts(f3) + o3.Prazo = 5 + o3.ExpectedPlan = shown3.Format() // mostrado com 10 min, aplicado com 5 + if _, err := Apply(context.Background(), f3, newSpy(f3), o3); !errors.Is(err, ErrPlanChanged) { + t.Fatalf("prazo diferente: %v", err) + } +} + +// O relógio real carrega a leitura monotônica; o backup relido (do JSON) não. A comparação do relido não pode abortar todo +// aplicar de verdade só por isso. +func TestAplicarComRelogioRealEFileStore(t *testing.T) { + f := newFake(t) + f.now = time.Now() + st := f.fileStore() + opts := ApplyOptions{Prazo: PrazoPadrao, Now: time.Now()} + if _, err := Apply(context.Background(), f, st, opts); err != nil { + t.Fatalf("Apply com time.Now(): %v", err) + } + if sn, err := st.Load(); err != nil || sn == nil { + t.Fatalf("snapshot: %v %v", sn, err) + } +} diff --git a/internal/usb/backup.go b/internal/usb/backup.go new file mode 100644 index 0000000..cfe383b --- /dev/null +++ b/internal/usb/backup.go @@ -0,0 +1,295 @@ +package usb + +import ( + "bytes" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "regexp" + "time" + + "github.com/PiluTech/toolkit/internal/privacidade" + "github.com/PiluTech/toolkit/internal/textsafe" +) + +// maxBackupBytes limita o arquivo de backup lido (é dado não confiável). +const maxBackupBytes = 4 << 20 + +var ( + reHex64 = regexp.MustCompile(`^[0-9a-f]{64}$`) + reExePath = regexp.MustCompile(`^[A-Za-z]:\\[A-Za-z0-9 _.()\\-]{1,240}$`) +) + +// Target é um valor que o Apply escreve, com o ORIGINAL (Existed/Orig) e o valor novo (Want). Orig só vale com Existed. +type Target struct { + Path string `json:"path"` + Existed bool `json:"existed"` + Orig RegValue `json:"orig"` + Want RegValue `json:"want"` +} + +// Snapshot é o estado ORIGINAL guardado antes da primeira chave: de cada alvo da lista fechada (inclusive "não existia"), +// se a chave Restrictions e as subchaves já existiam, e o que a tarefa de reversão executa. O hash SHA-256 do envelope +// detecta CORRUPÇÃO; quem impede adulteração é a ACL da pasta protegida (um arquivo que o administrador reescreve com hash +// novo não seria detectado, por isso a restauração também só mexe na lista fechada e confere o estado atual). +type Snapshot struct { + Version int `json:"version"` + Created time.Time `json:"created"` + KeyExisted bool `json:"key_existed"` + SubkeysExisted []string `json:"subkeys_existed"` + Targets []Target `json:"targets"` + RegFile string `json:"reg_file"` + RegSHA256 string `json:"reg_sha256"` + TaskExe string `json:"task_exe"` + Prazo int `json:"prazo"` +} + +type envelope struct { + SHA256 string `json:"sha256"` + Snapshot Snapshot `json:"snapshot"` +} + +func hashSnapshot(sn *Snapshot) (string, error) { + b, err := json.Marshal(sn) + if err != nil { + return "", err + } + h := sha256.Sum256(b) + return hex.EncodeToString(h[:]), nil +} + +func marshalEnvelope(sn *Snapshot) ([]byte, error) { + h, err := hashSnapshot(sn) + if err != nil { + return nil, err + } + return json.MarshalIndent(envelope{SHA256: h, Snapshot: *sn}, "", " ") +} + +func invalidBackup(format string, a ...any) error { + return fmt.Errorf("%w: %s", ErrBackupInvalid, fmt.Sprintf(format, a...)) +} + +func validKind(k privacidade.RegKind) bool { + return k == privacidade.RegDWORD || k == privacidade.RegString || k == privacidade.RegExpandString +} + +// validate confere a ESTRUTURA do snapshot contra a lista fechada (o arquivo é dado não confiável). +func (sn *Snapshot) validate() error { + if sn.Version != 1 { + return invalidBackup("versão %d desconhecida", sn.Version) + } + if sn.Prazo < PrazoMinimo || sn.Prazo > PrazoMaximo { + return invalidBackup("prazo %d fora de %d..%d", sn.Prazo, PrazoMinimo, PrazoMaximo) + } + if !reExePath.MatchString(sn.TaskExe) { + return invalidBackup("caminho da tarefa fora do formato") + } + if sn.RegFile != "" && sn.RegFile != RegFile { + return invalidBackup("arquivo .reg fora do esperado") + } + if sn.RegSHA256 != "" && !reHex64.MatchString(sn.RegSHA256) { + return invalidBackup("hash do .reg inválido") + } + for _, s := range sn.SubkeysExisted { + if s != nameAllow && s != nameDeny { + return invalidBackup("subchave %q fora da lista fechada", printableRel(s)) + } + } + if len(sn.Targets) == 0 || len(sn.Targets) > MaxAllowIDs+8 { + return invalidBackup("%d alvos (esperado 1..%d)", len(sn.Targets), MaxAllowIDs+8) + } + seen := map[string]bool{} + for _, t := range sn.Targets { + if err := checkRel(t.Path); err != nil { + return invalidBackup("alvo fora da lista fechada: %q", printableRel(t.Path)) + } + if seen[t.Path] { + return invalidBackup("alvo repetido: %q", t.Path) + } + seen[t.Path] = true + if err := checkWrite(t.Path, t.Want); err != nil { + return invalidBackup("valor novo de %q inválido", t.Path) + } + if t.Existed { + if !validKind(t.Orig.Kind) || len(t.Orig.Str) > 4096 { + return invalidBackup("valor original de %q inválido", t.Path) + } + if err := checkOrigText(t.Orig); err != nil { + return invalidBackup("valor original de %q inválido", t.Path) + } + } + } + return nil +} + +func checkOrigText(v RegValue) error { + for _, r := range v.Str { + if r < 0x20 || r == 0x7f { + return ErrEntradaInvalida + } + } + return nil +} + +// Store guarda o snapshot (e o .reg) na pasta protegida. Load devolve nil, nil quando não existe; arquivo corrompido, +// adulterado ou fora da estrutura é ErrBackupInvalid. Save NÃO cria a pasta: quem a cria e protege é System.ProtectDir. +type Store interface { + Folder() string + Load() (*Snapshot, error) + Save(*Snapshot) error + Remove() error + RegPath() string + FileSHA256(path string) (string, error) +} + +// RevertLogger é o Store que guarda o rastro da reversão automática (opcional: FileStore o implementa). +type RevertLogger interface { + // SaveRevertResult grava o texto do resultado (vazio apaga o rastro). + SaveRevertResult(note string) error + // LoadRevertResult devolve o texto gravado, já limpo (vazio = nenhum). + LoadRevertResult() string +} + +// RevertResultFile é o arquivo do rastro, dentro da pasta protegida. +const RevertResultFile = "usb-revert-result.txt" + +// SaveRevertResult grava o rastro (até 600 bytes, 0600); vazio apaga. +func (s FileStore) SaveRevertResult(note string) error { + path := filepath.Join(s.Dir, RevertResultFile) + if note == "" { + if err := os.Remove(path); err != nil && !errors.Is(err, os.ErrNotExist) { + return err + } + return nil + } + if len(note) > 600 { + note = note[:600] + } + return os.WriteFile(path, []byte(note), 0o600) +} + +// LoadRevertResult lê o rastro (limite de tamanho; texto de fora passa por textsafe). +func (s FileStore) LoadRevertResult() string { + f, err := os.Open(filepath.Join(s.Dir, RevertResultFile)) + if err != nil { + return "" + } + defer func() { _ = f.Close() }() + b, _ := io.ReadAll(io.LimitReader(f, 700)) + return textsafe.Line(string(b)) +} + +// FileStore é o Store em arquivo (usb-backup.json, escrita atômica, 0600). +type FileStore struct{ Dir string } + +// Folder devolve a pasta. +func (s FileStore) Folder() string { return s.Dir } + +// BackupPath é o arquivo do snapshot. +func (s FileStore) BackupPath() string { return filepath.Join(s.Dir, BackupFile) } + +// RegPath é o arquivo .reg exportado. +func (s FileStore) RegPath() string { return filepath.Join(s.Dir, RegFile) } + +// Load lê e valida o snapshot. +func (s FileStore) Load() (*Snapshot, error) { + f, err := os.Open(s.BackupPath()) + if errors.Is(err, os.ErrNotExist) { + return nil, nil + } + if err != nil { + return nil, err + } + defer func() { _ = f.Close() }() + data, err := io.ReadAll(io.LimitReader(f, maxBackupBytes+1)) + if err != nil { + return nil, err + } + if len(data) > maxBackupBytes { + return nil, invalidBackup("arquivo acima de %d bytes", maxBackupBytes) + } + dec := json.NewDecoder(bytes.NewReader(data)) + dec.DisallowUnknownFields() + var env envelope + if err := dec.Decode(&env); err != nil { + return nil, invalidBackup("ilegível ou cortado") + } + if dec.More() { + return nil, invalidBackup("conteúdo depois do fim do JSON") + } + want, err := hashSnapshot(&env.Snapshot) + if err != nil || want != env.SHA256 { + return nil, invalidBackup("o hash SHA-256 não confere (arquivo alterado ou corrompido)") + } + if err := env.Snapshot.validate(); err != nil { + return nil, err + } + return &env.Snapshot, nil +} + +// Save valida e grava de forma atômica (temporário na mesma pasta + rename). +func (s FileStore) Save(sn *Snapshot) error { + if err := sn.validate(); err != nil { + return err + } + if fi, err := os.Stat(s.Dir); err != nil || !fi.IsDir() { + return fmt.Errorf("a pasta do backup %s não existe: ela é criada e protegida antes de gravar", s.Dir) + } + data, err := marshalEnvelope(sn) + if err != nil { + return err + } + tmp, err := os.CreateTemp(s.Dir, ".usb-backup-*.tmp") + if err != nil { + return err + } + name := tmp.Name() + defer func() { _ = os.Remove(name) }() + if _, err := tmp.Write(data); err != nil { + _ = tmp.Close() + return err + } + if err := tmp.Chmod(0o600); err != nil { + _ = tmp.Close() + return err + } + if err := tmp.Sync(); err != nil { + _ = tmp.Close() + return err + } + if err := tmp.Close(); err != nil { + return err + } + return os.Rename(name, s.BackupPath()) +} + +// Remove apaga o snapshot e o .reg (ausente não é erro). +func (s FileStore) Remove() error { + var first error + for _, p := range []string{s.BackupPath(), s.RegPath()} { + if err := os.Remove(p); err != nil && !errors.Is(err, os.ErrNotExist) && first == nil { + first = err + } + } + return first +} + +// FileSHA256 devolve o SHA-256 (hex) de um arquivo. +func (s FileStore) FileSHA256(path string) (string, error) { + f, err := os.Open(path) + if err != nil { + return "", err + } + defer func() { _ = f.Close() }() + h := sha256.New() + if _, err := io.Copy(h, io.LimitReader(f, 64<<20)); err != nil { + return "", err + } + return hex.EncodeToString(h.Sum(nil)), nil +} diff --git a/internal/usb/backup_test.go b/internal/usb/backup_test.go new file mode 100644 index 0000000..d346c64 --- /dev/null +++ b/internal/usb/backup_test.go @@ -0,0 +1,177 @@ +package usb + +import ( + "errors" + "os" + "path/filepath" + "runtime" + "strconv" + "strings" + "testing" +) + +func sampleSnapshot() *Snapshot { + return &Snapshot{ + Version: 1, Created: t0, KeyExisted: false, Prazo: 10, TaskExe: ProtectedDir + `\` + RevertBinary, + Targets: []Target{ + {Path: "AllowDenyLayered", Existed: false, Want: DWORD(1)}, + {Path: `AllowDeviceIDs\1`, Existed: false, Want: String(`USB\VID_FFFF&PID_0001`)}, + }, + } +} + +func TestBackupIdaEVoltaEArquivoAtomico(t *testing.T) { + dir := t.TempDir() + st := FileStore{Dir: dir} + sn := sampleSnapshot() + if err := st.Save(sn); err != nil { + t.Fatal(err) + } + got, err := st.Load() + if err != nil || got == nil { + t.Fatalf("Load: %v %v", got, err) + } + if len(got.Targets) != 2 || got.Targets[1].Want.Str != `USB\VID_FFFF&PID_0001` || got.TaskExe != sn.TaskExe { + t.Fatalf("snapshot = %#v", got) + } + ents, _ := os.ReadDir(dir) + for _, e := range ents { + if strings.HasSuffix(e.Name(), ".tmp") { + t.Errorf("sobrou temporário %s", e.Name()) + } + } + if runtime.GOOS != "windows" { + if fi, _ := os.Stat(st.BackupPath()); fi.Mode().Perm() != 0o600 { + t.Errorf("permissão = %v", fi.Mode().Perm()) + } + } +} + +func TestBackupAusenteNaoEErro(t *testing.T) { + got, err := FileStore{Dir: t.TempDir()}.Load() + if got != nil || err != nil { + t.Fatalf("got=%v err=%v", got, err) + } +} + +func TestBackupNaoCriaAPastaSemACL(t *testing.T) { + st := FileStore{Dir: filepath.Join(t.TempDir(), "naoexiste")} + if err := st.Save(sampleSnapshot()); err == nil { + t.Fatal("Save não pode criar a pasta: quem cria e protege é o ProtectDir") + } +} + +func TestBackupRecusaCorrompidoAdulteradoEInvalido(t *testing.T) { + good := func(t *testing.T) (FileStore, string, []byte) { + dir := t.TempDir() + st := FileStore{Dir: dir} + if err := st.Save(sampleSnapshot()); err != nil { + t.Fatal(err) + } + raw, _ := os.ReadFile(st.BackupPath()) + return st, st.BackupPath(), raw + } + write := func(t *testing.T, p string, b []byte) { + t.Helper() + if err := os.WriteFile(p, b, 0o600); err != nil { + t.Fatal(err) + } + } + cases := map[string]func(t *testing.T, p string, raw []byte){ + "truncado": func(t *testing.T, p string, raw []byte) { write(t, p, raw[:len(raw)/2]) }, + "lixo": func(t *testing.T, p string, _ []byte) { write(t, p, []byte("nao e json")) }, + "vazio": func(t *testing.T, p string, _ []byte) { write(t, p, nil) }, + "hash trocado": func(t *testing.T, p string, raw []byte) { + write(t, p, []byte(strings.Replace(string(raw), `"sha256": "`, `"sha256": "00`, 1))) + }, + "conteudo trocado": func(t *testing.T, p string, raw []byte) { + write(t, p, []byte(strings.Replace(string(raw), `"prazo": 10`, `"prazo": 99`, 1))) + }, + "campo desconhecido": func(t *testing.T, p string, raw []byte) { + write(t, p, []byte(strings.Replace(string(raw), `"snapshot": {`, `"snapshot": {"extra": 1,`, 1))) + }, + "arquivo enorme": func(t *testing.T, p string, _ []byte) { write(t, p, []byte(strings.Repeat("a", 5<<20))) }, + } + for name, mut := range cases { + t.Run(name, func(t *testing.T) { + st, p, raw := good(t) + mut(t, p, raw) + got, err := st.Load() + if got != nil || !errors.Is(err, ErrBackupInvalid) { + t.Fatalf("got=%v err=%v, queria ErrBackupInvalid", got, err) + } + }) + } +} + +func TestBackupComHashCertoMasEstruturaForaDaListaFechadaRecusa(t *testing.T) { + bad := map[string]func(s *Snapshot){ + "caminho fora da lista": func(s *Snapshot) { s.Targets[0].Path = "DenyUnspecified" }, + "caminho com ..": func(s *Snapshot) { s.Targets[0].Path = `AllowDeviceIDs\..\x` }, + "versão desconhecida": func(s *Snapshot) { s.Version = 2 }, + "prazo fora do limite": func(s *Snapshot) { s.Prazo = 0 }, + "alvo repetido": func(s *Snapshot) { s.Targets = append(s.Targets, s.Targets[0]) }, + "valor novo inválido": func(s *Snapshot) { s.Targets[1].Want = String("a\x1b[2J") }, + "flag com valor errado": func(s *Snapshot) { s.Targets[0].Want = DWORD(7) }, + "regfile estranho": func(s *Snapshot) { s.RegFile = `..\..\Windows\x.reg` }, + "hash do reg inválido": func(s *Snapshot) { s.RegSHA256 = "xyz" }, + "subchave desconhecida": func(s *Snapshot) { s.SubkeysExisted = []string{"Run"} }, + "binário da tarefa vazio": func(s *Snapshot) { s.TaskExe = "" }, + "alvos demais": func(s *Snapshot) { s.Targets = manyTargets(MaxAllowIDs + 20) }, + } + for name, mut := range bad { + t.Run(name, func(t *testing.T) { + dir := t.TempDir() + sn := sampleSnapshot() + mut(sn) + raw, err := marshalEnvelope(sn) // hash CERTO: só a validação de estrutura pode barrar + if err != nil { + t.Fatal(err) + } + st := FileStore{Dir: dir} + if err := os.WriteFile(st.BackupPath(), raw, 0o600); err != nil { + t.Fatal(err) + } + if got, err := st.Load(); got != nil || !errors.Is(err, ErrBackupInvalid) { + t.Fatalf("got=%v err=%v", got, err) + } + if err := st.Save(sn); err == nil { + t.Fatal("Save também não pode gravar um snapshot inválido") + } + }) + } +} + +func manyTargets(n int) []Target { + var out []Target + for i := 1; i <= n; i++ { + out = append(out, Target{Path: `AllowDeviceIDs\` + strconv.Itoa(i), Want: String(`USB\VID_FFFF&PID_0001`)}) + } + return out +} + +func TestBackupRemoveApagaOJSONEORegSemErro(t *testing.T) { + st := FileStore{Dir: t.TempDir()} + if err := st.Remove(); err != nil { + t.Fatalf("remover o que não existe não é erro: %v", err) + } + _ = st.Save(sampleSnapshot()) + _ = os.WriteFile(st.RegPath(), []byte("x"), 0o600) + if err := st.Remove(); err != nil { + t.Fatal(err) + } + for _, p := range []string{st.BackupPath(), st.RegPath()} { + if _, err := os.Stat(p); err == nil { + t.Errorf("%s ainda existe", p) + } + } +} + +func TestBackupDoRegConfereHash(t *testing.T) { + st := FileStore{Dir: t.TempDir()} + _ = os.WriteFile(st.RegPath(), []byte("abc"), 0o600) + h, err := st.FileSHA256(st.RegPath()) + if err != nil || h != "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad" { + t.Fatalf("hash = %q %v", h, err) + } +} diff --git a/internal/usb/fake_test.go b/internal/usb/fake_test.go new file mode 100644 index 0000000..8606362 --- /dev/null +++ b/internal/usb/fake_test.go @@ -0,0 +1,255 @@ +package usb + +import ( + "context" + "errors" + "os" + "sort" + "strconv" + "strings" + "testing" + "time" +) + +var t0 = time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC) + +// fakeSys é o Windows em memória: nenhum teste do pacote toca o registro, o Agendador ou o disco do sistema. +type fakeSys struct { + t *testing.T + edition string + admin bool + devs []Device + devsErr error + tree RegTree + task TaskInfo + now time.Time + dir string // pasta "protegida" (temporária) onde o Store grava + log []string + failOn string // prefixo da operação que falha + hook func(op string) + + protectCalls int + staged StagedBinary + armSkew func(*TaskInfo) // muda a tarefa DEPOIS de armada (simula conferência que falha) + dropWrite string // RegWrite deste caminho "funciona" mas não grava (releitura pós-ação) + taskReadErr error + treeReadErr error + failed bool // uma falha de failOn já aconteceu + failAfter string // depois da primeira falha, também falham as operações com este prefixo +} + +func newFake(t *testing.T) *fakeSys { + t.Helper() + return &fakeSys{t: t, edition: EditionPro, admin: true, devs: machine(usbKeyboard("0001"), usbPendrive("0003")), + tree: RegTree{Entries: map[string]RegValue{}}, now: t0, dir: t.TempDir(), + staged: StagedBinary{Path: ProtectedDir + `\` + RevertBinary, SourceSHA: strings.Repeat("a", 64), CopySHA: strings.Repeat("a", 64)}} +} + +func (f *fakeSys) op(name string) error { + if f.hook != nil { + f.hook(name) + } + if f.failOn != "" && strings.HasPrefix(name, f.failOn) { + f.failed = true + return errors.New("falha simulada em " + name) + } + if f.failed && f.failAfter != "" && strings.HasPrefix(name, f.failAfter) { + return errors.New("falha simulada (depois da primeira) em " + name) + } + f.log = append(f.log, name) + return nil +} + +func (f *fakeSys) writes() int { + return f.count("reg-write:") + f.count("reg-delete:") + f.count("key-delete:") +} +func (f *fakeSys) count(prefix string) int { + n := 0 + for _, l := range f.log { + if strings.HasPrefix(l, prefix) { + n++ + } + } + return n +} +func (f *fakeSys) first(prefix string) int { + for i, l := range f.log { + if strings.HasPrefix(l, prefix) { + return i + } + } + return -1 +} + +func (f *fakeSys) Edition(context.Context) (string, error) { return f.edition, nil } +func (f *fakeSys) IsAdmin(context.Context) bool { return f.admin } +func (f *fakeSys) Devices(context.Context) ([]Device, error) { + return f.devs, f.devsErr +} + +func (f *fakeSys) ReadTree(context.Context) (RegTree, error) { + if f.treeReadErr != nil { + return RegTree{}, f.treeReadErr + } + out := RegTree{KeyExists: f.tree.KeyExists, Entries: map[string]RegValue{}, Subkeys: append([]string(nil), f.tree.Subkeys...)} + for k, v := range f.tree.Entries { + out.Entries[k] = v + } + return out, nil +} + +func (f *fakeSys) addSubkey(rel string) { + for _, s := range f.tree.Subkeys { + if s == rel { + return + } + } + f.tree.Subkeys = append(f.tree.Subkeys, rel) + sort.Strings(f.tree.Subkeys) +} + +func (f *fakeSys) RegWrite(_ context.Context, rel string, v RegValue) error { + if err := checkWrite(rel, v); err != nil { + f.t.Errorf("RegWrite fora da lista fechada: %v", err) + return err + } + if err := f.op("reg-write:" + rel); err != nil { + return err + } + if rel == f.dropWrite { + return nil + } + f.tree.KeyExists = true + if sub, _, ok := strings.Cut(rel, `\`); ok { + f.addSubkey(sub) + } + f.tree.Entries[rel] = v + return nil +} + +func (f *fakeSys) RegDelete(_ context.Context, rel string) error { + if err := f.op("reg-delete:" + rel); err != nil { + return err + } + delete(f.tree.Entries, rel) + return nil +} + +func (f *fakeSys) KeyDelete(_ context.Context, rel string) error { + if err := f.op("key-delete:" + rel); err != nil { + return err + } + for p := range f.tree.Entries { + if rel == "" || strings.HasPrefix(p, rel+`\`) { + f.t.Errorf("KeyDelete(%q) com valor %q ainda dentro: apagaria política às cegas", rel, p) + } + } + if rel == "" { + if len(f.tree.Subkeys) > 0 { + f.t.Errorf("KeyDelete(Restrictions) com subchaves %v", f.tree.Subkeys) + } + f.tree.KeyExists = false + return nil + } + var keep []string + for _, s := range f.tree.Subkeys { + if s != rel { + keep = append(keep, s) + } + } + f.tree.Subkeys = keep + return nil +} + +func (f *fakeSys) ExportReg(_ context.Context, file string) error { + if err := f.op("export-reg"); err != nil { + return err + } + return os.WriteFile(file, []byte("Windows Registry Editor Version 5.00\r\n"), 0o600) +} + +func (f *fakeSys) ProtectDir(context.Context, string) error { + f.protectCalls++ + return f.op("protect-dir") +} + +func (f *fakeSys) StageBinary(context.Context, string) (StagedBinary, error) { + if err := f.op("stage-binary"); err != nil { + return StagedBinary{}, err + } + return f.staged, nil +} + +func (f *fakeSys) ArmTask(_ context.Context, spec TaskSpec) error { + if err := f.op("task-arm:" + strconv.Itoa(spec.Minutes) + ":" + spec.Args); err != nil { + return err + } + f.task = TaskInfo{Exists: true, Enabled: true, Exe: spec.Exe, Args: spec.Args, User: "SYSTEM", Next: f.now.Add(time.Duration(spec.Minutes) * time.Minute)} + if f.armSkew != nil { + f.armSkew(&f.task) + } + return nil +} + +func (f *fakeSys) ReadTask(context.Context) (TaskInfo, error) { return f.task, f.taskReadErr } + +func (f *fakeSys) DeleteTask(context.Context) error { + if err := f.op("task-delete"); err != nil { + return err + } + f.task = TaskInfo{} + return nil +} + +// fileStore devolve o FileStore na pasta temporária do fake. +func (f *fakeSys) fileStore() FileStore { return FileStore{Dir: f.dir} } + +// spyStore envolve um Store e registra/falha as operações (a ordem backup -> tarefa -> chaves se confere pelo log do fake). +type spyStore struct { + Store + f *fakeSys + failSav bool + failRem bool +} + +func (s *spyStore) Save(sn *Snapshot) error { + if err := s.f.op("backup-save"); err != nil { + return err + } + if s.failSav { + return errors.New("falha simulada ao gravar o backup") + } + return s.Store.Save(sn) +} + +func (s *spyStore) Remove() error { + if s.failRem { + return errors.New("falha simulada ao remover o backup") + } + _ = s.f.op("backup-remove") + return s.Store.Remove() +} + +func newSpy(f *fakeSys) *spyStore { return &spyStore{Store: f.fileStore(), f: f} } + +func applyOpts(f *fakeSys) ApplyOptions { + return ApplyOptions{Prazo: PrazoPadrao, Now: f.now} +} + +func mustApply(t *testing.T, f *fakeSys, st Store) *ApplyResult { + t.Helper() + res, err := Apply(context.Background(), f, st, applyOpts(f)) + if err != nil { + t.Fatalf("Apply: %v", err) + } + return res +} + +func treeKeys(tr RegTree) []string { + var out []string + for k := range tr.Entries { + out = append(out, k) + } + sort.Strings(out) + return out +} diff --git a/internal/usb/fixtures_test.go b/internal/usb/fixtures_test.go new file mode 100644 index 0000000..dff1f33 --- /dev/null +++ b/internal/usb/fixtures_test.go @@ -0,0 +1,110 @@ +package usb + +// Fixtures SINTÉTICAS (repositório público): VID_FFFF/PID_xxxx e nomes inventados, nunca IDs de máquina ou cliente real. + +const ( + guidUSB = "{36fc9e60-c465-11cf-8056-444553540000}" + guidUSBDevice = "{88bae032-5a81-49f0-bc3d-a4ff138216d6}" + guidHID = "{745a17a0-74d3-11d0-b6fe-00a0c90f57da}" + guidKeyboard = "{4d36e96b-e325-11ce-bfc1-08002be10318}" + guidMouse = "{4d36e96f-e325-11ce-bfc1-08002be10318}" + guidDisk = "{4d36e967-e325-11ce-bfc1-08002be10318}" + guidSCSI = "{4d36e97b-e325-11ce-bfc1-08002be10318}" + guidHDC = "{4d36e96a-e325-11ce-bfc1-08002be10318}" + guidBT = "{e0cbf06c-cd8b-4647-bb8a-263b43f0f974}" + guidSystem = "{4d36e97d-e325-11ce-bfc1-08002be10318}" +) + +var classGUIDs = map[string]string{ + "USB": guidUSB, "USBDevice": guidUSBDevice, "HIDClass": guidHID, "Keyboard": guidKeyboard, "Mouse": guidMouse, + "DiskDrive": guidDisk, "SCSIAdapter": guidSCSI, "HDC": guidHDC, "Bluetooth": guidBT, "System": guidSystem, +} + +type devOpt func(*Device) + +func compat(ids ...string) devOpt { return func(d *Device) { d.CompatibleIDs = ids } } + +// dev monta um dispositivo: instância, pai, nome, classe e IDs de hardware. +func dev(inst, parent, name, class string, hw []string, opts ...devOpt) Device { + d := Device{InstanceID: inst, Parent: parent, Name: name, Class: class, ClassGUID: classGUIDs[class], HardwareIDs: hw} + for _, o := range opts { + o(&d) + } + return d +} + +const ( + rootID = `HTREE\ROOT\0` + halID = `ACPI_HAL\PNP0C08\0` + pciUSB = `PCI\VEN_FFFF&DEV_0001&SUBSYS_00000000&REV_01\3&11583659&0&A0` + hub30 = `USB\ROOT_HUB30\4&1111&0&0` +) + +// baseMachine é uma máquina sem nenhum USB externo: raiz, HAL, controlador USB, hub raiz, NVMe, SATA, teclado PS/2, +// touchpad I2C e o rádio Bluetooth (USB interno) com um teclado Bluetooth. +func baseMachine() []Device { + return []Device{ + dev(rootID, "", "Raiz", "System", []string{"HTREE\\ROOT\\0"}), + dev(halID, rootID, "ACPI x64", "System", []string{"ACPI_HAL\\PNP0C08"}), + // teclado PS/2 + dev(`ACPI\PNP0303\4&2222&0`, halID, "Teclado PS/2 padrão", "Keyboard", []string{`ACPI\PNP0303`}), + // touchpad I2C (HID sobre I2C) + dev(`ACPI\FFFF0001\4&3333&0`, halID, "Controlador I2C", "System", []string{`ACPI\FFFF0001`}), + dev(`HID\FFFF0001&COL01\5&4444&0&0000`, `ACPI\FFFF0001\4&3333&0`, "Touchpad I2C HID", "Mouse", []string{`HID\FFFF0001&COL01`}), + // controlador USB (PCI) e hub raiz + dev(pciUSB, halID, "Controlador xHCI", "USB", []string{`PCI\VEN_FFFF&DEV_0001&SUBSYS_00000000&REV_01`}, compat(`PCI\CC_0C0330`, `PCI\CC_0C03`)), + dev(hub30, pciUSB, "Hub raiz USB 3", "USB", []string{`USB\ROOT_HUB30`}), + // NVMe + dev(`PCI\VEN_FFFF&DEV_0002&SUBSYS_00000000&REV_01\3&11583659&0&B0`, halID, "Controlador NVMe", "SCSIAdapter", []string{`PCI\VEN_FFFF&DEV_0002&SUBSYS_00000000&REV_01`}), + dev(`SCSI\DISK&VEN_NVME&PROD_FAKE\5&5555&0&000000`, `PCI\VEN_FFFF&DEV_0002&SUBSYS_00000000&REV_01\3&11583659&0&B0`, "Disco NVMe", "DiskDrive", []string{`SCSI\DISKNVME____FAKE`}), + // SATA + dev(`PCI\VEN_FFFF&DEV_0003&SUBSYS_00000000&REV_01\3&11583659&0&B8`, halID, "Controlador SATA", "HDC", []string{`PCI\VEN_FFFF&DEV_0003&SUBSYS_00000000&REV_01`}), + dev(`IDE\DISKFAKE_SATA\5&6666&0&0.0.0`, `PCI\VEN_FFFF&DEV_0003&SUBSYS_00000000&REV_01\3&11583659&0&B8`, "Disco SATA", "DiskDrive", []string{`IDE\DISKFAKE_SATA`}), + // rádio Bluetooth (USB interno, composto) com o adaptador e um teclado Bluetooth + dev(`USB\VID_FFFF&PID_0002\5&7777&0&1`, hub30, "Rádio Bluetooth", "USB", []string{`USB\VID_FFFF&PID_0002&REV_0001`, `USB\VID_FFFF&PID_0002`}, compat(`USB\COMPOSITE`)), + dev(`USB\VID_FFFF&PID_0002&MI_00\6&7777&0&0000`, `USB\VID_FFFF&PID_0002\5&7777&0&1`, "Adaptador Bluetooth", "Bluetooth", []string{`USB\VID_FFFF&PID_0002&REV_0001&MI_00`, `USB\VID_FFFF&PID_0002&MI_00`}), + dev(`BTHENUM\DEV_AABBCCDDEEFF\7&8888&0&BLUETOOTHDEVICE_AABBCCDDEEFF`, `USB\VID_FFFF&PID_0002&MI_00\6&7777&0&0000`, "Teclado Bluetooth", "Keyboard", []string{`BTHENUM\DEV_AABBCCDDEEFF`}), + } +} + +// usbKeyboard é um teclado USB COMPOSTO (dispositivo, duas interfaces, nó HID de teclado e nó HID de controle de mídia). +func usbKeyboard(pid string) []Device { + base := `USB\VID_FFFF&PID_` + pid + top := base + `\6&9999&0&1` + mi0 := base + `&MI_00\7&aaaa&0&0000` + mi1 := base + `&MI_01\7&aaaa&0&0001` + return []Device{ + dev(top, hub30, "Teclado USB composto", "USB", []string{base + `&REV_0100`, base}, compat(`USB\COMPOSITE`)), + dev(mi0, top, "Dispositivo de entrada USB", "HIDClass", []string{base + `&REV_0100&MI_00`, base + `&MI_00`}, compat(`USB\Class_03&SubClass_01&Prot_01`)), + dev(`HID\VID_FFFF&PID_`+pid+`&MI_00\8&bbbb&0&0000`, mi0, "Teclado HID", "Keyboard", []string{`HID\VID_FFFF&PID_` + pid + `&REV_0100&MI_00`, `HID\VID_FFFF&PID_` + pid + `&MI_00`}, compat(`HID_DEVICE_SYSTEM_KEYBOARD`, `HID_DEVICE_UP:0001_U:0006`, `HID_DEVICE`)), + dev(mi1, top, "Dispositivo de entrada USB (mídia)", "HIDClass", []string{base + `&REV_0100&MI_01`, base + `&MI_01`}, compat(`USB\Class_03`)), + dev(`HID\VID_FFFF&PID_`+pid+`&MI_01\8&bbbb&0&0001`, mi1, "Controle de mídia HID", "HIDClass", []string{`HID\VID_FFFF&PID_` + pid + `&REV_0100&MI_01`, `HID\VID_FFFF&PID_` + pid + `&MI_01`}, compat(`HID_DEVICE_UP:000C_U:0001`, `HID_DEVICE`)), + } +} + +// usbPendrive é um pendrive (armazenamento pessoal): nó USB e o disco USBSTOR. +func usbPendrive(pid string) []Device { + base := `USB\VID_FFFF&PID_` + pid + top := base + `\0&pen&0&2` + return []Device{ + dev(top, hub30, "Pendrive USB", "USB", []string{base + `&REV_0001`, base}, compat(`USB\Class_08&SubClass_06&Prot_50`)), + dev(`USBSTOR\DISK&VEN_FAKE&PROD_PEN&REV_1.00\0&pen&0`, top, "Pendrive (disco)", "DiskDrive", []string{`USBSTOR\DISKFAKE_PEN`}), + } +} + +func machine(parts ...[]Device) []Device { + out := baseMachine() + for _, p := range parts { + out = append(out, p...) + } + return out +} + +func idx(devs []Device, name string) int { + for i, d := range devs { + if d.Name == name { + return i + } + } + return -1 +} diff --git a/internal/usb/plan.go b/internal/usb/plan.go new file mode 100644 index 0000000..76356e0 --- /dev/null +++ b/internal/usb/plan.go @@ -0,0 +1,182 @@ +package usb + +import ( + "context" + "errors" + "fmt" + "strings" + + "github.com/PiluTech/toolkit/internal/textsafe" +) + +// Textos fixos que valem em TODO fluxo (plano, CLI, TUI e docs): o rótulo de experimental e o limite honesto. +const ( + TextExperimental = "EXPERIMENTAL: esta função ainda não foi executada numa máquina real (A VERIFICAR em VM, ver docs/usb.md). Nada se aplica por padrão e nada muda sem a sua confirmação." + TextLimit = "Limite honesto: um dispositivo que CLONA o VID/PID de um permitido PASSA; a política nega só as duas classes de USB, então um dispositivo HID novo cujo nó não é de classe USB nem USBDevice (um teclado simples, por exemplo) pode NÃO ser bloqueado (A VERIFICAR em VM); a política só controla a instalação ou atualização de driver de dispositivo novo (o que já está instalado continua) e não é defesa contra quem tem acesso físico e conhece os IDs. Isto reduz o risco, não o elimina." + TextNeverElevates = "O toolkit nunca eleva sozinho: abra o terminal como administrador (botão direito, \"Executar como administrador\")." +) + +// RecoverySteps é o roteiro de recuperação mostrado na confirmação, no plano e quando o estado original é desconhecido. +// Os comandos exatos do WinRE e do Modo Seguro são A VERIFICAR em VM (docs/usb.md). +var RecoverySteps = []string{ + "Se o teclado travar mesmo assim: (1) espere o prazo da reversão automática; (2) use outro teclado já permitido; (3) entre com outra conta de administrador e restaure o .reg exportado em " + ProtectedDir + " (só apague a chave " + RestrictionsKey + " no Editor de Registro ou no gpedit.msc depois de confirmar que não havia política anterior: GPO de domínio, MDM ou outra ferramenta); (4) Modo Seguro (se a política vale nele: A VERIFICAR); (5) Ambiente de Recuperação do Windows (WinRE): prompt de comando, reg load do hive SOFTWARE offline, restaurar o .reg ou, só se confirmado que não havia política anterior, apagar a chave, reg unload (comandos A VERIFICAR em VM).", +} + +// Refusal é um motivo de recusa do plano; Kind é o erro sentinela que a representa. +type refusal struct { + kind error + text string +} + +// Plan é o que `aplicar` faria: política, dispositivos, prova e recusas. Só leitura. +type Plan struct { + Edition string + IsAdmin bool + Prazo int + Policy Policy + Units []Unit + Proof Proof + Refusals []string + refusals []refusal +} + +// OK diz se o plano pode ser aplicado (sem recusas). Administrador não entra aqui: é conferido no Apply. +func (p *Plan) OK() bool { return len(p.refusals) == 0 } + +// Err devolve o erro do plano recusado (nil se OK), com o sentinela do PRIMEIRO motivo e todos os textos. +func (p *Plan) Err() error { + if p.OK() { + return nil + } + return fmt.Errorf("%w: %s", p.refusals[0].kind, strings.Join(p.Refusals, "; ")) +} + +func (p *Plan) refuse(kind error, text string) { + p.refusals = append(p.refusals, refusal{kind, text}) + p.Refusals = append(p.Refusals, text) +} + +// EditionSupported diz se a edição está na documentação da política (Pro, Enterprise e Education); Home e o resto são recusados. +func EditionSupported(ed string) bool { + return ed == EditionPro || ed == EditionEnterprise || ed == EditionEducation +} + +// namespacePresent diz se a lista fechada de alvos do toolkit tem algum valor presente. +func namespacePresent(tr RegTree) bool { + for k := range tr.Entries { + if checkRel(k) == nil { + return true + } + } + return false +} + +// BuildPlan lê (só leitura, sem administrador) a edição, o registro e o PnP e monta o plano com a PROVA. Falha de leitura é +// erro (nunca "provavelmente seguro"); tudo que impede aplicar vira recusa no plano. +func BuildPlan(ctx context.Context, sys System, excluded []string) (*Plan, error) { + ed, err := sys.Edition(ctx) + if err != nil { + return nil, fmt.Errorf("não deu para descobrir a edição do Windows: %w", err) + } + p := &Plan{Edition: ed, IsAdmin: sys.IsAdmin(ctx), Prazo: PrazoPadrao} + if !EditionSupported(ed) { + p.refuse(ErrEdition, fmt.Sprintf("a edição %q do Windows não consta na documentação da política (só Pro, Enterprise e Education): o toolkit recusa em vez de prometer o que a Microsoft não documenta", textsafe.Line(ed))) + } + tr, err := sys.ReadTree(ctx) + if err != nil { + return nil, fmt.Errorf("não deu para ler a chave Restrictions: %w", err) + } + if len(tr.Entries) > 0 || len(tr.Subkeys) > 0 { + p.refuse(ErrExistingPolicy, "já existe política de restrição de instalação de dispositivos nesta máquina (de outra origem ou de uma aplicação anterior); o toolkit não mistura com ela. Desfaça a anterior (toolkit usb desfazer) ou peça a quem administra a máquina") + } + devs, err := sys.Devices(ctx) + if err != nil { + return nil, fmt.Errorf("não deu para ler os dispositivos (PnP): %w", err) + } + an, err := Analyze(devs, excluded) + if err != nil { + if errors.Is(err, ErrTreeIncomplete) || errors.Is(err, ErrNoProof) { + p.refuse(ErrNoProof, "sem prova dos dispositivos essenciais: "+textsafe.Line(err.Error())) + return p, nil + } + return nil, err + } + p.Policy, p.Units, p.Proof = an.Policy, an.Units, an.Proof + if !an.Proof.OK { + for _, f := range an.Proof.Failures { + p.refuse(ErrNoProof, textsafe.Line(f)) + } + } + return p, nil +} + +// Format escreve o plano em texto (determinístico). Todo texto de dispositivo já veio limpo por ParseDevices. +func (p *Plan) Format() string { + var b strings.Builder + w := func(format string, a ...any) { fmt.Fprintf(&b, format+"\n", a...) } + w("Modo empresa: permitir só os USB conhecidos (Windows) [EXPERIMENTAL]") + w("%s", TextExperimental) + w("") + w("%s", TextLimit) + w("") + adm := "não (aplicar exige administrador)" + if p.IsAdmin { + adm = "sim" + } + w("Edição do Windows: %s · administrador: %s", textsafe.Line(p.Edition), adm) + w("") + w("Dispositivos USB conectados agora (marcados = entram na lista e ficam PERMITIDOS; desmarcados = fora da lista, e bloqueados ao reconectar só se a política os alcançar):") + if len(p.Units) == 0 { + w(" (nenhum dispositivo USB externo)") + } + for _, u := range p.Units { + mark, state := "[x]", "permitido" + switch { + case !u.Selected && u.Blocked: + mark, state = "[ ]", "BLOQUEADO ao reconectar (desmarcado)" + case !u.Selected: + mark, state = "[ ]", fmt.Sprintf("desmarcado e fora da lista, mas a política NÃO o bloquearia (a classe %s não está na negação: A VERIFICAR em VM)", classOrDash(u.Class)) + } + ess := "" + if u.Essential { + ess = " · essencial (teclado, mouse ou outro HID)" + } + w(" %s %s %s classe %s conectado agora%s -> %s", mark, u.Name, u.VIDPID, classOrDash(u.Class), ess, state) + } + w("") + w("O que a política grava (só %s):", RestrictionsKey) + w(" - ordem em camadas (AllowDenyLayered), em vez da negação global de tudo que não está na lista (que valeria para TODOS os barramentos)") + w(" - %d ID(s) de hardware permitidos: os VID/PID dos USB marcados e %d ID(s) genéricos de controlador e hub raiz", len(p.Policy.AllowIDs), len(genericAllowIDs)) + w(" - negação só das 2 classes de USB (%s, %s); NUNCA classe de teclado, mouse, HID ou disco", denyClassGUIDs[0], denyClassGUIDs[1]) + w("") + if p.OK() { + w("Prova de dispositivos essenciais: OK (nenhum fica bloqueado, nem os pais deles)") + } else { + w("Prova de dispositivos essenciais: RECUSADO, nada será alterado") + } + for _, l := range p.Proof.Lines { + sym := "OK " + if !l.Allowed { + sym = "NÃO" + } + w(" %s %s (%s, %s): %s", sym, l.Name, classOrDash(l.Class), l.Bus, l.By) + } + for _, r := range p.Refusals { + w("RECUSADO: %s", r) + } + w("") + w("Ordem do aplicar: prova -> backup protegido em %s -> tarefa de reversão criada e conferida -> só então a primeira chave. Falha em qualquer passo = nenhuma alteração.", ProtectedDir) + w("Reversão automática em %d minuto(s): se você não confirmar (toolkit usb confirmar), a tarefa restaura o snapshot sozinha (execução como SYSTEM sem sessão: a provar em VM).", p.Prazo) + w("") + for _, s := range RecoverySteps { + w("%s", s) + } + return b.String() +} + +func classOrDash(c string) string { + if c == "" { + return "-" + } + return c +} diff --git a/internal/usb/pnp.go b/internal/usb/pnp.go new file mode 100644 index 0000000..bd5ba60 --- /dev/null +++ b/internal/usb/pnp.go @@ -0,0 +1,248 @@ +package usb + +import ( + "bytes" + "encoding/json" + "fmt" + "regexp" + "strings" + + "github.com/PiluTech/toolkit/internal/textsafe" +) + +// Device é um dispositivo PnP PRESENTE (lido de Get-PnpDevice/Get-PnpDeviceProperty). Todo texto vem validado e limpo +// por ParseDevices: a saída do PnP é dado NÃO confiável. +type Device struct { + InstanceID string + Parent string // vazio só na raiz da árvore + Name string + Class string + ClassGUID string + HardwareIDs []string + CompatibleIDs []string +} + +// Limites da leitura (o JSON vem de um processo externo). +const ( + maxDevices = 4000 + maxIDLen = 260 + maxIDsPerDev = 64 + maxJSONBytes = 16 << 20 +) + +var ( + reClassName = regexp.MustCompile(`^[A-Za-z0-9_. -]{0,64}$`) + reClassGUID = regexp.MustCompile(`^(\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\})?$`) + reVIDPID = regexp.MustCompile(`(?i)VID_([0-9A-F]{4})&PID_([0-9A-F]{4})`) +) + +// stringList aceita o que o ConvertTo-Json faz com uma propriedade de texto: null, um texto só (sem lista) ou uma lista. +type stringList []string + +func (s *stringList) UnmarshalJSON(b []byte) error { + b = bytes.TrimSpace(b) + switch { + case bytes.Equal(b, []byte("null")): + *s = nil + return nil + case len(b) > 0 && b[0] == '"': + var one string + if err := json.Unmarshal(b, &one); err != nil { + return err + } + *s = []string{one} + return nil + } + var many []string + if err := json.Unmarshal(b, &many); err != nil { + return err + } + *s = many + return nil +} + +type rawDevice struct { + InstanceID string `json:"InstanceId"` + Parent string `json:"Parent"` + Name string `json:"Name"` + Class string `json:"Class"` + ClassGUID string `json:"ClassGuid"` + HardwareIDs stringList `json:"HardwareIds"` + CompatibleIDs stringList `json:"CompatibleIds"` +} + +type rawEnvelope struct { + Count int `json:"count"` + Devices []rawDevice `json:"devices"` +} + +// printableASCII aceita só ASCII imprimível (0x20..0x7E): é o que os IDs de dispositivo usam; ESC, controle, bidi e +// qualquer outro caractere fazem a leitura inteira ser recusada (falha fechada: sem prova, sem aplicar). +func printableASCII(s string) bool { + for i := 0; i < len(s); i++ { + if s[i] < 0x20 || s[i] > 0x7e { + return false + } + } + return true +} + +func checkID(what, s string, allowEmpty bool) error { + if s == "" && allowEmpty { + return nil + } + if s == "" || len(s) > maxIDLen || !printableASCII(s) { + return fmt.Errorf("%w: %s fora do formato seguro", ErrTreeIncomplete, what) + } + return nil +} + +// ParseDevices lê o JSON do script de leitura do PnP: {"count":N,"devices":[...]}. JSON cortado, contagem que não bate, +// lista vazia, ID com caractere de controle ou acima do limite = erro (a leitura é a base da PROVA: incompleta não serve). +func ParseDevices(data []byte) ([]Device, error) { + data = bytes.TrimPrefix(bytes.TrimSpace(data), []byte("\xef\xbb\xbf")) + if len(data) == 0 || len(data) > maxJSONBytes { + return nil, fmt.Errorf("%w: leitura do PnP vazia ou grande demais", ErrTreeIncomplete) + } + var env rawEnvelope + if err := json.Unmarshal(data, &env); err != nil { + return nil, fmt.Errorf("%w: leitura do PnP ilegível ou cortada: %w", ErrTreeIncomplete, err) + } + if len(env.Devices) == 0 || len(env.Devices) > maxDevices || env.Count != len(env.Devices) { + return nil, fmt.Errorf("%w: a leitura do PnP trouxe %d dispositivo(s) mas anuncia %d", ErrTreeIncomplete, len(env.Devices), env.Count) + } + out := make([]Device, 0, len(env.Devices)) + for _, r := range env.Devices { + if err := checkID("ID de instância", r.InstanceID, false); err != nil { + return nil, err + } + if err := checkID("ID do pai", r.Parent, true); err != nil { + return nil, err + } + if !reClassName.MatchString(r.Class) || !reClassGUID.MatchString(r.ClassGUID) { + return nil, fmt.Errorf("%w: classe fora do formato seguro", ErrTreeIncomplete) + } + if len(r.HardwareIDs) > maxIDsPerDev || len(r.CompatibleIDs) > maxIDsPerDev { + return nil, fmt.Errorf("%w: IDs demais num dispositivo", ErrTreeIncomplete) + } + d := Device{InstanceID: r.InstanceID, Parent: r.Parent, Class: r.Class, ClassGUID: r.ClassGUID} + name := textsafe.Line(r.Name) + if len([]rune(name)) > 120 { + name = string([]rune(name)[:120]) + } + d.Name = name + for _, id := range r.HardwareIDs { + if err := checkID("ID de hardware", id, false); err != nil { + return nil, err + } + d.HardwareIDs = append(d.HardwareIDs, id) + } + for _, id := range r.CompatibleIDs { + if err := checkID("ID compatível", id, false); err != nil { + return nil, err + } + d.CompatibleIDs = append(d.CompatibleIDs, id) + } + out = append(out, d) + } + return out, nil +} + +// DeviceTree é a árvore de pais dos dispositivos presentes. +type DeviceTree struct { + devs []Device + byKey map[string]int // instância em minúsculas -> índice +} + +func lk(s string) string { return strings.ToLower(s) } + +// NewDeviceTree monta a árvore e RECUSA (ErrTreeIncomplete) instância repetida, pai desconhecido, ciclo e qualquer número de +// raízes diferente de um. Nada disso é "provavelmente seguro". +func NewDeviceTree(devs []Device) (*DeviceTree, error) { + t := &DeviceTree{devs: devs, byKey: make(map[string]int, len(devs))} + roots := 0 + for i, d := range devs { + k := lk(d.InstanceID) + if _, dup := t.byKey[k]; dup { + return nil, fmt.Errorf("%w: instância repetida (%s)", ErrTreeIncomplete, textsafe.Line(d.InstanceID)) + } + t.byKey[k] = i + if d.Parent == "" { + roots++ + } + } + if roots != 1 { + return nil, fmt.Errorf("%w: a árvore tem %d raiz(es), esperada 1", ErrTreeIncomplete, roots) + } + for _, d := range devs { + if d.Parent == "" { + continue + } + if _, ok := t.byKey[lk(d.Parent)]; !ok { + return nil, fmt.Errorf("%w: o pai de %q não aparece na leitura", ErrTreeIncomplete, d.Name) + } + } + for _, d := range devs { // ciclo: subir mais vezes que o número de nós + cur, steps := d, 0 + for cur.Parent != "" { + steps++ + if steps > len(devs) { + return nil, fmt.Errorf("%w: ciclo de pais em %q", ErrTreeIncomplete, d.Name) + } + cur = devs[t.byKey[lk(cur.Parent)]] + } + } + return t, nil +} + +// Get devolve o dispositivo pela instância. +func (t *DeviceTree) Get(inst string) (Device, bool) { + i, ok := t.byKey[lk(inst)] + if !ok { + return Device{}, false + } + return t.devs[i], true +} + +// Ancestors devolve as instâncias dos pais, do mais próximo à raiz (sem o próprio). +func (t *DeviceTree) Ancestors(inst string) []string { + var out []string + d, ok := t.Get(inst) + for ok && d.Parent != "" { + out = append(out, d.Parent) + d, ok = t.Get(d.Parent) + } + return out +} + +// busOf diz o barramento pelo prefixo do ID de instância (o que o PnP usa para separar os enumeradores). +func busOf(inst string) string { + pre, rest, found := strings.Cut(inst, `\`) + if !found { + return "outro" + } + switch strings.ToUpper(pre) { + case "USB", "USBSTOR", "USBPRINT": + return "USB" + case "BTHENUM", "BTHLE", "BTH": + return "Bluetooth" + case "ACPI": + seg, _, _ := strings.Cut(strings.ToUpper(rest), `\`) + if strings.HasPrefix(seg, "PNP03") || strings.HasPrefix(seg, "PNP0F") { + return "PS/2" + } + return "ACPI" + case "HTREE": + return "raiz" + } + return strings.ToUpper(pre) +} + +// vidpid extrai "VVVV:PPPP" (maiúsculas) de um ID com VID_xxxx&PID_xxxx. +func vidpid(id string) (string, bool) { + m := reVIDPID.FindStringSubmatch(id) + if m == nil { + return "", false + } + return strings.ToUpper(m[1]) + ":" + strings.ToUpper(m[2]), true +} diff --git a/internal/usb/pnp_test.go b/internal/usb/pnp_test.go new file mode 100644 index 0000000..b0bdece --- /dev/null +++ b/internal/usb/pnp_test.go @@ -0,0 +1,149 @@ +package usb + +import ( + "errors" + "strings" + "testing" +) + +func TestParseDevicesValido(t *testing.T) { + js := `{"count":2,"devices":[ + {"InstanceId":"HTREE\\ROOT\\0","Parent":"","Name":"Raiz","Class":"System","ClassGuid":"{4d36e97d-e325-11ce-bfc1-08002be10318}","HardwareIds":"HTREE\\ROOT\\0","CompatibleIds":null}, + {"InstanceId":"USB\\VID_FFFF&PID_0001\\1","Parent":"HTREE\\ROOT\\0","Name":"Teclado","Class":"USB","ClassGuid":"{36fc9e60-c465-11cf-8056-444553540000}","HardwareIds":["USB\\VID_FFFF&PID_0001&REV_0100","USB\\VID_FFFF&PID_0001"],"CompatibleIds":["USB\\COMPOSITE"]}]}` + devs, err := ParseDevices([]byte(js)) + if err != nil { + t.Fatal(err) + } + if len(devs) != 2 { + t.Fatalf("devs = %d", len(devs)) + } + // o PowerShell devolve UM único ID como texto, não como lista + if len(devs[0].HardwareIDs) != 1 || devs[0].HardwareIDs[0] != `HTREE\ROOT\0` { + t.Fatalf("hardware ids de um só valor: %#v", devs[0].HardwareIDs) + } + if len(devs[1].HardwareIDs) != 2 || devs[1].CompatibleIDs[0] != `USB\COMPOSITE` { + t.Fatalf("ids: %#v", devs[1]) + } +} + +func TestParseDevicesRecusaLeituraIncompleta(t *testing.T) { + cases := map[string]string{ + "json cortado": `{"count":2,"devices":[{"InstanceId":"A\\B","Parent":"","Name":"x","Class":"System","ClassGuid":"","HardwareIds":[],"CompatibleIds":[]}`, + "contagem diferente": `{"count":3,"devices":[{"InstanceId":"A\\B","Parent":"","Name":"x","Class":"System","ClassGuid":"","HardwareIds":[],"CompatibleIds":[]}]}`, + "sem dispositivos": `{"count":0,"devices":[]}`, + "vazio": ``, + "lixo": `not json`, + "sem instancia": `{"count":1,"devices":[{"InstanceId":"","Parent":"","Name":"x","Class":"System","ClassGuid":"","HardwareIds":[],"CompatibleIds":[]}]}`, + "id com controle": "{\"count\":1,\"devices\":[{\"InstanceId\":\"A\\\\B\\u001b[2J\",\"Parent\":\"\",\"Name\":\"x\",\"Class\":\"System\",\"ClassGuid\":\"\",\"HardwareIds\":[],\"CompatibleIds\":[]}]}", + "id enorme": `{"count":1,"devices":[{"InstanceId":"` + strings.Repeat("A", 400) + `","Parent":"","Name":"x","Class":"System","ClassGuid":"","HardwareIds":[],"CompatibleIds":[]}]}`, + } + for name, js := range cases { + if _, err := ParseDevices([]byte(js)); err == nil { + t.Errorf("%s: aceitou leitura inválida", name) + } + } +} + +func TestParseDevicesNeutralizaTextoMalicioso(t *testing.T) { + js := "{\"count\":1,\"devices\":[{\"InstanceId\":\"HTREE\\\\ROOT\\\\0\",\"Parent\":\"\",\"Name\":\"Teclado\\u001b[31m\\u202eevil\",\"Class\":\"System\",\"ClassGuid\":\"\",\"HardwareIds\":[],\"CompatibleIds\":[]}]}" + devs, err := ParseDevices([]byte(js)) + if err != nil { + t.Fatal(err) + } + n := devs[0].Name + if strings.ContainsRune(n, 0x1b) || strings.ContainsRune(n, 0x202e) { + t.Fatalf("nome com ESC/bidi não foi neutralizado: %q", n) + } +} + +func TestParseDevicesAceitaBOM(t *testing.T) { + js := "\ufeff" + `{"count":1,"devices":[{"InstanceId":"HTREE\\ROOT\\0","Parent":"","Name":"Raiz","Class":"System","ClassGuid":"","HardwareIds":[],"CompatibleIds":[]}]}` + if _, err := ParseDevices([]byte(js)); err != nil { + t.Fatal(err) + } +} + +func TestArvoreCompletaDaMaquinaBase(t *testing.T) { + tr, err := NewDeviceTree(machine(usbKeyboard("0001"))) + if err != nil { + t.Fatal(err) + } + kb := `HID\VID_FFFF&PID_0001&MI_00\8&bbbb&0&0000` + got := tr.Ancestors(kb) + if len(got) != 6 || got[len(got)-1] != rootID { + t.Fatalf("ancestrais do teclado = %v", got) + } +} + +func TestArvoreIncompletaRecusa(t *testing.T) { + devs := machine(usbKeyboard("0001")) + // remove o hub raiz: o teclado USB fica com pai desconhecido + var cut []Device + for _, d := range devs { + if d.InstanceID != hub30 { + cut = append(cut, d) + } + } + if _, err := NewDeviceTree(cut); !errors.Is(err, ErrTreeIncomplete) { + t.Fatalf("err = %v, queria ErrTreeIncomplete", err) + } +} + +func TestArvoreSemRaizOuComDuasRaizesRecusa(t *testing.T) { + devs := baseMachine() + devs[1].Parent = "" // o HAL vira uma segunda raiz + if _, err := NewDeviceTree(devs); !errors.Is(err, ErrTreeIncomplete) { + t.Fatalf("duas raízes: %v", err) + } + if _, err := NewDeviceTree(baseMachine()[1:]); !errors.Is(err, ErrTreeIncomplete) { + t.Fatalf("sem a raiz: %v", err) + } +} + +func TestArvoreComCicloRecusa(t *testing.T) { + devs := baseMachine() + devs[1].Parent = `ACPI\PNP0303\4&2222&0` // HAL -> teclado -> HAL + if _, err := NewDeviceTree(devs); !errors.Is(err, ErrTreeIncomplete) { + t.Fatalf("ciclo: %v", err) + } +} + +func TestArvoreInstanciaRepetidaRecusa(t *testing.T) { + devs := append(baseMachine(), baseMachine()[2]) + if _, err := NewDeviceTree(devs); !errors.Is(err, ErrTreeIncomplete) { + t.Fatalf("duplicada: %v", err) + } +} + +func TestBarramentoPeloPrefixoDaInstancia(t *testing.T) { + cases := map[string]string{ + `USB\VID_FFFF&PID_0001\1`: "USB", + `USBSTOR\DISK&VEN_FAKE\0`: "USB", + `ACPI\PNP0303\4&2222&0`: "PS/2", + `ACPI\FFFF0001\4&3333&0`: "ACPI", + `BTHENUM\DEV_AABBCCDDEEFF\7&8`: "Bluetooth", + `BTHLE\DEV_AABBCCDDEEFF\7&8`: "Bluetooth", + `PCI\VEN_FFFF&DEV_0002\3&1`: "PCI", + `HID\FFFF0001&COL01\5&4444&0&0000`: "HID", + `SCSI\DISK&VEN_NVME&PROD_FAKE\5&5555&0`: "SCSI", + `HTREE\ROOT\0`: "raiz", + `SEMBARRA`: "outro", + } + for inst, want := range cases { + if got := busOf(inst); got != want { + t.Errorf("busOf(%q) = %q, queria %q", inst, got, want) + } + } +} + +func TestVIDPID(t *testing.T) { + if v, ok := vidpid(`USB\VID_ffff&PID_0001&REV_0100`); !ok || v != "FFFF:0001" { + t.Fatalf("vidpid = %q %v", v, ok) + } + if _, ok := vidpid(`PCI\CC_0C03`); ok { + t.Fatal("PCI\\CC_0C03 não tem VID/PID") + } + if _, ok := vidpid(`BTHENUM\VID&0001057e_PID&2009`); ok { + t.Fatal("formato Bluetooth (VID&...) não é VID_xxxx&PID_xxxx") + } +} diff --git a/internal/usb/policy.go b/internal/usb/policy.go new file mode 100644 index 0000000..04c1d7a --- /dev/null +++ b/internal/usb/policy.go @@ -0,0 +1,378 @@ +package usb + +import ( + "fmt" + "regexp" + "slices" + "sort" + "strconv" + "strings" + + "github.com/PiluTech/toolkit/internal/privacidade" +) + +// Entry é uma escrita da política: caminho RELATIVO a Restrictions e o valor. +type Entry struct { + Path string + Value RegValue +} + +// Nomes da lista fechada de valores/subchaves (relativos a RestrictionsKey). +const ( + nameLayered = "AllowDenyLayered" + nameAllow = "AllowDeviceIDs" + nameDeny = "DenyDeviceClasses" +) + +var reIDValue = regexp.MustCompile(`^[A-Za-z0-9_\\&.{}-]{1,200}$`) + +// checkRel confere um caminho relativo contra a LISTA FECHADA de alvos: os três valores de ligação e os valores numerados +// (1..MaxAllowIDs, sem zero à esquerda) das duas subchaves. Qualquer outro caminho (DenyUnspecified, DenyDeviceIDs, +// "..", outra raiz, maiúsculas diferentes) é recusado ANTES de tocar no registro. +func checkRel(rel string) error { + switch rel { + case nameLayered, nameAllow, nameDeny: + return nil + } + sub, num, ok := strings.Cut(rel, `\`) + if ok { + limit := 0 + switch sub { + case nameAllow: + limit = MaxAllowIDs + case nameDeny: + limit = len(denyClassGUIDs) + } + n, err := strconv.Atoi(num) + if limit > 0 && err == nil && n >= 1 && n <= limit && strconv.Itoa(n) == num { + return nil + } + } + return fmt.Errorf("%w: %q não está na lista fechada de alvos do toolkit", ErrEntradaInvalida, printableRel(rel)) +} + +func printableRel(s string) string { + r := []rune(s) + if len(r) > 60 { + r = append(r[:60], '…') + } + for i, c := range r { + if c < 0x20 || c == 0x7f { + r[i] = '?' + } + } + return string(r) +} + +// checkWrite confere caminho E valor: os três valores de ligação são DWORD 1; os numerados são texto no formato de ID. +func checkWrite(rel string, v RegValue) error { + if err := checkRel(rel); err != nil { + return err + } + switch rel { + case nameLayered, nameAllow, nameDeny: + if v.Kind != privacidade.RegDWORD || v.DWORD != 1 { + return fmt.Errorf("%w: %s só aceita DWORD 1", ErrEntradaInvalida, rel) + } + return nil + } + if v.Kind != privacidade.RegString || !reIDValue.MatchString(v.Str) { + return fmt.Errorf("%w: valor de %s fora do formato de ID", ErrEntradaInvalida, rel) + } + return nil +} + +// Policy é a política que o toolkit grava: ordem em camadas, liberação por ID e negação só das duas classes de USB. +type Policy struct { + AllowIDs []string + DenyClasses []string +} + +// Entries devolve as escritas NA ORDEM SEGURA: a camada primeiro (sem ela a negação venceria a liberação e tudo de USB seria +// bloqueado), depois a lista de IDs e só então a negação, por último. +func (p Policy) Entries() []Entry { + out := []Entry{{nameLayered, DWORD(1)}} + for i, id := range p.AllowIDs { + out = append(out, Entry{nameAllow + `\` + strconv.Itoa(i+1), String(id)}) + } + out = append(out, Entry{nameAllow, DWORD(1)}) + for i, c := range p.DenyClasses { + out = append(out, Entry{nameDeny + `\` + strconv.Itoa(i+1), String(c)}) + } + return append(out, Entry{nameDeny, DWORD(1)}) +} + +// verdict avalia UM dispositivo na ordem em camadas: ID (hardware E compatíveis) > classe > sem regra (permitido, porque o +// toolkit não liga DenyUnspecified). +func (p Policy) verdict(d Device) (bool, string) { + allow := make(map[string]bool, len(p.AllowIDs)) + for _, id := range p.AllowIDs { + allow[lk(id)] = true + } + for _, id := range slices.Concat(d.HardwareIDs, d.CompatibleIDs) { + if allow[lk(id)] { + return true, "permitido pelo ID " + id + } + } + for _, c := range p.DenyClasses { + if d.ClassGUID != "" && strings.EqualFold(c, d.ClassGUID) { + return false, "a classe " + classLabel(d) + " é negada pela política e o dispositivo não está na lista de IDs" + } + } + return true, "nenhuma regra o nega (a classe " + classLabel(d) + " não está na lista de bloqueio)" +} + +func classLabel(d Device) string { + if d.Class != "" { + return d.Class + } + return "sem classe" +} + +// ProofLine é a evidência de UM dispositivo essencial: nome, classe, barramento, se fica permitido e por quê. +type ProofLine struct { + Name, Class, Bus string + Allowed bool + By string + Chain []string // nomes dos pais, do mais próximo à raiz +} + +// Proof é a prova de que os dispositivos essenciais continuam permitidos. OK só quando há linhas, nenhuma bloqueada e o +// disco interno foi visto. +type Proof struct { + Lines []ProofLine + Failures []string + OK bool +} + +// Unit é um dispositivo USB que o usuário vê (e marca ou desmarca): um nó USB que não é interface (&MI_) nem hub raiz. +type Unit struct { + Key string // ID de instância + Name string + VIDPID string + Class string + Selected bool + Essential bool // contém teclado, mouse ou outro HID: desmarcar recusa + Blocked bool // a política o bloquearia ao reconectar + IDs []string +} + +// Analysis é o resultado da análise do PnP: a política candidata, os dispositivos e a prova. +type Analysis struct { + Policy Policy + Units []Unit + Proof Proof +} + +func isUnitNode(d Device) bool { + pre, rest, ok := strings.Cut(d.InstanceID, `\`) + if !ok || !strings.EqualFold(pre, "USB") { + return false + } + seg, _, _ := strings.Cut(strings.ToUpper(rest), `\`) + return !strings.Contains(seg, "&MI_") && !strings.HasPrefix(seg, "ROOT_HUB") +} + +func essentialByClass(d Device, attached bool) bool { + switch strings.ToLower(d.Class) { + case "keyboard", "mouse", "hidclass": + return true + case "diskdrive", "hdc", "scsiadapter", "usb": + return !attached // disco, controlador e hub raiz INTERNOS; os USB externos são escolha do usuário + } + return false +} + +// Analyze monta a política candidata (IDs de hardware com VID/PID dos USB conectados e marcados, mais o conjunto genérico +// fechado) e PROVA, avaliando-a contra a árvore de pais, que todo dispositivo essencial continua permitido. excluded são +// as instâncias (Unit.Key) desmarcadas; uma instância que não existe mais é erro (seleção velha). Árvore incompleta = +// ErrTreeIncomplete. +func Analyze(devs []Device, excluded []string) (*Analysis, error) { + tree, err := NewDeviceTree(devs) + if err != nil { + return nil, err + } + // dono USB de cada nó: o USB visível mais próximo, subindo a partir dele. + owner := make(map[string]string, len(devs)) + var ownerOf func(d Device) string + ownerOf = func(d Device) string { + if o, ok := owner[lk(d.InstanceID)]; ok { + return o + } + o := "" + switch { + case isUnitNode(d): + o = d.InstanceID + case d.Parent != "": + p, _ := tree.Get(d.Parent) + o = ownerOf(p) + } + owner[lk(d.InstanceID)] = o + return o + } + units := map[string]*Unit{} + var order []string + for _, d := range devs { + if isUnitNode(d) { + v, _ := vidpid(d.InstanceID) + units[lk(d.InstanceID)] = &Unit{Key: d.InstanceID, Name: d.Name, VIDPID: v, Class: d.Class, Selected: true} + order = append(order, lk(d.InstanceID)) + } + } + for _, x := range excluded { + u, ok := units[lk(x)] + if !ok { + return nil, fmt.Errorf("o dispositivo %q não está conectado (a seleção é de uma leitura antiga: veja o plano de novo)", printableRel(x)) + } + u.Selected = false + } + + // política: o conjunto genérico fechado + VID/PID de todo nó dos USB marcados + ids := map[string]string{} + for _, g := range genericAllowIDs { + ids[lk(g)] = g + } + for _, d := range devs { + u := units[lk(ownerOf(d))] + if u == nil || !u.Selected { + continue + } + for _, h := range d.HardwareIDs { // só ID de HARDWARE com VID e PID; compatível nunca entra + if _, ok := vidpid(h); ok && reIDValue.MatchString(h) { + ids[lk(h)] = h + u.IDs = append(u.IDs, h) + } + } + } + pol := Policy{DenyClasses: slices.Clone(denyClassGUIDs)} + for _, v := range ids { + pol.AllowIDs = append(pol.AllowIDs, v) + } + sort.Strings(pol.AllowIDs) + if len(pol.AllowIDs) > MaxAllowIDs { + return nil, fmt.Errorf("%w: a lista teria %d IDs (limite %d)", ErrNoProof, len(pol.AllowIDs), MaxAllowIDs) + } + + // efetivo: um nó é bloqueado se ELE ou qualquer pai for bloqueado + eff := map[string]bool{} + why := map[string]string{} + var effective func(d Device) bool + effective = func(d Device) bool { + k := lk(d.InstanceID) + if v, ok := eff[k]; ok { + return v + } + ok, by := pol.verdict(d) + why[k] = by + if ok && d.Parent != "" { + p, _ := tree.Get(d.Parent) + if !effective(p) { + ok = false + why[k] = "bloqueado porque um dispositivo pai (" + p.Name + ") fica bloqueado" + } + } + eff[k] = ok + return ok + } + + // dispositivos essenciais (qualquer barramento) e, para os USB, todos os nós do mesmo dispositivo (composto) + ess := map[string]bool{} + for _, d := range devs { + if essentialByClass(d, ownerOf(d) != "") { + ess[lk(d.InstanceID)] = true + } + } + for _, d := range devs { + if o := ownerOf(d); o != "" && ess[lk(d.InstanceID)] { + units[lk(o)].Essential = true + } + } + for _, d := range devs { + if o := ownerOf(d); o != "" && units[lk(o)].Essential { + ess[lk(d.InstanceID)] = true + } + } + + var pr Proof + haveDisk := false + for _, d := range devs { + if !ess[lk(d.InstanceID)] { + continue + } + if strings.EqualFold(d.Class, "DiskDrive") && ownerOf(d) == "" { + haveDisk = true + } + l := ProofLine{Name: d.Name, Class: d.Class, Bus: lineBus(d, tree), Allowed: effective(d), By: why[lk(d.InstanceID)]} + for _, a := range tree.Ancestors(d.InstanceID) { + p, _ := tree.Get(a) + l.Chain = append(l.Chain, p.Name) + } + pr.Lines = append(pr.Lines, l) + if !l.Allowed { + pr.Failures = append(pr.Failures, fmt.Sprintf("%s (%s, %s) ficaria BLOQUEADO: %s", l.Name, classLabel(d), l.Bus, l.By)) + } + } + // Teclado, mouse ou outro HID DESMARCADO é recusa por regra, qualquer que seja a classe do nó USB: a política só nega as duas + // classes de USB, então um dispositivo simples (nó de classe HIDClass) ficaria "permitido" pelo avaliador mesmo desmarcado; + // o toolkit não aceita deixar um essencial fora da lista. + for _, k := range order { + if u := units[k]; u.Essential && !u.Selected { + pr.Failures = append(pr.Failures, fmt.Sprintf("%s (%s) está desmarcado, mas contém teclado, mouse ou outro HID: o toolkit recusa deixá-lo fora da lista (marque-o de volta)", u.Name, dashStr(u.VIDPID))) + } + } + if !haveDisk { + pr.Failures = append(pr.Failures, "nenhum disco interno apareceu na leitura: não dá para provar que o disco do sistema continua permitido") + } + sort.SliceStable(pr.Lines, func(i, j int) bool { + a, b := pr.Lines[i], pr.Lines[j] + if a.Bus != b.Bus { + return a.Bus < b.Bus + } + if a.Class != b.Class { + return a.Class < b.Class + } + return a.Name < b.Name + }) + pr.OK = len(pr.Failures) == 0 && len(pr.Lines) > 0 + + an := &Analysis{Policy: pol, Proof: pr} + for _, k := range order { + u := units[k] + d, _ := tree.Get(u.Key) + u.Blocked = !effective(d) + slices.Sort(u.IDs) + u.IDs = slices.Compact(u.IDs) + an.Units = append(an.Units, *u) + } + sort.SliceStable(an.Units, func(i, j int) bool { + if an.Units[i].Name != an.Units[j].Name { + return an.Units[i].Name < an.Units[j].Name + } + return an.Units[i].Key < an.Units[j].Key + }) + return an, nil +} + +func dashStr(s string) string { + if s == "" { + return "-" + } + return s +} + +// lineBus é o barramento mostrado na prova: o do nó; HID herda o do pai (o HID é lógico, o físico é o do pai). +func lineBus(d Device, tree *DeviceTree) string { + b := busOf(d.InstanceID) + cur := d + for b == "HID" && cur.Parent != "" { + p, ok := tree.Get(cur.Parent) + if !ok { + break + } + cur = p + if pb := busOf(p.InstanceID); pb != "HID" { + return pb + } + } + return b +} diff --git a/internal/usb/policy_test.go b/internal/usb/policy_test.go new file mode 100644 index 0000000..fb96c53 --- /dev/null +++ b/internal/usb/policy_test.go @@ -0,0 +1,385 @@ +package usb + +import ( + "context" + "errors" + "fmt" + "slices" + "strings" + "testing" +) + +func mustAnalyze(t *testing.T, devs []Device, excluded ...string) *Analysis { + t.Helper() + a, err := Analyze(devs, excluded) + if err != nil { + t.Fatalf("Analyze: %v", err) + } + return a +} + +func proofFor(a *Analysis, name string) *ProofLine { + for i := range a.Proof.Lines { + if a.Proof.Lines[i].Name == name { + return &a.Proof.Lines[i] + } + } + return nil +} + +func TestMaquinaBaseComTecladoUSBTemProvaCompleta(t *testing.T) { + a := mustAnalyze(t, machine(usbKeyboard("0001"))) + if !a.Proof.OK { + t.Fatalf("prova falhou: %v", a.Proof.Failures) + } + // essenciais de TODOS os barramentos aparecem na prova, todos permitidos + for _, n := range []string{"Teclado PS/2 padrão", "Touchpad I2C HID", "Teclado Bluetooth", "Disco NVMe", "Disco SATA", "Controlador NVMe", "Controlador SATA", "Controlador xHCI", "Hub raiz USB 3", "Teclado HID", "Controle de mídia HID"} { + l := proofFor(a, n) + if l == nil { + t.Errorf("%q fora da prova", n) + continue + } + if !l.Allowed { + t.Errorf("%q bloqueado na prova", n) + } + } +} + +func TestTecladoI2CPS2BluetoothNaoSaoAfetados(t *testing.T) { + a := mustAnalyze(t, machine()) + for _, n := range []string{"Teclado PS/2 padrão", "Touchpad I2C HID", "Teclado Bluetooth"} { + l := proofFor(a, n) + if l == nil || !l.Allowed { + t.Fatalf("%q deveria estar permitido: %#v", n, l) + } + if !strings.Contains(l.By, "nenhuma regra") { + t.Errorf("%q: evidência = %q", n, l.By) + } + } + if proofFor(a, "Touchpad I2C HID").Bus != "ACPI" { + t.Errorf("barramento do touchpad = %q", proofFor(a, "Touchpad I2C HID").Bus) + } +} + +func TestDiscosNVMeESATAEControladoresPermitidos(t *testing.T) { + a := mustAnalyze(t, machine()) + for _, n := range []string{"Disco NVMe", "Controlador NVMe", "Disco SATA", "Controlador SATA"} { + if l := proofFor(a, n); l == nil || !l.Allowed { + t.Errorf("%q deveria estar permitido", n) + } + } +} + +func TestPoliticaNuncaContemClasseAmplaNemDenyUnspecified(t *testing.T) { + a := mustAnalyze(t, machine(usbKeyboard("0001"), usbPendrive("0003"))) + for _, c := range a.Policy.DenyClasses { + low := strings.ToLower(c) + for _, bad := range []string{guidKeyboard, guidMouse, guidHID, guidDisk, guidHDC, guidSCSI, guidBT, guidSystem} { + if low == bad { + t.Fatalf("classe ampla %s no bloqueio", c) + } + } + } + want := []string{"{36fc9e60-c465-11cf-8056-444553540000}", "{88bae032-5a81-49f0-bc3d-a4ff138216d6}"} + var got []string + for _, c := range a.Policy.DenyClasses { + got = append(got, strings.ToLower(c)) + } + if !slices.Equal(got, want) { + t.Fatalf("classes negadas = %v", got) + } + for _, e := range a.Policy.Entries() { + if strings.Contains(e.Path, "DenyUnspecified") || strings.Contains(e.Path, "DenyDeviceIDs") || strings.Contains(e.Path, "Retroactive") { + t.Fatalf("a política escreveu %q", e.Path) + } + } +} + +func TestListaSoTemVIDPIDOuOsGenericosFechados(t *testing.T) { + a := mustAnalyze(t, machine(usbKeyboard("0001"), usbPendrive("0003"))) + for _, id := range a.Policy.AllowIDs { + if _, ok := vidpid(id); ok { + continue + } + if !slices.Contains(genericAllowIDs, id) { + t.Errorf("ID %q na lista: nem VID/PID nem do conjunto genérico fechado", id) + } + } + for _, g := range genericAllowIDs { + if !slices.Contains(a.Policy.AllowIDs, g) { + t.Errorf("genérico %q ausente da lista", g) + } + } + // ID compatível genérico NUNCA entra (liberaria a classe inteira) + for _, bad := range []string{`USB\COMPOSITE`, `HID_DEVICE`, `HID_DEVICE_SYSTEM_KEYBOARD`, `USB\Class_03`, `HID_DEVICE_UP:0001_U:0006`} { + if slices.Contains(a.Policy.AllowIDs, bad) { + t.Errorf("ID compatível genérico %q entrou na lista", bad) + } + } +} + +func TestListaIncluiTodosOsNosDoComposto(t *testing.T) { + a := mustAnalyze(t, machine(usbKeyboard("0001"))) + for _, id := range []string{ + `USB\VID_FFFF&PID_0001`, `USB\VID_FFFF&PID_0001&REV_0100`, + `USB\VID_FFFF&PID_0001&MI_00`, `USB\VID_FFFF&PID_0001&MI_01`, + `HID\VID_FFFF&PID_0001&MI_00`, `HID\VID_FFFF&PID_0001&MI_01`, + } { + if !slices.Contains(a.Policy.AllowIDs, id) { + t.Errorf("ID do nó %q fora da lista", id) + } + } +} + +func TestDispositivosListadosSoSaoUSBConectados(t *testing.T) { + a := mustAnalyze(t, machine(usbKeyboard("0001"), usbPendrive("0003"))) + var names []string + for _, u := range a.Units { + names = append(names, u.Name) + if !u.Selected { + t.Errorf("%q deveria vir marcado por padrão", u.Name) + } + if u.VIDPID == "" { + t.Errorf("%q sem VID:PID", u.Name) + } + } + slices.Sort(names) + want := []string{"Pendrive USB", "Rádio Bluetooth", "Teclado USB composto"} + if !slices.Equal(names, want) { + t.Fatalf("dispositivos = %v, queria %v (nunca interno não-USB, nunca hub raiz)", names, want) + } +} + +func TestTecladoDesmarcadoRecusa(t *testing.T) { + devs := machine(usbKeyboard("0001"), usbPendrive("0003")) + a := mustAnalyze(t, devs, `USB\VID_FFFF&PID_0001\6&9999&0&1`) + if a.Proof.OK { + t.Fatal("teclado conectado desmarcado: a prova NÃO pode passar") + } + if len(a.Proof.Failures) == 0 || !strings.Contains(strings.Join(a.Proof.Failures, "\n"), "Teclado") { + t.Fatalf("falhas = %v", a.Proof.Failures) + } + if l := proofFor(a, "Teclado HID"); l == nil || l.Allowed { + t.Fatalf("o nó HID do teclado desmarcado devia aparecer bloqueado: %#v", l) + } +} + +func TestMouseDesmarcadoRecusa(t *testing.T) { + mouse := []Device{ + dev(`USB\VID_FFFF&PID_0007\6&mouse&0&3`, hub30, "Mouse USB", "USB", []string{`USB\VID_FFFF&PID_0007&REV_0100`, `USB\VID_FFFF&PID_0007`}), + dev(`HID\VID_FFFF&PID_0007\8&mouse&0&0000`, `USB\VID_FFFF&PID_0007\6&mouse&0&3`, "Mouse HID", "Mouse", []string{`HID\VID_FFFF&PID_0007&REV_0100`, `HID\VID_FFFF&PID_0007`}), + } + devs := machine(usbKeyboard("0001"), mouse) + if a := mustAnalyze(t, devs); !a.Proof.OK { + t.Fatalf("com tudo marcado deveria passar: %v", a.Proof.Failures) + } + if a := mustAnalyze(t, devs, `USB\VID_FFFF&PID_0007\6&mouse&0&3`); a.Proof.OK { + t.Fatal("mouse desmarcado: a prova NÃO pode passar") + } +} + +func TestPendriveDesmarcadoPassaEFicaBloqueado(t *testing.T) { + devs := machine(usbKeyboard("0001"), usbPendrive("0003")) + a := mustAnalyze(t, devs, `USB\VID_FFFF&PID_0003\0&pen&0&2`) + if !a.Proof.OK { + t.Fatalf("o pendrive não é essencial: %v", a.Proof.Failures) + } + if slices.Contains(a.Policy.AllowIDs, `USB\VID_FFFF&PID_0003`) { + t.Fatal("pendrive desmarcado entrou na lista") + } + for _, u := range a.Units { + if u.Name == "Pendrive USB" && (u.Selected || u.Blocked != true) { + t.Fatalf("unidade do pendrive: %#v", u) + } + } +} + +func TestPendriveSemTecladoEDiscoUSBNaoSaoEssenciais(t *testing.T) { + a := mustAnalyze(t, machine(usbPendrive("0003"))) + if proofFor(a, "Pendrive (disco)") != nil { + t.Fatal("disco USB removível não é o disco do sistema: não é essencial") + } + if proofFor(a, "Disco NVMe") == nil { + t.Fatal("disco interno é essencial") + } +} + +func TestRadioBluetoothDesmarcadoBloqueiaOTecladoBluetooth(t *testing.T) { + devs := machine() + a := mustAnalyze(t, devs, `USB\VID_FFFF&PID_0002\5&7777&0&1`) + if a.Proof.OK { + t.Fatal("sem o rádio Bluetooth o teclado Bluetooth perde o pai: a prova NÃO pode passar") + } + if l := proofFor(a, "Teclado Bluetooth"); l == nil || l.Allowed { + t.Fatalf("teclado Bluetooth deveria estar bloqueado por herança: %#v", l) + } +} + +func TestNoDoCompostoSemVIDPIDBloqueadoRecusa(t *testing.T) { + devs := machine(usbKeyboard("0001")) + // um nó do composto sem VID/PID em nenhum ID de hardware, da classe USBDevice (negada): bloquearia o conjunto + devs = append(devs, dev(`USB\VID_FFFF&PID_0001&MI_02\7&aaaa&0&0002`, `USB\VID_FFFF&PID_0001\6&9999&0&1`, "Interface genérica", "USBDevice", []string{`USB\INTERFACE_SEM_ID`})) + a := mustAnalyze(t, devs) + if a.Proof.OK { + t.Fatal("nó do composto bloqueado: a prova NÃO pode passar (todos os nós têm de ficar permitidos)") + } + if !strings.Contains(strings.Join(a.Proof.Failures, "\n"), "Interface genérica") { + t.Fatalf("falhas = %v", a.Proof.Failures) + } +} + +func TestControladorUSBSemIDGenericoRecusa(t *testing.T) { + devs := baseMachine() + i := idx(devs, "Controlador xHCI") + devs[i].CompatibleIDs = []string{`PCI\CC_9999`} // sem PCI\CC_0C03: ficaria bloqueado pela classe USB + a := mustAnalyze(t, devs) + if a.Proof.OK { + t.Fatal("controlador USB bloqueado: a prova NÃO pode passar") + } +} + +func TestIDCompativelCasaComALista(t *testing.T) { + // o controlador xHCI só casa pelo ID COMPATÍVEL PCI\CC_0C03: a avaliação olha hardware E compatíveis + a := mustAnalyze(t, baseMachine()) + if l := proofFor(a, "Controlador xHCI"); l == nil || !l.Allowed || !strings.Contains(l.By, `PCI\CC_0C03`) { + t.Fatalf("controlador xHCI: %#v", l) + } +} + +func TestCasamentoDeIDIgnoraMaiusculas(t *testing.T) { + devs := machine(usbKeyboard("0001")) + for i := range devs { + if devs[i].Name == "Teclado USB composto" { + devs[i].HardwareIDs = []string{`usb\vid_ffff&pid_0001&rev_0100`, `usb\vid_ffff&pid_0001`} + } + } + if a := mustAnalyze(t, devs); !a.Proof.OK { + t.Fatalf("IDs em minúsculas deveriam casar: %v", a.Proof.Failures) + } +} + +func TestArvoreIncompletaNaAnaliseRecusa(t *testing.T) { + devs := machine(usbKeyboard("0001")) + var cut []Device + for _, d := range devs { + if d.InstanceID != hub30 { + cut = append(cut, d) + } + } + if _, err := Analyze(cut, nil); !errors.Is(err, ErrTreeIncomplete) { + t.Fatalf("err = %v", err) + } +} + +func TestExclusaoDeInstanciaDesconhecidaRecusa(t *testing.T) { + if _, err := Analyze(machine(), []string{`USB\VID_FFFF&PID_9999\nao-existe`}); err == nil { + t.Fatal("exclusão de dispositivo que não existe deve ser erro (seleção velha)") + } +} + +func TestMuitosIDsRecusa(t *testing.T) { + devs := machine() + for i := 0; i < MaxAllowIDs+5; i++ { + pid := fmt.Sprintf("%04X", i) + inst := `USB\VID_FFFE&PID_` + pid + `\x` + pid + devs = append(devs, dev(inst, hub30, "USB "+pid, "USBDevice", []string{`USB\VID_FFFE&PID_` + pid})) + } + if _, err := Analyze(devs, nil); err == nil { + t.Fatal("lista acima do limite deveria recusar") + } +} + +func TestEntradasDaPoliticaEmOrdemSegura(t *testing.T) { + a := mustAnalyze(t, machine(usbKeyboard("0001"))) + es := a.Policy.Entries() + if es[0].Path != "AllowDenyLayered" { + t.Fatalf("a camada tem de ser a PRIMEIRA escrita (sem ela o Deny vence o Allow): %q", es[0].Path) + } + last := es[len(es)-1] + if last.Path != "DenyDeviceClasses" { + t.Fatalf("a negação tem de ser a ÚLTIMA escrita: %q", last.Path) + } + posAllow, posAllowFlag := -1, -1 + for i, e := range es { + switch e.Path { + case "AllowDeviceIDs": + posAllowFlag = i + case `AllowDeviceIDs\1`: + posAllow = i + } + if err := checkRel(e.Path); err != nil { + t.Errorf("caminho %q fora da lista fechada: %v", e.Path, err) + } + } + if posAllow < 0 || posAllowFlag < posAllow { + t.Fatalf("a lista tem de ser gravada antes de ligar AllowDeviceIDs: %d %d", posAllow, posAllowFlag) + } +} + +func TestCheckRelListaFechada(t *testing.T) { + ok := []string{"AllowDenyLayered", "AllowDeviceIDs", "DenyDeviceClasses", `AllowDeviceIDs\1`, `AllowDeviceIDs\200`, `DenyDeviceClasses\2`} + for _, p := range ok { + if err := checkRel(p); err != nil { + t.Errorf("%q deveria passar: %v", p, err) + } + } + bad := []string{"", "DenyUnspecified", "DenyDeviceIDs", `DenyDeviceIDs\1`, `AllowDeviceIDs\0`, `AllowDeviceIDs\201`, `AllowDeviceIDs\01`, `AllowDeviceIDs\a`, + `..\Run`, `AllowDeviceIDs\..\x`, `HKLM\SOFTWARE\x`, `allowdeviceids`, `AllowDeviceIDs\`, `AllowDeviceIDs\1\2`, "AllowDenyLayered ", `DenyDeviceClasses\3`} + for _, p := range bad { + if err := checkRel(p); !errors.Is(err, ErrEntradaInvalida) { + t.Errorf("%q deveria ser recusado: %v", p, err) + } + } +} + +// Mouse USB SIMPLES (não composto): o nó USB do dispositivo é de classe HIDClass ("USB Input Device"), que a política NÃO +// nega. Desmarcá-lo o tiraria da lista sem que o avaliador o bloqueasse: a regra "essencial desmarcado = recusa" é +// explícita e independe da classe (revisão do advisor). +func simpleMouse() []Device { + top := `USB\VID_FFFF&PID_0008\6&smp&0&3` + return []Device{ + dev(top, hub30, "Mouse USB simples", "HIDClass", []string{`USB\VID_FFFF&PID_0008&REV_0100`, `USB\VID_FFFF&PID_0008`}), + dev(`HID\VID_FFFF&PID_0008\8&smp&0&0000`, top, "Mouse HID simples", "Mouse", []string{`HID\VID_FFFF&PID_0008&REV_0100`, `HID\VID_FFFF&PID_0008`}), + } +} + +func TestMouseUSBSimplesDesmarcadoRecusaMesmoSemBloqueioPelaClasse(t *testing.T) { + devs := machine(usbKeyboard("0001"), simpleMouse()) + if a := mustAnalyze(t, devs); !a.Proof.OK { + t.Fatalf("com tudo marcado deveria passar: %v", a.Proof.Failures) + } + a := mustAnalyze(t, devs, `USB\VID_FFFF&PID_0008\6&smp&0&3`) + if a.Proof.OK { + t.Fatal("mouse simples desmarcado: a prova NÃO pode passar (a política não o bloquearia, mas o essencial não pode ficar fora da lista)") + } + if !strings.Contains(strings.Join(a.Proof.Failures, "\n"), "Mouse USB simples") || !strings.Contains(strings.Join(a.Proof.Failures, "\n"), "desmarcado") { + t.Fatalf("falhas = %v", a.Proof.Failures) + } + for _, u := range a.Units { + if u.Name == "Mouse USB simples" && (u.Selected || u.Blocked || !u.Essential) { + t.Fatalf("o avaliador não bloquearia o nó HIDClass: %#v", u) + } + } +} + +func TestPlanoDizQueDesmarcadoNaoBloqueadoPelaPoliticaNaoEBloqueado(t *testing.T) { + f := newFake(t) + f.devs = machine(usbKeyboard("0001"), simpleMouse(), []Device{ + dev(`USB\VID_FFFF&PID_0009\6&cam&0&4`, hub30, "Webcam USB simples", "HIDClass", []string{`USB\VID_FFFF&PID_0009`}), + }) + p, err := BuildPlan(context.Background(), f, []string{`USB\VID_FFFF&PID_0009\6&cam&0&4`}) + if err != nil { + t.Fatal(err) + } + // a webcam é HIDClass, então é essencial por classe (HID): desmarcar recusa; o texto não pode dizer BLOQUEADO + txt := p.Format() + if strings.Contains(txt, "Webcam USB simples FFFF:0009 classe HIDClass conectado agora · essencial (teclado, mouse ou outro HID) -> BLOQUEADO") { + t.Fatalf("disse BLOQUEADO para um nó que a política não bloqueia:\n%s", txt) + } + if !strings.Contains(txt, "NÃO o bloquearia") { + t.Fatalf("o plano devia dizer que a política não bloquearia:\n%s", txt) + } + if p.OK() { + t.Fatal("HID essencial desmarcado: plano recusado") + } +} diff --git a/internal/usb/revisao_crivo_test.go b/internal/usb/revisao_crivo_test.go new file mode 100644 index 0000000..df0867a --- /dev/null +++ b/internal/usb/revisao_crivo_test.go @@ -0,0 +1,146 @@ +package usb + +import ( + "context" + "errors" + "strings" + "testing" +) + +// Revisão do Crivo no #91 (reversão e pasta protegida). + +// 1) A reversão tinha UMA tentativa: se falhasse, a tarefa ficava concluída e o usuário, travado. +func TestArmTaskTentaMaisDeUmaVez(t *testing.T) { + s := armTaskScript(10) + for _, want := range []string{"-RestartCount 3", "-RestartInterval (New-TimeSpan -Minutes 1)"} { + if !strings.Contains(s, want) { + t.Errorf("o script da tarefa não tem %q: sem nova tentativa, uma falha deixa a política aplicada para sempre", want) + } + } +} + +// A tarefa já prova o SYSTEM: o reverter não pergunta IsAdmin (outro powershell.exe que pode falhar sem sessão e +// devolveria ErrNeedsAdmin sem escrever nada). Sem direito, o reg.exe falha sozinho: nada é escrito às cegas. +func TestReverterNaoDependeDeIsAdmin(t *testing.T) { + f := newFake(t) + st := f.fileStore() + mustApply(t, f, st) + f.admin = false + if _, err := Undo(context.Background(), f, st); !errors.Is(err, ErrNeedsAdmin) { + t.Fatalf("o desfazer do usuário continua exigindo administrador: %v", err) + } + res, err := Revert(context.Background(), f, st) + if err != nil || res.Restored == 0 { + t.Fatalf("o reverter (SYSTEM, sem IsAdmin) deveria restaurar: %+v %v", res, err) + } +} + +// A reversão que falha deixa rastro: `toolkit usb` e a TUI mostram "a reversão rodou e falhou: ...". +func TestReverterGravaORastro(t *testing.T) { + f := newFake(t) + st := f.fileStore() + mustApply(t, f, st) + // GPO/MDM muda um valor gravado: o desfazer recusa (conflito) + f.tree.Entries["AllowDenyLayered"] = DWORD(0) + if _, err := Revert(context.Background(), f, st); !errors.Is(err, ErrConflict) { + t.Fatalf("esperava conflito: %v", err) + } + s, err := ReadStatus(context.Background(), f, st) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(s.RevertNote, "falhou") { + t.Fatalf("a falha da reversão não deixou rastro: %q", s.RevertNote) + } + // o próximo Apply (depois de resolvida a sobra) começa sem o rastro velho: a nota some quando há restauração + f.tree.Entries["AllowDenyLayered"] = DWORD(1) + if _, err := Revert(context.Background(), f, st); err != nil { + t.Fatal(err) + } + s, _ = ReadStatus(context.Background(), f, st) + if !strings.Contains(s.RevertNote, "restaurou") { + t.Fatalf("o sucesso também deixa rastro: %q", s.RevertNote) + } +} + +// 2) A pasta já pode existir (criada por usuário comum): as ACLs dos FILHOS são refeitas, os que são links são +// recusados e um .reg velho é apagado antes do export. O reset NUNCA é na pasta raiz (desfaria a proteção). +func TestProtectDirRefazAsAclsDosFilhos(t *testing.T) { + s := protectDirScript + acl := strings.Index(s, "Set-Acl -LiteralPath $d") + reset := strings.Index(s, "/reset") + owner := strings.Index(s, "/setowner") + if acl < 0 || reset < 0 || owner < 0 || reset < acl || owner < acl { + t.Fatalf("o reset e o dono dos filhos vêm DEPOIS do Set-Acl da pasta: acl=%d reset=%d setowner=%d", acl, reset, owner) + } + if !strings.Contains(s, "Get-ChildItem -LiteralPath $d -Force") { + t.Error("os filhos têm de ser listados com -Force (ocultos também)") + } + if strings.Contains(s, "icacls.exe $d") || strings.Contains(s, "icacls.exe '"+ProtectedDir) { + t.Error("o icacls NÃO pode resetar a própria pasta raiz (desfaria a proteção)") + } + if !strings.Contains(s, "ReparsePoint") || strings.Count(s, "reparse point") < 2 { + t.Error("filho que é link também é recusado") + } + if !strings.Contains(s, "[IO.File]::Delete") || !strings.Contains(s, RegFile) { + t.Error("um .reg que já estava na pasta é apagado antes do export") + } + if err := asciiOnly(s); err != nil { + t.Errorf("script não ASCII: %v", err) + } +} + +// 3) A árvore é relida logo antes da primeira escrita: o que mudou na janela da preparação aborta (nada escrito). +func TestApplyRelêAArvoreAntesDaPrimeiraEscrita(t *testing.T) { + f := newFake(t) + st := f.fileStore() + f.hook = func(op string) { + if strings.HasPrefix(op, "task-arm") { // GPO/MDM grava na janela entre o snapshot e a primeira escrita + f.tree.KeyExists = true + f.tree.Entries["DenyDeviceIDs"] = DWORD(1) + } + } + _, err := Apply(context.Background(), f, st, applyOpts(f)) + if !errors.Is(err, ErrExistingPolicy) { + t.Fatalf("a árvore mudou durante a preparação: esperava ErrExistingPolicy, veio %v", err) + } + if f.writes() != 0 { + t.Fatalf("nada podia ser escrito: %d escritas", f.writes()) + } + if f.task.Exists { + t.Error("a tarefa deste Apply deveria ter sido removida") + } + if sn, _ := st.Load(); sn != nil { + t.Error("o backup deste Apply deveria ter sido removido") + } +} + +// 4) O Confirm remove a tarefa e confere de novo que a política continua lá: se a reversão já estava rodando, não diz +// "confirmado". +func TestConfirmConfereAPoliticaDepoisDeRemoverATarefa(t *testing.T) { + f := newFake(t) + st := f.fileStore() + mustApply(t, f, st) + f.hook = func(op string) { + if op == "task-delete" { // a tarefa já estava executando e termina de restaurar enquanto o Confirm a remove + f.tree = RegTree{Entries: map[string]RegValue{}} + } + } + if err := Confirm(context.Background(), f, st); err == nil { + t.Fatal("a política sumiu durante o Confirm: não pode dizer confirmado") + } +} + +// 5) Aviso quando o toolkit roda de uma pasta que usuário comum grava. +func TestAvisoDoExecutavelForaDePastaDeAdministrador(t *testing.T) { + for _, ok := range []string{`C:\Program Files\toolkit\toolkit.exe`, `c:\program files (x86)\x\t.exe`, `C:\Windows\System32\t.exe`} { + if w := ExeFolderWarning(ok); w != "" { + t.Errorf("%s não deveria avisar: %q", ok, w) + } + } + for _, bad := range []string{`C:\Users\ana\Downloads\toolkit.exe`, `D:\tools\toolkit.exe`, `C:\ProgramData\x\toolkit.exe`, `toolkit.exe`} { + if w := ExeFolderWarning(bad); w == "" { + t.Errorf("%s deveria avisar", bad) + } + } +} diff --git a/internal/usb/undo_test.go b/internal/usb/undo_test.go new file mode 100644 index 0000000..16e0c1d --- /dev/null +++ b/internal/usb/undo_test.go @@ -0,0 +1,374 @@ +package usb + +import ( + "context" + "errors" + "os" + "strings" + "testing" + "time" +) + +func snapshotOf(t *testing.T, f *fakeSys) RegTree { + t.Helper() + tr, err := f.ReadTree(context.Background()) + if err != nil { + t.Fatal(err) + } + return tr +} + +func TestDesfazerIdaEVoltaExata(t *testing.T) { + f := newFake(t) + st := newSpy(f) + before := snapshotOf(t, f) + mustApply(t, f, st) + if len(f.tree.Entries) == 0 { + t.Fatal("nada foi aplicado") + } + res, err := Undo(context.Background(), f, st) + if err != nil { + t.Fatal(err) + } + if res.Restored == 0 { + t.Errorf("res = %#v", res) + } + after := snapshotOf(t, f) + if after.KeyExists != before.KeyExists || len(after.Entries) != 0 || len(after.Subkeys) != 0 { + t.Fatalf("o registro não voltou ao original: %v %v exists=%v", treeKeys(after), after.Subkeys, after.KeyExists) + } + if f.task.Exists { + t.Error("a tarefa de reversão deveria ter sido removida") + } + if sn, _ := st.Load(); sn != nil { + t.Error("o backup deveria ter sido removido") + } +} + +func TestDesfazerPreservaPoliticaDeOutraOrigem(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + // depois da aplicação, GPO/MDM/outra ferramenta acrescenta uma política na MESMA chave + f.tree.Entries[`DenyDeviceIDs\1`] = String(`USB\VID_AAAA&PID_0001`) + f.tree.Entries["DenyDeviceIDs"] = DWORD(1) + f.addSubkey("DenyDeviceIDs") + if _, err := Undo(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if !f.tree.KeyExists { + t.Fatal("a chave Restrictions foi apagada com política de outra origem dentro") + } + if len(f.tree.Entries) != 2 || f.tree.Entries[`DenyDeviceIDs\1`].Str == "" || f.tree.Entries["DenyDeviceIDs"].DWORD != 1 { + t.Fatalf("a política de outra origem não foi preservada: %v", treeKeys(f.tree)) + } + if f.count("key-delete:") > 0 { + for _, l := range f.log { + if l == "key-delete:" { + t.Fatal("KeyDelete(Restrictions) com conteúdo de outra origem") + } + } + } + if !contains(f.tree.Subkeys, "DenyDeviceIDs") || contains(f.tree.Subkeys, "AllowDeviceIDs") || contains(f.tree.Subkeys, "DenyDeviceClasses") { + t.Fatalf("subchaves = %v", f.tree.Subkeys) + } +} + +func contains(l []string, s string) bool { + for _, x := range l { + if x == s { + return true + } + } + return false +} + +func TestDesfazerNaoApagaAChaveQueJaExistia(t *testing.T) { + f := newFake(t) + f.tree = RegTree{KeyExists: true, Entries: map[string]RegValue{}} + st := newSpy(f) + mustApply(t, f, st) + if _, err := Undo(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if !f.tree.KeyExists { + t.Fatal("a chave Restrictions já existia (vazia) antes: o desfazer não pode apagá-la") + } + for _, l := range f.log { + if l == "key-delete:" { + t.Fatal("KeyDelete(Restrictions) apesar de a chave já existir antes") + } + } +} + +func TestDesfazerValorAlteradoPorOutraOrigemParaSemEscrever(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + f.tree.Entries[`AllowDeviceIDs\1`] = String(`USB\VID_BBBB&PID_0001`) // outra origem trocou o valor que o toolkit gravou + n := f.writes() + _, err := Undo(context.Background(), f, st) + if !errors.Is(err, ErrConflict) { + t.Fatalf("err = %v, queria ErrConflict", err) + } + if f.writes() != n { + t.Fatalf("o desfazer escreveu apesar do conflito: %v", f.log[n:]) + } + if sn, _ := st.Load(); sn == nil || !f.task.Exists { + t.Error("backup e tarefa têm de ficar para a análise") + } +} + +func TestDesfazerSemAdminRecusaAntes(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + f.admin = false + n := len(f.log) + if _, err := Undo(context.Background(), f, st); !errors.Is(err, ErrNeedsAdmin) { + t.Fatalf("err = %v", err) + } + if len(f.log) != n { + t.Fatalf("mexeu em algo sem administrador: %v", f.log[n:]) + } +} + +// --- snapshot ausente, corrompido ou adulterado depois de uma aplicação --- + +func TestSnapshotAusenteDepoisDeAplicarEEstadoOriginalDesconhecido(t *testing.T) { + for name, setup := range map[string]func(f *fakeSys, st *spyStore){ + "backup apagado (tarefa e chaves ficaram)": func(_ *fakeSys, st *spyStore) { _ = st.Store.Remove() }, + "backup apagado e tarefa já removida": func(f *fakeSys, st *spyStore) { + _ = st.Store.Remove() + f.task = TaskInfo{} + }, + "backup apagado e só a tarefa sobrou": func(f *fakeSys, st *spyStore) { + _ = st.Store.Remove() + f.tree = RegTree{Entries: map[string]RegValue{}} + }, + "backup corrompido": func(_ *fakeSys, st *spyStore) { + p := st.Store.(FileStore).BackupPath() + if err := os.WriteFile(p, []byte(`{"sha256":"x","snapshot":{`), 0o600); err != nil { + t.Fatal(err) + } + }, + } { + t.Run(name, func(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + setup(f, st) + n := len(f.log) + plan, err := BuildUndo(context.Background(), f, st) + if err != nil { + t.Fatalf("BuildUndo: %v", err) + } + if plan.Kind != UndoUnknown { + t.Fatalf("Kind = %v, queria UndoUnknown", plan.Kind) + } + txt := plan.Format() + if !strings.Contains(txt, "ESTADO ORIGINAL DESCONHECIDO") { + t.Errorf("sem o aviso:\n%s", txt) + } + if strings.Contains(txt, "Nada a desfazer") { + t.Error("disse 'nada a desfazer' havendo sinais de aplicação") + } + for _, want := range []string{"outra conta de administrador", "WinRE", "A VERIFICAR", "confirmar que não havia política anterior"} { + if !strings.Contains(txt, want) { + t.Errorf("recuperação manual sem %q:\n%s", want, txt) + } + } + _, err = Undo(context.Background(), f, st) + if !errors.Is(err, ErrOriginalUnknown) { + t.Fatalf("Undo err = %v, queria ErrOriginalUnknown", err) + } + if len(f.log) != n { + t.Fatalf("restaurou/escreveu às cegas: %v", f.log[n:]) + } + }) + } +} + +func TestNadaADesfazerSoQuandoNuncaHouveAplicacao(t *testing.T) { + f := newFake(t) + st := newSpy(f) + plan, err := BuildUndo(context.Background(), f, st) + if err != nil { + t.Fatal(err) + } + if plan.Kind != UndoNothing || !strings.Contains(plan.Format(), "Nada a desfazer") { + t.Fatalf("plan = %v\n%s", plan.Kind, plan.Format()) + } + res, err := Undo(context.Background(), f, st) + if err != nil || !res.Nothing { + t.Fatalf("res=%#v err=%v", res, err) + } + if len(f.log) != 0 { + t.Fatalf("mexeu em algo: %v", f.log) + } +} + +func TestBackupAdulteradoRecusaRestaurar(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + p := st.Store.(FileStore).BackupPath() + raw, _ := os.ReadFile(p) + tampered := strings.Replace(string(raw), `"prazo": 10`, `"prazo": 11`, 1) + if tampered == string(raw) { + t.Fatal("o teste não conseguiu adulterar o arquivo") + } + if err := os.WriteFile(p, []byte(tampered), 0o600); err != nil { + t.Fatal(err) + } + n := len(f.log) + plan, err := BuildUndo(context.Background(), f, st) + if err != nil || plan.Kind != UndoUnknown { + t.Fatalf("plan=%v err=%v", plan, err) + } + if len(f.log) != n { + t.Fatal("mexeu em algo") + } + if _, statErr := os.Stat(p); statErr != nil { + t.Error("o arquivo adulterado tem de ser mantido para análise") + } +} + +func TestDesfazerValidaEstadoPosRestauracao(t *testing.T) { + // valor que o toolkit gravou foi apagado por fora: não é conflito, só já está restaurado + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + delete(f.tree.Entries, `AllowDeviceIDs\1`) + if _, err := Undo(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if len(f.tree.Entries) != 0 { + t.Fatalf("sobrou %v", treeKeys(f.tree)) + } +} + +// --- timer: expirar restaura; confirmar cancela a reversão --- + +func TestTimerExpirarRestauraOSnapshot(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + // a tarefa dispara: roda o MESMO caminho do desfazer, como SYSTEM + if _, err := Undo(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if len(f.tree.Entries) != 0 || f.task.Exists { + t.Fatal("a reversão automática não restaurou") + } +} + +func TestConfirmarCancelaAReversaoEMantemAPolitica(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + if err := Confirm(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if f.task.Exists { + t.Fatal("a tarefa deveria ter sido removida") + } + if len(f.tree.Entries) == 0 { + t.Fatal("a política tem de continuar aplicada") + } + if sn, _ := st.Load(); sn == nil { + t.Fatal("o backup tem de ficar para o desfazer") + } + // só a tarefa do toolkit foi removida; nenhuma escrita no registro + if f.count("task-delete") != 1 { + t.Fatalf("log = %v", f.log) + } + // o desfazer continua funcionando depois de confirmar + if _, err := Undo(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if len(f.tree.Entries) != 0 { + t.Fatal("desfazer depois de confirmar não restaurou") + } +} + +func TestConfirmarRecusas(t *testing.T) { + f := newFake(t) + st := newSpy(f) + if err := Confirm(context.Background(), f, st); !errors.Is(err, ErrNothingToConfirm) { + t.Fatalf("sem nada aplicado: %v", err) + } + + mustApply(t, f, st) + f.admin = false + if err := Confirm(context.Background(), f, st); !errors.Is(err, ErrNeedsAdmin) { + t.Fatalf("sem admin: %v", err) + } + f.admin = true + + f.task.Args = "usb desfazer --yes" + if err := Confirm(context.Background(), f, st); !errors.Is(err, ErrTaskUnexpected) { + t.Fatalf("tarefa com outro comando: %v", err) + } + if f.count("task-delete") != 0 { + t.Fatal("removeu uma tarefa que não é a do toolkit") + } + f.task.Args = RevertArgs + + f.task.Exe = `C:\Users\Public\evil.exe` + if err := Confirm(context.Background(), f, st); !errors.Is(err, ErrTaskUnexpected) { + t.Fatalf("tarefa com outro binário: %v", err) + } +} + +func TestConfirmarSemSnapshotRecusa(t *testing.T) { + f := newFake(t) + st := newSpy(f) + mustApply(t, f, st) + _ = st.Store.Remove() + if err := Confirm(context.Background(), f, st); !errors.Is(err, ErrOriginalUnknown) { + t.Fatalf("err = %v", err) + } + if f.count("task-delete") != 0 { + t.Fatal("cancelou a reversão sem snapshot: o desfazer ficaria impossível") + } +} + +func TestStatusCobreOsEstados(t *testing.T) { + f := newFake(t) + st := newSpy(f) + s, err := ReadStatus(context.Background(), f, st) + if err != nil || s.Kind != StatusClean { + t.Fatalf("limpo: %v %v", s, err) + } + mustApply(t, f, st) + if s, _ = ReadStatus(context.Background(), f, st); s.Kind != StatusArmed { + t.Fatalf("armado: %v", s.Kind) + } + if !s.Task.Next.Equal(t0.Add(10 * time.Minute)) { + t.Fatalf("próximo disparo = %v", s.Task.Next) + } + if err := Confirm(context.Background(), f, st); err != nil { + t.Fatal(err) + } + if s, _ = ReadStatus(context.Background(), f, st); s.Kind != StatusActive { + t.Fatalf("ativo: %v", s.Kind) + } + _ = st.Store.Remove() + if s, _ = ReadStatus(context.Background(), f, st); s.Kind != StatusUnknown { + t.Fatalf("sem snapshot: %v", s.Kind) + } +} + +func TestStatusLeituraDaTarefaFalhaEErro(t *testing.T) { + f := newFake(t) + f.taskReadErr = errors.New("acesso negado") + if _, err := ReadStatus(context.Background(), f, newSpy(f)); err == nil { + t.Fatal("falha de leitura da tarefa tem de ser erro (nunca virar 'limpo')") + } + f = newFake(t) + f.treeReadErr = errors.New("acesso negado") + if _, err := ReadStatus(context.Background(), f, newSpy(f)); err == nil { + t.Fatal("falha de leitura do registro tem de ser erro") + } +} diff --git a/internal/usb/usb.go b/internal/usb/usb.go new file mode 100644 index 0000000..a7336db --- /dev/null +++ b/internal/usb/usb.go @@ -0,0 +1,171 @@ +// Package usb é o modo empresa do Windows: permitir só os USB conhecidos (PR14 do plano). FUNÇÃO EXPERIMENTAL: não foi +// executada numa máquina real; tudo o que depende do comportamento do Windows está marcado "A VERIFICAR em VM" em +// docs/usb.md, e NADA se aplica por padrão (só com `toolkit usb aplicar` ou a ação da TUI, depois do plano e da +// confirmação). +// +// O mecanismo é a política oficial "Restrições de instalação de dispositivos" +// (HKLM\SOFTWARE\Policies\Microsoft\Windows\DeviceInstall\Restrictions) em ordem de camadas (AllowDenyLayered), com a +// negação LIMITADA às duas classes de configuração de USB e a liberação por ID de hardware (VID/PID) dos USB conectados +// hoje. Nunca se bloqueia por classe de teclado, mouse, HID ou disco, nunca se usa DenyUnspecified (global) e nada é +// escrito fora da lista fechada de valores de closedTargets. +// +// LIMITE HONESTO: a política só controla a instalação ou atualização de driver de dispositivo novo (o que já está +// instalado continua) e um dispositivo que CLONA o VID/PID de um permitido passa. Isto reduz o risco, não o elimina. +// +// Segurança do desenho: aplicar só acontece depois de PROVAR, pela árvore PnP, que todo dispositivo essencial (e todos os +// seus pais) continua permitido; com o backup protegido gravado e a tarefa de reversão armada e conferida ANTES da +// primeira chave; e a reversão restaura exatamente o snapshot, sem apagar a chave Restrictions às cegas. +// +// Todo acesso ao Windows passa pela interface System; os testes usam uma implementação em memória. +package usb + +import ( + "context" + "errors" + "time" + + "github.com/PiluTech/toolkit/internal/privacidade" +) + +// RegValue é um valor do registro (tipo preservado): o mesmo da privacidade. +type RegValue = privacidade.RegValue + +// DWORD cria um valor numérico. +func DWORD(n uint32) RegValue { return privacidade.DWORD(n) } + +// String cria um valor REG_SZ. +func String(s string) RegValue { return RegValue{Kind: privacidade.RegString, Str: s} } + +// Locais e nomes FIXOS (nunca vêm de variável de ambiente). +const ( + // RestrictionsKey é a ÚNICA chave que a função lê e escreve (sensível a maiúsculas: o prefixo é conferido exato). + RestrictionsKey = `HKLM\SOFTWARE\Policies\Microsoft\Windows\DeviceInstall\Restrictions` + // ProtectedDir guarda o backup e a cópia do binário da reversão: ACL só para SYSTEM e Administradores. + ProtectedDir = `C:\ProgramData\toolkit` + // BackupFile e RegFile ficam dentro de ProtectedDir. + BackupFile = "usb-backup.json" + RegFile = "usb-restrictions-backup.reg" + // RevertBinary é a cópia do toolkit que a tarefa de reversão executa (dentro de ProtectedDir). + RevertBinary = "toolkit-usb-revert.exe" + // TaskPath e TaskName identificam a ÚNICA tarefa agendada que a função cria, confere e remove. + TaskPath = `\PiluTech\` + TaskName = "toolkit-usb-reverter" + // RevertArgs é o argumento EXATO da tarefa (subcomando oculto que restaura o snapshot). + RevertArgs = "usb reverter" + + // PrazoPadrao, PrazoMinimo e PrazoMaximo são o prazo (minutos) da reversão automática (decisão 7 do plano). + PrazoPadrao = 10 + PrazoMinimo = 2 + PrazoMaximo = 60 + + // MaxAllowIDs limita a lista de IDs permitidos (e o tamanho do snapshot). + MaxAllowIDs = 200 +) + +// Classes de configuração de USB que a política nega (Microsoft, cenário de USB): "USB" e "USBDevice". Lista FECHADA. +// A confirmação de que bastam para impedir o filho HID de um dispositivo novo é A VERIFICAR em VM. +var denyClassGUIDs = []string{"{36fc9e60-c465-11cf-8056-444553540000}", "{88BAE032-5A81-49f0-BC3D-A4FF138216D6}"} + +// genericAllowIDs é o conjunto FECHADO de IDs genéricos que entram na lista (a fonte [2] do plano): controladores e hubs +// raiz USB. Todo outro ID da lista tem VID e PID. ID compatível genérico de HID/classe NUNCA entra. +var genericAllowIDs = []string{`PCI\CC_0C03`, `PCI\CC_0C0330`, `PNP0CA1`, `USB\ROOT_HUB20`, `USB\ROOT_HUB30`, `USB\USB20_HUB`} + +// Erros do pacote. +var ( + // ErrNeedsAdmin: aplicar, confirmar e desfazer escrevem em HKLM e na tarefa do sistema. Nada foi alterado. + ErrNeedsAdmin = errors.New("o modo empresa de USB exige administrador") + // ErrEdition: edição do Windows sem suporte documentado (Home e as demais não listadas). + ErrEdition = errors.New("esta edição do Windows não documenta a política de restrição de instalação de dispositivos") + // ErrNoProof: não foi possível PROVAR que os dispositivos essenciais continuam permitidos. Nada foi alterado. + ErrNoProof = errors.New("não foi possível provar que os dispositivos essenciais continuam permitidos") + // ErrPrazo: prazo fora de PrazoMinimo..PrazoMaximo. + ErrPrazo = errors.New("prazo da reversão fora do intervalo permitido") + // ErrExistingPolicy: já há política de restrição (de outra origem ou do toolkit) que o toolkit não mistura. + ErrExistingPolicy = errors.New("já existe política de restrição de instalação de dispositivos") + // ErrBackupInvalid: o backup existe mas está corrompido, adulterado ou fora da estrutura esperada. + ErrBackupInvalid = errors.New("backup de USB corrompido, adulterado ou inválido") + // ErrOriginalUnknown: houve aplicação e o snapshot sumiu ou é inválido: nada é restaurado às cegas. + ErrOriginalUnknown = errors.New("ESTADO ORIGINAL DESCONHECIDO") + // ErrConflict: um valor que o toolkit gravou agora tem outro conteúdo (outra origem mexeu): nada é restaurado. + ErrConflict = errors.New("um valor gravado pelo toolkit foi alterado por outra origem") + // ErrNothingToConfirm: não há tarefa de reversão do toolkit para cancelar. + ErrNothingToConfirm = errors.New("não há reversão pendente para confirmar") + // ErrTaskUnexpected: a tarefa de reversão não é exatamente a que o toolkit criaria. + ErrTaskUnexpected = errors.New("a tarefa de reversão não é a esperada") + // ErrPlanChanged: o plano recalculado agora não é o que foi mostrado e confirmado. Nada foi alterado. + ErrPlanChanged = errors.New("o estado mudou desde o plano mostrado") + // ErrEntradaInvalida: caminho de valor fora da lista fechada, nome ou valor fora do formato seguro. + ErrEntradaInvalida = errors.New("entrada inválida") + // ErrTreeIncomplete: a árvore PnP lida está incompleta ou inconsistente. + ErrTreeIncomplete = errors.New("árvore de dispositivos incompleta") +) + +// Edições aceitas (a política é documentada só para elas; Home e o resto = ErrEdition). +const ( + EditionPro = "pro" + EditionEnterprise = "enterprise" + EditionEducation = "education" + EditionHome = "home" + EditionOther = "other" +) + +// RegTree é o que há hoje sob a chave Restrictions (valores por caminho RELATIVO, ex. "AllowDenyLayered" ou +// "AllowDeviceIDs\1"), mais as subchaves. Só REG_DWORD, REG_SZ e REG_EXPAND_SZ: outro tipo faz a leitura falhar (um valor +// que não dá para restaurar exatamente nunca é sobrescrito). +type RegTree struct { + KeyExists bool + Entries map[string]RegValue + Subkeys []string // caminhos relativos das subchaves +} + +// StagedBinary é a cópia do toolkit feita na pasta protegida para a tarefa de reversão. +type StagedBinary struct { + Path string + SourceSHA, CopySHA string // SHA-256 (hex) do binário em execução e da cópia: têm de ser iguais +} + +// TaskSpec é o que a tarefa de reversão deve fazer: executar Exe com Args, como SYSTEM, uma vez, daqui a Minutes. +type TaskSpec struct { + Exe, Args string + Minutes int +} + +// TaskInfo é a tarefa de reversão como o Agendador a mostra. +type TaskInfo struct { + Exists bool + Enabled bool + Exe string + Args string + User string // "SYSTEM" ou o SID S-1-5-18 + Next time.Time // próximo disparo (UTC); zero = sem disparo +} + +// System é o Windows visto pelo toolkit. Leituras (Edition, IsAdmin, Devices, ReadTree, ReadTask) nunca exigem +// administrador e são ReadOnly; escritas nunca levam Elevate (a função recusa ANTES, por IsAdmin, e nunca eleva sozinha). +// Toda escrita no registro só aceita caminhos da lista fechada (checkRel). +type System interface { + Edition(ctx context.Context) (string, error) + IsAdmin(ctx context.Context) bool + // Devices lê o PnP (dispositivos presentes, com pai, classe e IDs). Leitura incompleta é erro. + Devices(ctx context.Context) ([]Device, error) + + // ReadTree lê tudo o que há sob Restrictions (KeyExists=false quando a ausência está provada). + ReadTree(ctx context.Context) (RegTree, error) + // RegWrite e RegDelete mexem num VALOR (caminho relativo da lista fechada). Apagar o que não existe não é erro. + RegWrite(ctx context.Context, rel string, v RegValue) error + RegDelete(ctx context.Context, rel string) error + // KeyDelete apaga uma subchave da lista fechada (ou a própria Restrictions, rel "") SÓ quando ela está vazia. + KeyDelete(ctx context.Context, rel string) error + // ExportReg exporta a chave Restrictions para file (reg export), dentro da pasta protegida. + ExportReg(ctx context.Context, file string) error + + // ProtectDir cria dir (se faltar), recusa ponto de reparse, define dono e ACL (SYSTEM e Administradores, sem herança), + // RELÊ a ACL e devolve erro se ela não for exatamente essa. + ProtectDir(ctx context.Context, dir string) error + // StageBinary copia o toolkit em execução para dir e confere o SHA-256 da cópia contra o do original. + StageBinary(ctx context.Context, dir string) (StagedBinary, error) + + ArmTask(ctx context.Context, spec TaskSpec) error + ReadTask(ctx context.Context) (TaskInfo, error) + DeleteTask(ctx context.Context) error +} diff --git a/internal/usb/usbtest/usbtest.go b/internal/usb/usbtest/usbtest.go new file mode 100644 index 0000000..5b3ffb1 --- /dev/null +++ b/internal/usb/usbtest/usbtest.go @@ -0,0 +1,256 @@ +// Package usbtest traz um Windows em memória (usb.System) e um Store em memória para os testes dos pacotes que usam o +// pacote usb (CLI e TUI). Nenhum teste que o use toca o registro, o Agendador ou o disco. Dados SINTÉTICOS (repositório +// público): VID_FFFF/PID_xxxx e nomes inventados. +package usbtest + +import ( + "context" + "errors" + "fmt" + "sort" + "strings" + "time" + + "github.com/PiluTech/toolkit/internal/usb" +) + +// Sys é o System em memória. Os campos exportados são o estado; Log registra as mutações, na ordem. +type Sys struct { + EditionID string + Admin bool + Devs []usb.Device + DevsErr error + Tree usb.RegTree + Task usb.TaskInfo + Now time.Time + Log []string + FailOn string // prefixo da operação que falha + OnRead func() // chamado a cada leitura do PnP (gancho de teste) + StagedSHA string +} + +// NewSys devolve um Windows Pro com administrador, um teclado e um pendrive USB. +func NewSys() *Sys { + return &Sys{EditionID: usb.EditionPro, Admin: true, Devs: Devices(true), Tree: usb.RegTree{Entries: map[string]usb.RegValue{}}, + Now: time.Date(2026, 11, 14, 12, 0, 0, 0, time.UTC), StagedSHA: strings.Repeat("a", 64)} +} + +func (s *Sys) op(name string) error { + if s.FailOn != "" && strings.HasPrefix(name, s.FailOn) { + return errors.New("falha simulada em " + name) + } + s.Log = append(s.Log, name) + return nil +} + +// Writes conta as escritas no registro. +func (s *Sys) Writes() int { + n := 0 + for _, l := range s.Log { + if strings.HasPrefix(l, "reg-") || strings.HasPrefix(l, "key-") { + n++ + } + } + return n +} + +// Edition implementa usb.System. +func (s *Sys) Edition(context.Context) (string, error) { return s.EditionID, nil } + +// IsAdmin implementa usb.System. +func (s *Sys) IsAdmin(context.Context) bool { return s.Admin } + +// Devices implementa usb.System. +func (s *Sys) Devices(context.Context) ([]usb.Device, error) { + if s.OnRead != nil { + s.OnRead() + } + return s.Devs, s.DevsErr +} + +// ReadTree implementa usb.System. +func (s *Sys) ReadTree(context.Context) (usb.RegTree, error) { + out := usb.RegTree{KeyExists: s.Tree.KeyExists, Entries: map[string]usb.RegValue{}, Subkeys: append([]string(nil), s.Tree.Subkeys...)} + for k, v := range s.Tree.Entries { + out.Entries[k] = v + } + return out, nil +} + +// RegWrite implementa usb.System. +func (s *Sys) RegWrite(_ context.Context, rel string, v usb.RegValue) error { + if err := s.op("reg-write:" + rel); err != nil { + return err + } + s.Tree.KeyExists = true + if sub, _, ok := strings.Cut(rel, `\`); ok && !has(s.Tree.Subkeys, sub) { + s.Tree.Subkeys = append(s.Tree.Subkeys, sub) + sort.Strings(s.Tree.Subkeys) + } + s.Tree.Entries[rel] = v + return nil +} + +// RegDelete implementa usb.System. +func (s *Sys) RegDelete(_ context.Context, rel string) error { + if err := s.op("reg-delete:" + rel); err != nil { + return err + } + delete(s.Tree.Entries, rel) + return nil +} + +// KeyDelete implementa usb.System. +func (s *Sys) KeyDelete(_ context.Context, rel string) error { + if err := s.op("key-delete:" + rel); err != nil { + return err + } + if rel == "" { + s.Tree.KeyExists = false + return nil + } + var keep []string + for _, k := range s.Tree.Subkeys { + if k != rel { + keep = append(keep, k) + } + } + s.Tree.Subkeys = keep + return nil +} + +func has(l []string, s string) bool { + for _, x := range l { + if x == s { + return true + } + } + return false +} + +// ExportReg implementa usb.System (não grava arquivo: o MemStore não precisa). +func (s *Sys) ExportReg(context.Context, string) error { return s.op("export-reg") } + +// ProtectDir implementa usb.System. +func (s *Sys) ProtectDir(context.Context, string) error { return s.op("protect-dir") } + +// StageBinary implementa usb.System. +func (s *Sys) StageBinary(context.Context, string) (usb.StagedBinary, error) { + if err := s.op("stage-binary"); err != nil { + return usb.StagedBinary{}, err + } + return usb.StagedBinary{Path: usb.ProtectedDir + `\` + usb.RevertBinary, SourceSHA: s.StagedSHA, CopySHA: s.StagedSHA}, nil +} + +// ArmTask implementa usb.System. +func (s *Sys) ArmTask(_ context.Context, spec usb.TaskSpec) error { + if err := s.op("task-arm"); err != nil { + return err + } + s.Task = usb.TaskInfo{Exists: true, Enabled: true, Exe: spec.Exe, Args: spec.Args, User: "SYSTEM", Next: s.Now.Add(time.Duration(spec.Minutes) * time.Minute)} + return nil +} + +// ReadTask implementa usb.System. +func (s *Sys) ReadTask(context.Context) (usb.TaskInfo, error) { return s.Task, nil } + +// DeleteTask implementa usb.System. +func (s *Sys) DeleteTask(context.Context) error { + if err := s.op("task-delete"); err != nil { + return err + } + s.Task = usb.TaskInfo{} + return nil +} + +// MemStore é o usb.Store em memória (valida a estrutura como o FileStore: o snapshot passa pelo mesmo caminho de validação). +type MemStore struct { + sn *usb.Snapshot + corrupt bool + Fail bool + note string +} + +// SaveRevertResult e LoadRevertResult implementam usb.RevertLogger (o rastro da reversão automática, em memória). +func (m *MemStore) SaveRevertResult(note string) error { m.note = note; return nil } + +// LoadRevertResult implementa usb.RevertLogger. +func (m *MemStore) LoadRevertResult() string { return m.note } + +// Folder implementa usb.Store. +func (m *MemStore) Folder() string { return `C:\ProgramData\toolkit` } + +// RegPath implementa usb.Store. +func (m *MemStore) RegPath() string { return `C:\ProgramData\toolkit\` + usb.RegFile } + +// FileSHA256 implementa usb.Store. +func (m *MemStore) FileSHA256(string) (string, error) { return strings.Repeat("d", 64), nil } + +// Load implementa usb.Store. +func (m *MemStore) Load() (*usb.Snapshot, error) { + if m.corrupt { + return nil, fmt.Errorf("%w: arquivo adulterado (simulado)", usb.ErrBackupInvalid) + } + if m.sn == nil { + return nil, nil + } + cp := *m.sn + return &cp, nil +} + +// Save implementa usb.Store. +func (m *MemStore) Save(sn *usb.Snapshot) error { + if m.Fail { + return errors.New("falha simulada ao gravar o backup") + } + cp := *sn + m.sn = &cp + return nil +} + +// Remove implementa usb.Store. +func (m *MemStore) Remove() error { m.sn, m.corrupt = nil, false; return nil } + +// Corrupt simula arquivo adulterado: o Load passa a devolver ErrBackupInvalid. +func (m *MemStore) Corrupt() { m.corrupt = true } + +var _ usb.Store = (*MemStore)(nil) +var _ usb.System = (*Sys)(nil) + +// Devices devolve uma máquina sintética: teclado PS/2, controlador USB, hub raiz, NVMe, um teclado USB e, com pendrive, +// um pendrive USB. +func Devices(pendrive bool) []usb.Device { + d := func(inst, parent, name, class, guid string, hw []string, cp ...string) usb.Device { + return usb.Device{InstanceID: inst, Parent: parent, Name: name, Class: class, ClassGUID: guid, HardwareIDs: hw, CompatibleIDs: cp} + } + const ( + root = `HTREE\ROOT\0` + pci = `PCI\VEN_FFFF&DEV_0001&SUBSYS_00000000&REV_01\3&1&0&A0` + hub = `USB\ROOT_HUB30\4&1&0&0` + kb = `USB\VID_FFFF&PID_0001\6&9&0&1` + nvme = `PCI\VEN_FFFF&DEV_0002&SUBSYS_00000000&REV_01\3&1&0&B0` + ) + out := []usb.Device{ + d(root, "", "Raiz", "System", "{4d36e97d-e325-11ce-bfc1-08002be10318}", []string{`HTREE\ROOT\0`}), + d(`ACPI\PNP0303\4&2&0`, root, "Teclado PS/2 padrão", "Keyboard", "{4d36e96b-e325-11ce-bfc1-08002be10318}", []string{`ACPI\PNP0303`}), + d(pci, root, "Controlador xHCI", "USB", "{36fc9e60-c465-11cf-8056-444553540000}", []string{`PCI\VEN_FFFF&DEV_0001&SUBSYS_00000000&REV_01`}, `PCI\CC_0C0330`, `PCI\CC_0C03`), + d(hub, pci, "Hub raiz USB 3", "USB", "{36fc9e60-c465-11cf-8056-444553540000}", []string{`USB\ROOT_HUB30`}), + d(nvme, root, "Controlador NVMe", "SCSIAdapter", "{4d36e97b-e325-11ce-bfc1-08002be10318}", []string{`PCI\VEN_FFFF&DEV_0002&SUBSYS_00000000&REV_01`}), + d(`SCSI\DISK&VEN_NVME\5&5&0&0`, nvme, "Disco NVMe", "DiskDrive", "{4d36e967-e325-11ce-bfc1-08002be10318}", []string{`SCSI\DISKNVME____FAKE`}), + d(kb, hub, "Teclado USB", "USB", "{36fc9e60-c465-11cf-8056-444553540000}", []string{`USB\VID_FFFF&PID_0001&REV_0100`, `USB\VID_FFFF&PID_0001`}), + d(`HID\VID_FFFF&PID_0001\8&b&0&0`, kb, "Teclado HID", "Keyboard", "{4d36e96b-e325-11ce-bfc1-08002be10318}", []string{`HID\VID_FFFF&PID_0001&REV_0100`, `HID\VID_FFFF&PID_0001`}), + } + if pendrive { + pen := `USB\VID_FFFF&PID_0003\0&p&0&2` + out = append(out, + d(pen, hub, "Pendrive USB", "USB", "{36fc9e60-c465-11cf-8056-444553540000}", []string{`USB\VID_FFFF&PID_0003&REV_0001`, `USB\VID_FFFF&PID_0003`}), + d(`USBSTOR\DISK&VEN_FAKE\0&p&0`, pen, "Pendrive (disco)", "DiskDrive", "{4d36e967-e325-11ce-bfc1-08002be10318}", []string{`USBSTOR\DISKFAKE_PEN`})) + } + return out +} + +// KeyboardKey e PendriveKey são as instâncias dos dispositivos USB do Devices (a chave da seleção). +const ( + KeyboardKey = `USB\VID_FFFF&PID_0001\6&9&0&1` + PendriveKey = `USB\VID_FFFF&PID_0003\0&p&0&2` +) diff --git a/internal/usb/windows.go b/internal/usb/windows.go new file mode 100644 index 0000000..db2f065 --- /dev/null +++ b/internal/usb/windows.go @@ -0,0 +1,663 @@ +package usb + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "os" + "path/filepath" + "regexp" + "strconv" + "strings" + "time" + + "github.com/PiluTech/toolkit/internal/exec" + "github.com/PiluTech/toolkit/internal/privacidade" + "github.com/PiluTech/toolkit/internal/textsafe" +) + +// Executáveis do Windows, SEMPRE por caminho absoluto (nunca pelo PATH). O arquivo compila em qualquer SO: só os comandos +// montados aqui dependem do Windows, e os testes usam um Runner falso. +const ( + regExe = `C:\Windows\System32\reg.exe` + psExe = `C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe` + + cmdTimeout = 60 * time.Second + pnpTimeout = 180 * time.Second + + editionKey = `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion` + restrictionsDir = `HKLM\SOFTWARE\Policies\Microsoft\Windows\DeviceInstall` + maxRegOutput = 4 << 20 +) + +// windowsSystem implementa System sobre reg.exe e powershell.exe. Leituras vão pelo exec.ReadOnlyRunner (ReadOnly=true, nunca +// Elevate); escritas pelo exec.MutatingRunner (ReadOnly=false) e NUNCA levam Elevate: o administrador é conferido antes +// (IsAdmin) e o toolkit nunca eleva sozinho. Nenhum shell implícito: os argumentos vão como lista e os scripts do PowerShell +// são texto FIXO em ASCII, com só números e constantes validados interpolados. +type windowsSystem struct { + read, mutate exec.Runner + elevated func() bool + dir string // pasta protegida esperada em ProtectDir/StageBinary/ExportReg (ProtectedDir; os testes trocam) + stage func(dir string) (StagedBinary, error) +} + +// NewWindowsSystem cria o System real do Windows. elevated diz se o processo está elevado (nil = não). +func NewWindowsSystem(rn exec.Runner, elevated func() bool) System { + return &windowsSystem{read: exec.ReadOnlyRunner(rn), mutate: exec.MutatingRunner(rn), elevated: elevated, dir: ProtectedDir, stage: stageSelf} +} + +func invalid(format string, a ...any) error { + return fmt.Errorf("%w: %s", ErrEntradaInvalida, fmt.Sprintf(format, a...)) +} + +// asciiOnly recusa script com qualquer byte fora de ASCII imprimível (ou quebra de linha/tab): é checado em TODO script antes +// de executar (e nos testes sobre as constantes). +func asciiOnly(s string) error { + for i := 0; i < len(s); i++ { + c := s[i] + if (c < 0x20 && c != '\n' && c != '\t') || c > 0x7e { + return invalid("o script do PowerShell tem um byte fora de ASCII (posição %d)", i) + } + } + return nil +} + +func snippet(r exec.Result) string { + s := strings.TrimSpace(string(r.Stderr)) + if s == "" { + s = strings.TrimSpace(string(r.Stdout)) + } + s = strings.Join(strings.Fields(textsafe.Line(s)), " ") + if len(s) > 200 { + s = s[:200] + "..." + } + return s +} + +func cmdFailed(c exec.Cmd, r exec.Result) error { + exe := c.Name[strings.LastIndex(c.Name, `\`)+1:] + return fmt.Errorf("%s terminou com código %d: %s", exe, r.ExitCode, snippet(r)) +} + +func (w *windowsSystem) readCmd(ctx context.Context, timeout time.Duration, name string, args ...string) (exec.Cmd, exec.Result, error) { + c := exec.Cmd{Name: name, Args: args, ReadOnly: true, Timeout: timeout} + r, err := w.read.Run(ctx, c) + return c, r, err +} + +func (w *windowsSystem) writeCmd(ctx context.Context, name string, args ...string) (exec.Cmd, exec.Result, error) { + c := exec.Cmd{Name: name, Args: args, Timeout: cmdTimeout} // nunca Elevate + r, err := w.mutate.Run(ctx, c) + return c, r, err +} + +func psArgs(script string) []string { + return []string{"-NoProfile", "-NonInteractive", "-Command", script} +} + +func (w *windowsSystem) psRead(ctx context.Context, timeout time.Duration, script string) (exec.Result, error) { + if err := asciiOnly(script); err != nil { + return exec.Result{}, err + } + c, r, err := w.readCmd(ctx, timeout, psExe, psArgs(script)...) + if err != nil { + return r, fmt.Errorf("powershell: %w", err) + } + if r.ExitCode != 0 { + return r, cmdFailed(c, r) + } + return r, nil +} + +func (w *windowsSystem) psWrite(ctx context.Context, script string) error { + if err := asciiOnly(script); err != nil { + return err + } + c, r, err := w.writeCmd(ctx, psExe, psArgs(script)...) + if err != nil { + return fmt.Errorf("powershell: %w", err) + } + if r.ExitCode != 0 { + return cmdFailed(c, r) + } + return nil +} + +// IsAdmin devolve o callback injetado (nil = false). +func (w *windowsSystem) IsAdmin(context.Context) bool { return w.elevated != nil && w.elevated() } + +// Edition lê EditionID (leitura; é a ÚNICA leitura fora da chave Restrictions). Só Professional, Enterprise e Education +// (e as variantes que começam assim) são aceitas pela política; Core (Home), Server, IoT e o resto são EditionOther/Home. +func (w *windowsSystem) Edition(ctx context.Context) (string, error) { + c, r, err := w.readCmd(ctx, cmdTimeout, regExe, "query", editionKey, "/v", "EditionID") + if err != nil { + return "", fmt.Errorf("reg query: %w", err) + } + if r.ExitCode != 0 { + return "", cmdFailed(c, r) + } + vals, _, err := parseRegList(string(r.Stdout), editionKey) + if err != nil { + return "", err + } + v, ok := vals["EditionID"] + if !ok { + return EditionOther, nil + } + id := strings.ToLower(v.Str) + switch { + case strings.HasPrefix(id, "core"): + return EditionHome, nil + case strings.HasPrefix(id, "professional"): + return EditionPro, nil + case strings.HasPrefix(id, "enterprise"): + return EditionEnterprise, nil + case strings.HasPrefix(id, "education"): + return EditionEducation, nil + } + return EditionOther, nil +} + +// --- registro --- + +func keyOf(rel string) string { + if rel == "" { + return RestrictionsKey + } + return RestrictionsKey + `\` + rel +} + +var reRegValue = regexp.MustCompile(`^ {4}(.+?) {4}(REG_[A-Z_]+)(?: {4}(.*))?$`) + +// parseRegList lê a saída de `reg query /s` (ou de um valor só). Devolve os valores (nome -> valor) da chave base +// quando não há /s (usado por Edition) e, para a árvore, é chamada por parseRegTree. Só REG_DWORD, REG_SZ e REG_EXPAND_SZ: +// outro tipo é erro (um valor que não dá para restaurar exatamente nunca é sobrescrito). +func parseRegList(out, base string) (map[string]RegValue, []string, error) { + vals := map[string]RegValue{} + var subs []string + root := regRootName(base) + cur := "" + for _, line := range strings.Split(out, "\n") { + line = strings.TrimRight(line, "\r") + if strings.TrimSpace(line) == "" { + continue + } + if !strings.HasPrefix(line, " ") { + if !strings.EqualFold(line, root) && !strings.HasPrefix(strings.ToLower(line), strings.ToLower(root)+`\`) { + return nil, nil, fmt.Errorf("cabeçalho de chave inesperado na saída do reg.exe") + } + cur = strings.TrimPrefix(line[len(root):], `\`) + if cur != "" { + subs = append(subs, cur) + } + continue + } + m := reRegValue.FindStringSubmatch(line) + if m == nil { + return nil, nil, fmt.Errorf("linha de valor em formato inesperado na saída do reg.exe") + } + name, typ, data := m[1], m[2], m[3] + if name == "(Default)" { + if data == "(value not set)" { + continue + } + return nil, nil, fmt.Errorf("valor padrão preenchido na chave: tipo de valor que o toolkit não restaura") + } + var v RegValue + switch typ { + case "REG_DWORD": + n, err := strconv.ParseUint(strings.TrimSpace(data), 0, 32) + if err != nil { + return nil, nil, fmt.Errorf("REG_DWORD ilegível") + } + v = DWORD(uint32(n)) + case "REG_SZ": + v = String(data) + case "REG_EXPAND_SZ": + v = RegValue{Kind: privacidade.RegExpandString, Str: data} + default: + return nil, nil, fmt.Errorf("o valor %q é do tipo %s, que o toolkit não consegue restaurar exatamente: recusado", textsafe.Line(name), typ) + } + path := name + if cur != "" { + path = cur + `\` + name + } + vals[path] = v + } + return vals, subs, nil +} + +// regRootName converte "HKLM\..." no nome longo que o reg.exe imprime. +func regRootName(key string) string { + if rest, ok := strings.CutPrefix(key, `HKLM\`); ok { + return `HKEY_LOCAL_MACHINE\` + rest + } + return key +} + +// ReadTree: reg query /s. Exit 0 = existe (parse). Exit 1 é AMBÍGUO (ausente ou acesso negado, texto +// traduzido): a ausência só é aceita quando PROVADA pela listagem de um ancestral; na dúvida é erro (nada é mudado). +func (w *windowsSystem) ReadTree(ctx context.Context) (RegTree, error) { + c, r, err := w.readCmd(ctx, cmdTimeout, regExe, "query", RestrictionsKey, "/s") + if err != nil { + return RegTree{}, fmt.Errorf("reg query: %w", err) + } + if len(r.Stdout) > maxRegOutput { + return RegTree{}, fmt.Errorf("saída do reg.exe grande demais") + } + switch r.ExitCode { + case 0: + vals, subs, err := parseRegList(string(r.Stdout), RestrictionsKey) + if err != nil { + return RegTree{}, err + } + tr := RegTree{KeyExists: true, Entries: vals} + seen := map[string]bool{} + for _, s := range subs { + if !seen[s] { + seen[s] = true + tr.Subkeys = append(tr.Subkeys, s) + } + } + return tr, nil + case 1: + if err := w.proveAbsent(ctx, c, r); err != nil { + return RegTree{}, err + } + return RegTree{Entries: map[string]RegValue{}}, nil + } + return RegTree{}, cmdFailed(c, r) +} + +// proveAbsent sobe pelos ancestrais de Restrictions até um que LISTE (exit 0) e prova pela listagem dele que a próxima +// subchave não existe. Se ela aparece, existe mas não abriu (acesso negado): erro. +func (w *windowsSystem) proveAbsent(ctx context.Context, c exec.Cmd, first exec.Result) error { + cur, below := RestrictionsKey, "" + for i := 0; i < 6; i++ { + j := strings.LastIndex(cur, `\`) + if j < 0 { + break + } + below, cur = cur, cur[:j] + _, pr, err := w.readCmd(ctx, cmdTimeout, regExe, "query", cur) + if err != nil { + return fmt.Errorf("reg query: %w", err) + } + if pr.ExitCode == 1 { + continue + } + if pr.ExitCode != 0 { + return cmdFailed(c, pr) + } + full := regRootName(cur) + `\` + below[strings.LastIndex(below, `\`)+1:] + for _, line := range strings.Split(string(pr.Stdout), "\n") { + if strings.EqualFold(strings.TrimSpace(line), full) { + return fmt.Errorf("a chave Restrictions existe mas não pôde ser lida (acesso negado?): %s", snippet(first)) + } + } + return nil + } + return fmt.Errorf("não foi possível confirmar que a chave Restrictions não existe: %s", snippet(first)) +} + +func splitRel(rel string) (key, name string) { + if sub, n, ok := strings.Cut(rel, `\`); ok { + return keyOf(sub), n + } + return RestrictionsKey, rel +} + +// RegWrite: reg.exe add /v /t REG_DWORD|REG_SZ /d /f. Caminho e valor conferidos contra a lista fechada +// ANTES de executar; nunca Elevate. +func (w *windowsSystem) RegWrite(ctx context.Context, rel string, v RegValue) error { + if err := checkWrite(rel, v); err != nil { + return err + } + key, name := splitRel(rel) + typ, data := "REG_DWORD", strconv.FormatUint(uint64(v.DWORD), 10) + if v.Kind == privacidade.RegString { + typ, data = "REG_SZ", v.Str + } + c, r, err := w.writeCmd(ctx, regExe, "add", key, "/v", name, "/t", typ, "/d", data, "/f") + if err != nil { + return fmt.Errorf("reg add: %w", err) + } + if r.ExitCode != 0 { + return cmdFailed(c, r) + } + return nil +} + +// RegDelete: confere (leitura) que o valor existe e só então roda reg.exe delete /v /f. +func (w *windowsSystem) RegDelete(ctx context.Context, rel string) error { + if err := checkRel(rel); err != nil { + return err + } + tr, err := w.ReadTree(ctx) + if err != nil { + return err + } + if _, ok := tr.Entries[rel]; !ok { + return nil + } + key, name := splitRel(rel) + c, r, err := w.writeCmd(ctx, regExe, "delete", key, "/v", name, "/f") + if err != nil { + return fmt.Errorf("reg delete: %w", err) + } + if r.ExitCode != 0 { + return cmdFailed(c, r) + } + return nil +} + +// KeyDelete apaga a subchave (AllowDeviceIDs ou DenyDeviceClasses) ou a própria Restrictions SÓ quando está vazia (relida +// agora): reg delete /f apagaria tudo o que houver dentro, inclusive política de outra origem. +func (w *windowsSystem) KeyDelete(ctx context.Context, rel string) error { + if rel != "" && rel != nameAllow && rel != nameDeny { + return invalid("subchave %q fora da lista fechada", printableRel(rel)) + } + tr, err := w.ReadTree(ctx) + if err != nil { + return err + } + if !tr.KeyExists { + return nil + } + if rel == "" { + if len(tr.Entries) > 0 || len(tr.Subkeys) > 0 { + return fmt.Errorf("a chave Restrictions não está vazia: não será apagada") + } + } else { + if !hasString(tr.Subkeys, rel) { + return nil + } + if hasEntriesUnder(tr, rel) { + return fmt.Errorf("a subchave %s não está vazia: não será apagada", rel) + } + } + c, r, err := w.writeCmd(ctx, regExe, "delete", keyOf(rel), "/f") + if err != nil { + return fmt.Errorf("reg delete: %w", err) + } + if r.ExitCode != 0 { + return cmdFailed(c, r) + } + return nil +} + +// ExportReg: reg.exe export /y. O arquivo tem de ser o .reg da pasta protegida. +func (w *windowsSystem) ExportReg(ctx context.Context, file string) error { + norm := func(s string) string { return strings.ToLower(strings.ReplaceAll(s, "/", `\`)) } + if norm(file) != norm(w.dir)+`\`+strings.ToLower(RegFile) { + return invalid("o .reg só pode ser exportado para a pasta protegida") + } + c, r, err := w.writeCmd(ctx, regExe, "export", RestrictionsKey, file, "/y") + if err != nil { + return fmt.Errorf("reg export: %w", err) + } + if r.ExitCode != 0 { + return cmdFailed(c, r) + } + return nil +} + +// --- pasta protegida --- + +// Scripts FIXOS (ASCII, sem aspas duplas). A pasta é sempre a constante ProtectedDir. +const protectDirScript = `$ErrorActionPreference='Stop' +$d='` + ProtectedDir + `' +if(Test-Path -LiteralPath $d){ $i=Get-Item -LiteralPath $d -Force; if(($i.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0){ throw 'reparse point' }; foreach($c in @(Get-ChildItem -LiteralPath $d -Force)){ if(($c.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0){ throw 'reparse point dentro da pasta' } } } else { New-Item -ItemType Directory -Path $d | Out-Null } +$sys=New-Object System.Security.Principal.SecurityIdentifier('S-1-5-18') +$adm=New-Object System.Security.Principal.SecurityIdentifier('S-1-5-32-544') +$acl=New-Object System.Security.AccessControl.DirectorySecurity +$acl.SetOwner($adm) +$acl.SetAccessRuleProtection($true,$false) +foreach($s in @($sys,$adm)){ $acl.AddAccessRule((New-Object System.Security.AccessControl.FileSystemAccessRule($s,'FullControl','ContainerInherit,ObjectInherit','None','Allow'))) } +Set-Acl -LiteralPath $d -AclObject $acl +foreach($c in @(Get-ChildItem -LiteralPath $d -Force)){ & icacls.exe $c.FullName /reset /t /c /l | Out-Null; if($LASTEXITCODE -ne 0){ throw 'icacls reset' }; & icacls.exe $c.FullName /setowner '*S-1-5-32-544' /t /c /l | Out-Null; if($LASTEXITCODE -ne 0){ throw 'icacls setowner' } } +[IO.File]::Delete((Join-Path $d '` + RegFile + `')) +` + +const readDirScript = `$ErrorActionPreference='Stop' +$d='` + ProtectedDir + `' +$i=Get-Item -LiteralPath $d -Force +[pscustomobject]@{reparse=(($i.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0);sddl=(Get-Acl -LiteralPath $d).GetSecurityDescriptorSddlForm('All')} | ConvertTo-Json -Compress +` + +type dirInfo struct { + Reparse bool `json:"reparse"` + SDDL string `json:"sddl"` +} + +var ( + reSDDLOwner = regexp.MustCompile(`O:([A-Z]{2}|S-[0-9-]+)`) + reSDDLDACL = regexp.MustCompile(`D:([A-Z]*)((?:\([^)]*\))*)`) +) + +// checkDirSDDL confere que a ACL é EXATAMENTE: dono Administradores (BA), DACL protegida (sem herança) e só duas ACEs de +// permissão FullControl (FA) com herança de objeto e contêiner (OICI) para SYSTEM (SY) e Administradores (BA). Nenhuma ACE +// para Users, Authenticated Users ou Everyone. (A forma exata do SDDL que o Windows devolve é A VERIFICAR em VM.) +func checkDirSDDL(sddl string) error { + bad := func(why string) error { return fmt.Errorf("a ACL da pasta protegida não é a esperada: %s", why) } + o := reSDDLOwner.FindStringSubmatch(sddl) + if o == nil || (o[1] != "BA" && o[1] != "S-1-5-32-544") { + return bad("o dono não é Administradores") + } + d := reSDDLDACL.FindStringSubmatch(sddl) + if d == nil { + return bad("sem DACL") + } + if !strings.Contains(d[1], "P") { + return bad("a herança não foi desligada") + } + aces := regexp.MustCompile(`\(([^)]*)\)`).FindAllStringSubmatch(d[2], -1) + got := map[string]bool{} + for _, a := range aces { + f := strings.Split(a[1], ";") + if len(f) != 6 || f[0] != "A" || f[2] != "FA" || f[1] != "OICI" { + return bad("há uma ACE que não é de FullControl herdável") + } + switch f[5] { + case "SY", "S-1-5-18": + got["SY"] = true + case "BA", "S-1-5-32-544": + got["BA"] = true + default: + return bad("há uma ACE para " + f[5]) + } + } + if len(aces) != 2 || !got["SY"] || !got["BA"] { + return bad("deveria haver só SYSTEM e Administradores") + } + return nil +} + +// ProtectDir cria e protege a pasta e RELÊ a ACL (SDDL, que não depende do idioma); ACL diferente da esperada é erro. +func (w *windowsSystem) ProtectDir(ctx context.Context, dir string) error { + if dir != w.dir { + return invalid("pasta de backup inesperada") + } + if err := w.psWrite(ctx, protectDirScript); err != nil { + return fmt.Errorf("não deu para criar e proteger a pasta: %w", err) + } + r, err := w.psRead(ctx, cmdTimeout, readDirScript) + if err != nil { + return fmt.Errorf("não deu para reler a ACL da pasta: %w", err) + } + var info dirInfo + if err := json.Unmarshal(r.Stdout, &info); err != nil { + return fmt.Errorf("leitura da ACL ilegível") + } + if info.Reparse { + return fmt.Errorf("a pasta protegida é um ponto de reparse (link): recusada") + } + return checkDirSDDL(info.SDDL) +} + +// stageSelf copia o toolkit em execução para dir e confere o SHA-256 da cópia. +func stageSelf(dir string) (StagedBinary, error) { + src, err := os.Executable() + if err != nil { + return StagedBinary{}, err + } + return copyAndHash(src, dir) +} + +func copyAndHash(src, dir string) (StagedBinary, error) { + in, err := os.Open(src) + if err != nil { + return StagedBinary{}, err + } + defer func() { _ = in.Close() }() + tmp, err := os.CreateTemp(dir, ".revert-*.tmp") + if err != nil { + return StagedBinary{}, err + } + name := tmp.Name() + defer func() { _ = os.Remove(name) }() + h := sha256.New() + if _, err := io.Copy(io.MultiWriter(tmp, h), in); err != nil { + _ = tmp.Close() + return StagedBinary{}, err + } + if err := tmp.Close(); err != nil { + return StagedBinary{}, err + } + dst := filepath.Join(dir, RevertBinary) + if err := os.Rename(name, dst); err != nil { + return StagedBinary{}, err + } + srcSum := hex.EncodeToString(h.Sum(nil)) + out, err := os.Open(dst) + if err != nil { + return StagedBinary{}, err + } + defer func() { _ = out.Close() }() + h2 := sha256.New() + if _, err := io.Copy(h2, out); err != nil { + return StagedBinary{}, err + } + return StagedBinary{Path: dir + `\` + RevertBinary, SourceSHA: srcSum, CopySHA: hex.EncodeToString(h2.Sum(nil))}, nil +} + +// StageBinary copia o toolkit para a pasta protegida (a tarefa de reversão executa essa cópia, com ACL só de SYSTEM e +// Administradores, nunca um binário editável por usuário comum). +func (w *windowsSystem) StageBinary(_ context.Context, dir string) (StagedBinary, error) { + if dir != w.dir { + return StagedBinary{}, invalid("pasta de backup inesperada") + } + return w.stage(dir) +} + +// --- tarefa agendada --- + +func armTaskScript(minutes int) string { + return `$ErrorActionPreference='Stop' +$a=New-ScheduledTaskAction -Execute '` + taskExe() + `' -Argument '` + RevertArgs + `' +$t=New-ScheduledTaskTrigger -Once -At ((Get-Date).AddMinutes(` + strconv.Itoa(minutes) + `)) +$p=New-ScheduledTaskPrincipal -UserId 'S-1-5-18' -LogonType ServiceAccount -RunLevel Highest +$s=New-ScheduledTaskSettingsSet -StartWhenAvailable -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit (New-TimeSpan -Minutes 5) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1) +Register-ScheduledTask -TaskName '` + TaskName + `' -TaskPath '` + TaskPath + `' -Action $a -Trigger $t -Principal $p -Settings $s | Out-Null +` +} + +const readTaskScript = `$ErrorActionPreference='Stop' +$t=Get-ScheduledTask -TaskName '` + TaskName + `' -TaskPath '` + TaskPath + `' -ErrorAction SilentlyContinue +if(-not $t){ [pscustomobject]@{exists=$false} | ConvertTo-Json -Compress; exit 0 } +$i=Get-ScheduledTaskInfo -TaskName '` + TaskName + `' -TaskPath '` + TaskPath + `' +$a=@($t.Actions) +$n=$null +if($i.NextRunTime -and $i.NextRunTime.Year -gt 2000){ $n=$i.NextRunTime.ToUniversalTime().ToString('o') } +[pscustomobject]@{exists=$true;enabled=($t.State.ToString() -ne 'Disabled');exe=[string]$a[0].Execute;args=[string]$a[0].Arguments;user=[string]$t.Principal.UserId;next=$n;actions=$a.Count;triggers=@($t.Triggers).Count} | ConvertTo-Json -Compress +` + +const deleteTaskScript = `$ErrorActionPreference='Stop' +Unregister-ScheduledTask -TaskName '` + TaskName + `' -TaskPath '` + TaskPath + `' -Confirm:$false +` + +// ArmTask cria a ÚNICA tarefa do toolkit: SYSTEM, execução única daqui a Minutes, "executar assim que possível" se o horário +// passar (StartWhenAvailable), comando fixo. Programa, argumento e prazo são conferidos ANTES de montar o script. Sem -Force: +// uma tarefa de mesmo nome já existente é erro, nunca sobrescrita. +func (w *windowsSystem) ArmTask(ctx context.Context, spec TaskSpec) error { + if !strings.EqualFold(spec.Exe, taskExe()) || spec.Args != RevertArgs { + return invalid("a tarefa só pode executar o binário da pasta protegida com o argumento fixo") + } + if spec.Minutes < PrazoMinimo || spec.Minutes > PrazoMaximo { + return fmt.Errorf("%w: %d minutos", ErrPrazo, spec.Minutes) + } + return w.psWrite(ctx, armTaskScript(spec.Minutes)) +} + +type taskJSON struct { + Exists bool `json:"exists"` + Enabled bool `json:"enabled"` + Exe string `json:"exe"` + Args string `json:"args"` + User string `json:"user"` + Next *string `json:"next"` + Actions int `json:"actions"` + Triggers int `json:"triggers"` +} + +// ReadTask lê a tarefa (Get-ScheduledTask e Get-ScheduledTaskInfo, em JSON: não depende do idioma). Mais de uma ação ou +// gatilho vira um programa/comando que nunca confere (a conferência do chamador recusa). +func (w *windowsSystem) ReadTask(ctx context.Context) (TaskInfo, error) { + r, err := w.psRead(ctx, cmdTimeout, readTaskScript) + if err != nil { + return TaskInfo{}, err + } + var tj taskJSON + if err := json.Unmarshal([]byte(strings.TrimPrefix(strings.TrimSpace(string(r.Stdout)), "\ufeff")), &tj); err != nil { + return TaskInfo{}, fmt.Errorf("leitura da tarefa ilegível") + } + if !tj.Exists { + return TaskInfo{}, nil + } + ti := TaskInfo{Exists: true, Enabled: tj.Enabled, Exe: textsafe.Line(tj.Exe), Args: textsafe.Line(tj.Args), User: textsafe.Line(tj.User)} + if tj.Actions != 1 || tj.Triggers != 1 { + ti.Exe = "(a tarefa tem " + strconv.Itoa(tj.Actions) + " ação(ões) e " + strconv.Itoa(tj.Triggers) + " gatilho(s))" + } + if tj.Next != nil { + t, err := time.Parse(time.RFC3339Nano, *tj.Next) + if err != nil { + return TaskInfo{}, fmt.Errorf("próximo disparo ilegível") + } + ti.Next = t.UTC() + } + return ti, nil +} + +// DeleteTask remove a tarefa do toolkit (nome fixo). +func (w *windowsSystem) DeleteTask(ctx context.Context) error { + return w.psWrite(ctx, deleteTaskScript) +} + +// --- PnP --- + +const readDevicesScript = `$ErrorActionPreference='Stop' +[Console]::OutputEncoding=New-Object System.Text.UTF8Encoding $false +$o=@() +foreach($x in @(Get-PnpDevice -PresentOnly)){ +$p=@(Get-PnpDeviceProperty -InstanceId $x.InstanceId -KeyName 'DEVPKEY_Device_Parent','DEVPKEY_Device_HardwareIds','DEVPKEY_Device_CompatibleIds' -ErrorAction SilentlyContinue) +$h=@{} +foreach($r in $p){ $h[$r.KeyName]=$r.Data } +$n=[string]$x.FriendlyName +if(-not $n){ $n=[string]$x.Name } +$o+=[pscustomobject]@{InstanceId=[string]$x.InstanceId;Parent=[string]$h['DEVPKEY_Device_Parent'];Name=$n;Class=[string]$x.Class;ClassGuid=[string]$x.ClassGuid;HardwareIds=@($h['DEVPKEY_Device_HardwareIds']);CompatibleIds=@($h['DEVPKEY_Device_CompatibleIds'])} +} +[pscustomobject]@{count=$o.Count;devices=$o} | ConvertTo-Json -Compress -Depth 4 +` + +// Devices lê o PnP (só leitura): dispositivos presentes com pai, classe e IDs, em JSON com a contagem (para detectar leitura +// cortada). Formato e disponibilidade por versão do Windows: A VERIFICAR em VM. +func (w *windowsSystem) Devices(ctx context.Context) ([]Device, error) { + r, err := w.psRead(ctx, pnpTimeout, readDevicesScript) + if err != nil { + return nil, err + } + return ParseDevices(r.Stdout) +} diff --git a/internal/usb/windows_test.go b/internal/usb/windows_test.go new file mode 100644 index 0000000..f4f5257 --- /dev/null +++ b/internal/usb/windows_test.go @@ -0,0 +1,695 @@ +package usb + +import ( + "context" + "encoding/json" + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + "testing" + "time" + + "github.com/PiluTech/toolkit/internal/exec" +) + +// winSim é um Windows SIMULADO por trás do exec.Runner: interpreta só os comandos que o toolkit monta (reg.exe e os scripts +// fixos do PowerShell), guarda o estado em memória e registra TODA chamada para o teste do contrato. Nada real é tocado. +type winSim struct { + t *testing.T + now time.Time + edition string + devs []Device + tree RegTree + task *simTask + locked bool // pasta protegida criada + calls []exec.Cmd + failPS string // trecho do script que falha + badSDDL bool +} + +type simTask struct { + minutes int + next time.Time +} + +const goodSDDL = `O:BAG:SYD:PAI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)` + +func newSim(t *testing.T) *winSim { + return &winSim{t: t, now: t0, edition: "Professional", devs: machine(usbKeyboard("0001"), usbPendrive("0003")), tree: RegTree{Entries: map[string]RegValue{}}} +} + +func (s *winSim) LookPath(string) (string, error) { return "", os.ErrNotExist } + +func ok(out string) (exec.Result, error) { return exec.Result{Stdout: []byte(out)}, nil } +func code(c int, out string) (exec.Result, error) { + return exec.Result{ExitCode: c, Stdout: []byte(out)}, nil +} + +func (s *winSim) Run(_ context.Context, c exec.Cmd) (exec.Result, error) { + s.calls = append(s.calls, c) + switch c.Name { + case regExe: + return s.reg(c.Args) + case psExe: + if len(c.Args) != 4 || c.Args[0] != "-NoProfile" || c.Args[1] != "-NonInteractive" || c.Args[2] != "-Command" { + s.t.Errorf("argumentos do powershell inesperados: %v", c.Args) + return code(1, "") + } + return s.ps(c.Args[3]) + } + s.t.Errorf("executável inesperado: %s", c.Name) + return code(1, "") +} + +func (s *winSim) reg(a []string) (exec.Result, error) { + switch a[0] { + case "query": + key := a[1] + if key == editionKey { + return ok(regRootName(editionKey) + "\r\n EditionID REG_SZ " + s.edition + "\r\n") + } + if key == RestrictionsKey { + if !s.tree.KeyExists { + return code(1, "") + } + return ok(s.renderTree()) + } + if key == restrictionsDir { + return code(1, "") // DeviceInstall não existe + } + return ok(regRootName(key) + "\r\n" + regRootName(key) + `\Outra` + "\r\n") // ancestral listável, sem DeviceInstall + case "add": + rel := strings.TrimPrefix(strings.TrimPrefix(a[1], RestrictionsKey), `\`) + name := a[3] + path := name + if rel != "" { + path = rel + `\` + name + } + var v RegValue + if a[5] == "REG_DWORD" { + n, _ := strconv.Atoi(a[7]) + v = DWORD(uint32(n)) + } else { + v = String(a[7]) + } + s.tree.KeyExists = true + if rel != "" { + f := &fakeSys{tree: s.tree} + f.addSubkey(rel) + s.tree.Subkeys = f.tree.Subkeys + } + s.tree.Entries[path] = v + return ok("") + case "delete": + rel := strings.TrimPrefix(strings.TrimPrefix(a[1], RestrictionsKey), `\`) + if len(a) >= 5 && a[2] == "/v" { + path := a[3] + if rel != "" { + path = rel + `\` + a[3] + } + delete(s.tree.Entries, path) + return ok("") + } + if rel == "" { + s.tree.KeyExists = false + } else { + var keep []string + for _, k := range s.tree.Subkeys { + if k != rel { + keep = append(keep, k) + } + } + s.tree.Subkeys = keep + } + return ok("") + case "export": + return ok("") + } + s.t.Errorf("reg.exe com verbo inesperado: %v", a) + return code(1, "") +} + +func (s *winSim) renderTree() string { + var b strings.Builder + root := regRootName(RestrictionsKey) + b.WriteString(root + "\r\n") + emit := func(prefix string) { + for k, v := range s.tree.Entries { + dir, name := "", k + if i := strings.LastIndex(k, `\`); i >= 0 { + dir, name = k[:i], k[i+1:] + } + if dir != prefix { + continue + } + if v.Kind == 0 { + fmt.Fprintf(&b, " %s REG_DWORD 0x%x\r\n", name, v.DWORD) + } else { + fmt.Fprintf(&b, " %s REG_SZ %s\r\n", name, v.Str) + } + } + b.WriteString("\r\n") + } + emit("") + for _, sub := range s.tree.Subkeys { + b.WriteString(root + `\` + sub + "\r\n") + emit(sub) + } + return b.String() +} + +func (s *winSim) ps(script string) (exec.Result, error) { + if s.failPS != "" && strings.Contains(script, s.failPS) { + return exec.Result{ExitCode: 1, Stderr: []byte("falha simulada")}, nil + } + switch { + case strings.Contains(script, "Get-PnpDevice"): + env := map[string]any{"count": len(s.devs)} + var raws []map[string]any + for _, d := range s.devs { + raws = append(raws, map[string]any{"InstanceId": d.InstanceID, "Parent": d.Parent, "Name": d.Name, "Class": d.Class, "ClassGuid": d.ClassGUID, "HardwareIds": d.HardwareIDs, "CompatibleIds": d.CompatibleIDs}) + } + env["devices"] = raws + b, _ := json.Marshal(env) + return ok(string(b)) + case strings.Contains(script, "SetAccessRuleProtection"): + s.locked = true + return ok("") + case strings.Contains(script, "GetSecurityDescriptorSddlForm"): + sddl := goodSDDL + if s.badSDDL { + sddl = `O:BAG:SYD:AI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;0x1200a9;;;BU)` + } + return ok(fmt.Sprintf(`{"reparse":false,"sddl":%q}`, sddl)) + case strings.Contains(script, "Register-ScheduledTask"): + i := strings.Index(script, "AddMinutes(") + j := strings.Index(script[i:], ")") + n, _ := strconv.Atoi(script[i+len("AddMinutes(") : i+j]) + s.task = &simTask{minutes: n, next: s.now.Add(time.Duration(n) * time.Minute)} + return ok("") + case strings.Contains(script, "Unregister-ScheduledTask"): + s.task = nil + return ok("") + case strings.Contains(script, "Get-ScheduledTask"): + if s.task == nil { + return ok(`{"exists":false}`) + } + return ok(fmt.Sprintf(`{"exists":true,"enabled":true,"exe":%q,"args":%q,"user":"S-1-5-18","next":%q,"actions":1,"triggers":1}`, taskExe(), RevertArgs, s.task.next.Format(time.RFC3339Nano))) + } + s.t.Errorf("script inesperado: %.80s", script) + return code(1, "") +} + +func simSystem(t *testing.T, s *winSim) (*windowsSystem, FileStore) { + t.Helper() + dir := t.TempDir() + w := NewWindowsSystem(s, func() bool { return true }).(*windowsSystem) + w.dir = dir + w.stage = func(string) (StagedBinary, error) { + return StagedBinary{Path: taskExe(), SourceSHA: strings.Repeat("c", 64), CopySHA: strings.Repeat("c", 64)}, nil + } + return w, FileStore{Dir: dir} +} + +// --- contrato dos comandos --- + +func TestScriptsSaoASCIISemAspasDuplas(t *testing.T) { + scripts := map[string]string{"protectDir": protectDirScript, "readDir": readDirScript, "armTask": armTaskScript(10), "readTask": readTaskScript, "deleteTask": deleteTaskScript, "devices": readDevicesScript} + for name, sc := range scripts { + if err := asciiOnly(sc); err != nil { + t.Errorf("%s: %v", name, err) + } + if strings.Contains(sc, `"`) { + t.Errorf("%s tem aspas duplas (o Go as escapa na linha de comando; scripts não precisam delas)", name) + } + } + if asciiOnly("Get-PnpDevice \u00e7") == nil || asciiOnly("a\x00b") == nil { + t.Error("asciiOnly deveria recusar não-ASCII e NUL") + } +} + +func TestContratoFluxoCompletoAplicarConfirmarDesfazer(t *testing.T) { + sim := newSim(t) + w, st := simSystem(t, sim) + if _, err := Apply(context.Background(), w, st, ApplyOptions{Prazo: 10, Now: t0}); err != nil { + t.Fatalf("Apply: %v", err) + } + if sim.task == nil || sim.task.minutes != 10 || !sim.locked { + t.Fatalf("estado simulado: %#v", sim.task) + } + if err := Confirm(context.Background(), w, st); err != nil { + t.Fatalf("Confirm: %v", err) + } + if sim.task != nil { + t.Fatal("a tarefa deveria ter saído") + } + if _, err := Undo(context.Background(), w, st); err != nil { + t.Fatalf("Undo: %v", err) + } + if sim.tree.KeyExists || len(sim.tree.Entries) != 0 { + t.Fatalf("o registro não voltou ao original: %v", sim.tree) + } + + var regWrites, taskOps int + for _, c := range sim.calls { + if c.Elevate { + t.Errorf("Elevate em %s %v: o toolkit nunca eleva sozinho", c.Name, c.Args) + } + if c.Name != regExe && c.Name != psExe { + t.Errorf("executável fora do contrato: %s", c.Name) + } + if !strings.HasPrefix(c.Name, `C:\Windows\System32\`) { + t.Errorf("caminho não absoluto: %s", c.Name) + } + if c.Name == regExe { + verb := c.Args[0] + switch verb { + case "add", "delete", "export": + if c.ReadOnly { + t.Errorf("mutação marcada ReadOnly: %v", c.Args) + } + if verb != "export" { + regWrites++ + } + if !strings.HasPrefix(c.Args[1], RestrictionsKey) { // sensível a maiúsculas, prefixo exato + t.Errorf("escrita no registro fora de Restrictions: %v", c.Args) + } + if len(c.Args[1]) > len(RestrictionsKey) && c.Args[1][len(RestrictionsKey)] != '\\' { + t.Errorf("chave fora de Restrictions (prefixo parcial): %v", c.Args) + } + case "query": + if !c.ReadOnly { + t.Errorf("leitura sem ReadOnly: %v", c.Args) + } + default: + t.Errorf("verbo do reg.exe fora do contrato: %v", c.Args) + } + for _, a := range c.Args { + if strings.HasPrefix(a, "HKCU") || strings.Contains(a, "HKEY_CURRENT_USER") || strings.Contains(a, "CurrentControlSet") { + t.Errorf("chave fora do contrato: %v", c.Args) + } + } + } + if c.Name == psExe { + script := c.Args[3] + if err := asciiOnly(script); err != nil { + t.Errorf("script não ASCII: %v", err) + } + mut := strings.Contains(script, "Register-ScheduledTask") || strings.Contains(script, "Unregister-ScheduledTask") || strings.Contains(script, "Set-Acl") + if mut == c.ReadOnly { + t.Errorf("ReadOnly=%v incoerente com o script %.60s", c.ReadOnly, script) + } + if strings.Contains(script, "Register-ScheduledTask") || strings.Contains(script, "Unregister-ScheduledTask") || strings.Contains(script, "Get-ScheduledTask") { + taskOps++ + if !strings.Contains(script, "'"+TaskName+"'") || !strings.Contains(script, "'"+TaskPath+"'") { + t.Errorf("operação de tarefa que não é só a do toolkit: %.100s", script) + } + if strings.Contains(script, "-Force") || strings.Contains(script, "Get-ScheduledTask |") || strings.Contains(script, "-TaskName *") { + t.Errorf("operação ampla/forçada de tarefa: %.100s", script) + } + } + for _, bad := range []string{"Invoke-Expression", "iex ", "Start-Process", "DownloadString", "Remove-Item", "-ExecutionPolicy", "Restart-Computer", "shutdown"} { + if strings.Contains(script, bad) { + t.Errorf("script usa %q", bad) + } + } + } + } + if regWrites == 0 || taskOps == 0 { + t.Fatalf("o fluxo não exercitou escritas (%d) e tarefa (%d)", regWrites, taskOps) + } +} + +func TestContratoNenhumaEscritaEmDenyUnspecifiedNemClassesAmplas(t *testing.T) { + sim := newSim(t) + w, st := simSystem(t, sim) + if _, err := Apply(context.Background(), w, st, ApplyOptions{Prazo: 10, Now: t0}); err != nil { + t.Fatal(err) + } + for _, c := range sim.calls { + if c.Name != regExe || c.Args[0] != "add" { + continue + } + line := strings.Join(c.Args, " ") + for _, bad := range []string{"DenyUnspecified", "DenyDeviceIDs", "Retroactive", strings.ToLower(guidKeyboard), strings.ToLower(guidMouse), strings.ToLower(guidHID), strings.ToLower(guidDisk)} { + if strings.Contains(strings.ToLower(line), strings.ToLower(bad)) { + t.Errorf("escrita com %q: %s", bad, line) + } + } + } +} + +func TestContratoSemAdminNenhumComandoDeMutacao(t *testing.T) { + sim := newSim(t) + w, st := simSystem(t, sim) + w.elevated = func() bool { return false } + if _, err := Apply(context.Background(), w, st, ApplyOptions{Prazo: 10, Now: t0}); err == nil { + t.Fatal("devia recusar") + } + if len(sim.calls) != 1 { // só a leitura da edição + t.Fatalf("chamadas = %d (só a edição pode ser lida antes de recusar): %v", len(sim.calls), sim.calls) + } +} + +func TestContratoPlanoSoLeitura(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + if _, err := BuildPlan(context.Background(), w, nil); err != nil { + t.Fatal(err) + } + for _, c := range sim.calls { + if !c.ReadOnly || c.Elevate { + t.Errorf("o plano executou algo que não é leitura: %v %v", c.Name, c.Args) + } + } +} + +func TestContratoACLAmplaAbortaAntesDeQualquerChave(t *testing.T) { + sim := newSim(t) + sim.badSDDL = true + w, st := simSystem(t, sim) + if _, err := Apply(context.Background(), w, st, ApplyOptions{Prazo: 10, Now: t0}); err == nil { + t.Fatal("ACL ampla devia abortar") + } + for _, c := range sim.calls { + if c.Name == regExe && c.Args[0] != "query" { + t.Fatalf("escreveu no registro com a ACL ampla: %v", c.Args) + } + } + if sim.task != nil { + t.Fatal("criou tarefa com a ACL ampla") + } +} + +func TestContratoFalhaDoPowerShellAoArmarAbortaSemChaves(t *testing.T) { + sim := newSim(t) + sim.failPS = "Register-ScheduledTask" + w, st := simSystem(t, sim) + if _, err := Apply(context.Background(), w, st, ApplyOptions{Prazo: 10, Now: t0}); err == nil { + t.Fatal("devia falhar") + } + for _, c := range sim.calls { + if c.Name == regExe && c.Args[0] == "add" { + t.Fatalf("escreveu chave sem a tarefa armada: %v", c.Args) + } + } + if sn, _ := st.Load(); sn != nil { + t.Error("backup deste Apply ficou") + } +} + +// --- unidades da implementação real --- + +func TestEditionMapeamento(t *testing.T) { + for id, want := range map[string]string{"Professional": EditionPro, "ProfessionalWorkstation": EditionPro, "Enterprise": EditionEnterprise, "EnterpriseS": EditionEnterprise, + "Education": EditionEducation, "Core": EditionHome, "CoreN": EditionHome, "CoreSingleLanguage": EditionHome, "ServerStandard": EditionOther, "IoTEnterprise": EditionOther, "": EditionOther} { + sim := newSim(t) + sim.edition = id + w, _ := simSystem(t, sim) + got, err := w.Edition(context.Background()) + if err != nil || got != want { + t.Errorf("%q -> %q (%v), queria %q", id, got, err, want) + } + } +} + +func TestReadTreeAusenciaProvadaEAcessoNegado(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + tr, err := w.ReadTree(context.Background()) + if err != nil || tr.KeyExists || len(tr.Entries) != 0 { + t.Fatalf("ausente: %v %v", tr, err) + } + // acesso negado: reg query sai 1 e o ancestral LISTA a chave => existe mas não abriu + denied := &winSim{t: t, tree: RegTree{}} + rn := &denyRunner{winSim: denied} + w2 := NewWindowsSystem(rn, nil) + if _, err := w2.ReadTree(context.Background()); err == nil { + t.Fatal("acesso negado não pode virar 'ausente'") + } + // nenhum ancestral lista: não prova nada + rn2 := &noProofRunner{winSim: denied} + if _, err := NewWindowsSystem(rn2, nil).ReadTree(context.Background()); err == nil { + t.Fatal("sem prova de ausência tem de ser erro") + } +} + +type denyRunner struct{ *winSim } + +func (d *denyRunner) Run(_ context.Context, c exec.Cmd) (exec.Result, error) { + switch c.Args[1] { + case RestrictionsKey: + return exec.Result{ExitCode: 1}, nil + case restrictionsDir: + return exec.Result{Stdout: []byte(regRootName(restrictionsDir) + "\r\n" + regRootName(RestrictionsKey) + "\r\n")}, nil + } + return exec.Result{ExitCode: 1}, nil +} + +type noProofRunner struct{ *winSim } + +func (d *noProofRunner) Run(context.Context, exec.Cmd) (exec.Result, error) { + return exec.Result{ExitCode: 1}, nil +} + +func TestParseRegListTiposENomes(t *testing.T) { + out := regRootName(RestrictionsKey) + "\r\n (Default) REG_SZ (value not set)\r\n AllowDenyLayered REG_DWORD 0x1\r\n\r\n" + + regRootName(RestrictionsKey) + `\AllowDeviceIDs` + "\r\n 1 REG_SZ USB\\VID_FFFF&PID_0001\r\n 2 REG_EXPAND_SZ %X%\r\n" + vals, subs, err := parseRegList(out, RestrictionsKey) + if err != nil { + t.Fatal(err) + } + if vals["AllowDenyLayered"].DWORD != 1 || vals[`AllowDeviceIDs\1`].Str != `USB\VID_FFFF&PID_0001` || vals[`AllowDeviceIDs\2`].Str != "%X%" || len(subs) != 1 || subs[0] != "AllowDeviceIDs" { + t.Fatalf("vals=%v subs=%v", vals, subs) + } + for name, bad := range map[string]string{ + "multi_sz": regRootName(RestrictionsKey) + "\r\n X REG_MULTI_SZ a\\0b\r\n", + "binary": regRootName(RestrictionsKey) + "\r\n X REG_BINARY 00FF\r\n", + "default": regRootName(RestrictionsKey) + "\r\n (Default) REG_SZ algo\r\n", + "cabecalho": "HKEY_CURRENT_USER\\Software\\X\r\n A REG_DWORD 0x1\r\n", + "dword": regRootName(RestrictionsKey) + "\r\n A REG_DWORD zz\r\n", + "formato": regRootName(RestrictionsKey) + "\r\n lixo sem tipo\r\n", + } { + if _, _, err := parseRegList(bad, RestrictionsKey); err == nil { + t.Errorf("%s: aceitou", name) + } + } +} + +func TestRegWriteEDeleteRecusamForaDaListaSemExecutar(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + for _, p := range []string{"DenyUnspecified", `DenyDeviceIDs\1`, `..\x`, `AllowDeviceIDs\0`} { + if err := w.RegWrite(context.Background(), p, DWORD(1)); err == nil { + t.Errorf("RegWrite(%q) aceito", p) + } + if err := w.RegDelete(context.Background(), p); err == nil { + t.Errorf("RegDelete(%q) aceito", p) + } + } + if err := w.RegWrite(context.Background(), "AllowDenyLayered", DWORD(0)); err == nil { + t.Error("valor 0 na camada aceito") + } + if err := w.KeyDelete(context.Background(), "Run"); err == nil { + t.Error("KeyDelete fora da lista aceito") + } + if len(sim.calls) != 0 { + t.Fatalf("executou comandos mesmo com entrada inválida: %v", sim.calls) + } +} + +func TestKeyDeleteSoQuandoVazia(t *testing.T) { + sim := newSim(t) + sim.tree = RegTree{KeyExists: true, Subkeys: []string{"AllowDeviceIDs"}, Entries: map[string]RegValue{`AllowDeviceIDs\1`: String(`USB\VID_AAAA&PID_0001`)}} + w, _ := simSystem(t, sim) + if err := w.KeyDelete(context.Background(), "AllowDeviceIDs"); err == nil { + t.Fatal("apagou subchave com valor dentro") + } + if err := w.KeyDelete(context.Background(), ""); err == nil { + t.Fatal("apagou Restrictions com conteúdo") + } + for _, c := range sim.calls { + if c.Name == regExe && c.Args[0] == "delete" { + t.Fatalf("executou delete: %v", c.Args) + } + } +} + +func TestArmTaskRecusaComandoQueNaoEODoToolkit(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + for _, spec := range []TaskSpec{ + {Exe: `C:\Users\Public\x.exe`, Args: RevertArgs, Minutes: 10}, + {Exe: taskExe(), Args: "usb desfazer --yes", Minutes: 10}, + {Exe: taskExe(), Args: RevertArgs, Minutes: 1}, + {Exe: taskExe(), Args: RevertArgs, Minutes: 61}, + {Exe: taskExe(), Args: RevertArgs + "; calc", Minutes: 10}, + } { + if err := w.ArmTask(context.Background(), spec); err == nil { + t.Errorf("aceitou %v", spec) + } + } + if len(sim.calls) != 0 { + t.Fatalf("executou: %v", sim.calls) + } + if err := w.ArmTask(context.Background(), TaskSpec{Exe: taskExe(), Args: RevertArgs, Minutes: 7}); err != nil { + t.Fatal(err) + } + sc := sim.calls[0].Args[3] + for _, want := range []string{"AddMinutes(7)", "S-1-5-18", "-StartWhenAvailable", "'" + taskExe() + "'", "'" + RevertArgs + "'"} { + if !strings.Contains(sc, want) { + t.Errorf("script sem %q:\n%s", want, sc) + } + } +} + +func TestReadTaskVariacoes(t *testing.T) { + run := func(out string) (TaskInfo, error) { + rn := &psOut{out: out} + return NewWindowsSystem(rn, nil).ReadTask(context.Background()) + } + ti, err := run(`{"exists":false}`) + if err != nil || ti.Exists { + t.Fatalf("ausente: %v %v", ti, err) + } + ti, err = run(`{"exists":true,"enabled":true,"exe":"C:\\x.exe","args":"usb reverter","user":"SYSTEM","next":"2026-11-14T12:10:00.0000000Z","actions":1,"triggers":1}`) + if err != nil || !ti.Exists || !ti.Enabled || ti.User != "SYSTEM" || !ti.Next.Equal(t0.Add(10*time.Minute)) { + t.Fatalf("ti=%#v err=%v", ti, err) + } + ti, _ = run(`{"exists":true,"enabled":true,"exe":"C:\\x.exe","args":"usb reverter","user":"SYSTEM","next":null,"actions":2,"triggers":1}`) + if !ti.Next.IsZero() || !strings.Contains(ti.Exe, "ação") { + t.Fatalf("duas ações devem virar programa que não confere: %#v", ti) + } + if _, err := run(`not json`); err == nil { + t.Fatal("lixo aceito") + } + if _, err := run(`{"exists":true,"next":"ontem"}`); err == nil { + t.Fatal("data ilegível aceita") + } +} + +type psOut struct{ out string } + +func (p *psOut) Run(context.Context, exec.Cmd) (exec.Result, error) { + return exec.Result{Stdout: []byte(p.out)}, nil +} +func (p *psOut) LookPath(string) (string, error) { return "", os.ErrNotExist } + +func TestCheckDirSDDL(t *testing.T) { + if err := checkDirSDDL(goodSDDL); err != nil { + t.Fatal(err) + } + if err := checkDirSDDL(`O:BAG:SYD:PAI(A;OICI;FA;;;BA)(A;OICI;FA;;;SY)`); err != nil { + t.Fatalf("ordem das ACEs não importa: %v", err) + } + for name, s := range map[string]string{ + "dono Users": `O:BUG:SYD:PAI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)`, + "sem protecao": `O:BAG:SYD:AI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)`, + "ACE de Users": `O:BAG:SYD:PAI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;0x1200a9;;;BU)`, + "Everyone": `O:BAG:SYD:PAI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;WD)`, + "Authenticated": `O:BAG:SYD:PAI(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;AU)`, + "so SYSTEM": `O:BAG:SYD:PAI(A;OICI;FA;;;SY)`, + "sem heranca": `O:BAG:SYD:PAI(A;;FA;;;SY)(A;;FA;;;BA)`, + "direito parcial": `O:BAG:SYD:PAI(A;OICI;0x1200a9;;;SY)(A;OICI;FA;;;BA)`, + "negacao": `O:BAG:SYD:PAI(D;OICI;FA;;;SY)(A;OICI;FA;;;BA)`, + "vazio": ``, + } { + if err := checkDirSDDL(s); err == nil { + t.Errorf("%s: aceitou %q", name, s) + } + } +} + +func TestProtectDirRecusaPontoDeReparseEPastaInesperada(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + if err := w.ProtectDir(context.Background(), `C:\Outra`); err == nil { + t.Fatal("pasta inesperada aceita") + } + rn := &psOut{out: `{"reparse":true,"sddl":"` + goodSDDL + `"}`} + w2 := NewWindowsSystem(rn, nil).(*windowsSystem) + if err := w2.ProtectDir(context.Background(), ProtectedDir); err == nil || !strings.Contains(err.Error(), "reparse") { + t.Fatalf("ponto de reparse aceito: %v", err) + } +} + +func TestCopyAndHashConfereACopia(t *testing.T) { + dir := t.TempDir() + src := filepath.Join(t.TempDir(), "toolkit.exe") + if err := os.WriteFile(src, []byte("binario sintetico"), 0o700); err != nil { + t.Fatal(err) + } + sb, err := copyAndHash(src, dir) + if err != nil { + t.Fatal(err) + } + if sb.SourceSHA == "" || sb.SourceSHA != sb.CopySHA { + t.Fatalf("hashes: %#v", sb) + } + b, _ := os.ReadFile(filepath.Join(dir, RevertBinary)) + if string(b) != "binario sintetico" { + t.Fatalf("cópia = %q", b) + } + ents, _ := os.ReadDir(dir) + for _, e := range ents { + if strings.HasSuffix(e.Name(), ".tmp") { + t.Errorf("temporário sobrou: %s", e.Name()) + } + } +} + +func TestDevicesLeitura(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + devs, err := w.Devices(context.Background()) + if err != nil || len(devs) != len(sim.devs) { + t.Fatalf("devs=%d err=%v", len(devs), err) + } + c := sim.calls[0] + if !c.ReadOnly || c.Elevate || c.Name != psExe { + t.Fatalf("cmd = %#v", c) + } + if !strings.Contains(c.Args[3], "-PresentOnly") || !strings.Contains(c.Args[3], "DEVPKEY_Device_Parent") { + t.Fatal("o script não lê os presentes com o pai") + } +} + +func TestContratoChaveVaziaPreExistenteExportaOReg(t *testing.T) { + sim := newSim(t) + sim.tree = RegTree{KeyExists: true, Entries: map[string]RegValue{}} + w, st := simSystem(t, sim) + // o .reg de verdade seria gravado pelo reg.exe; aqui o simulador não cria o arquivo: grava um sintético no lugar + if err := os.WriteFile(st.RegPath(), []byte("Windows Registry Editor Version 5.00\r\n"), 0o600); err != nil { + t.Fatal(err) + } + if _, err := Apply(context.Background(), w, st, ApplyOptions{Prazo: 10, Now: t0}); err != nil { + t.Fatal(err) + } + var exported bool + for _, c := range sim.calls { + if c.Name == regExe && c.Args[0] == "export" { + exported = true + if c.Args[1] != RestrictionsKey || c.ReadOnly || c.Elevate || !strings.HasSuffix(c.Args[2], RegFile) || c.Args[3] != "/y" { + t.Errorf("export fora do contrato: %v", c.Args) + } + } + } + if !exported { + t.Fatal("a chave existia: o .reg de segurança tinha de ser exportado") + } +} + +func TestExportRegSoParaOArquivoDaPastaProtegida(t *testing.T) { + sim := newSim(t) + w, _ := simSystem(t, sim) + for _, f := range []string{`C:\Users\Public\usb-restrictions-backup.reg`, w.dir + `\outro.reg`, `..\usb-restrictions-backup.reg`, w.dir + `\sub\` + RegFile, ""} { + if err := w.ExportReg(context.Background(), f); err == nil { + t.Errorf("aceitou exportar para %q", f) + } + } + if len(sim.calls) != 0 { + t.Fatalf("executou: %v", sim.calls) + } +}