Skip to content

Seguranca

PedroVMota edited this page Nov 13, 2026 · 2 revisions

Segurança

A segurança do código é a segunda prioridade do projeto. Os princípios: não há unsafe, todos os ficheiros são entrada hostil, não há rede e nada de um ficheiro é executado.

Código

Medida Onde
#![forbid(unsafe_code)] em todos os crates (incluindo bw-icon e os alvos de fuzzing), mais unsafe_code = "deny" nos lints do workspace src/lib.rs / main.rs de cada crate, Cargo.toml
Clippy pedantic em warn, -D warnings no make lint Cargo.toml, Makefile
unwrap_used e expect_used dão aviso fora dos testes Cargo.toml, clippy.toml
overflow-checks = true e panic = "abort" no perfil release (também no fuzzing) Cargo.toml, fuzz/Cargo.toml
Invariantes do modelo validadas na construção, em cada edição e na desserialização (#[serde(try_from)]); uma edição recusada não muda nada bw-core

Ficheiros = entrada hostil

Projetos e macros (.bitwerk, .bwmacro)

  • Tamanho máximo de 64 MiB, verificado antes e durante a leitura.
  • Profundidade de recursão do RON limitada a 64.
  • Limites de objetos: 1M componentes, 4M segmentos, 4M nós, 1M junções, 2M fios e 256 vértices por fio nos formatos antigos, nome com 256 bytes, 4096 memórias de no máximo 16K palavras de 16 bits.
  • Limites de macros: 4096 definições, profundidade 16, 2M componentes no desenho achatado (contra "bombas de macros"), 255 pinos por macro, datasheet de 64 KiB, ciclos recusados.
  • Anotações: 1 KiB e 16 linhas, sem caracteres de controlo.
  • Validação estrutural completa antes de qualquer dado chegar à aplicação; versões futuras dão erro explícito.
  • Gravação atómica (ficheiro temporário + rename).

Tabela completa em Formato de ficheiros.

Memória (.map e conteúdo no projeto)

Parsers próprios e limitados: .map com 1 MiB e 4 KiB por linha, tokens até 4 dígitos, valores e endereços verificados; conteúdo no projeto com 256 KiB de texto e contagens/totais verificados. Testados com dados malformados.

Digital Works (.dwm, .dwt, .map binário)

Parser próprio sem recursão (pilha explícita) com limites: 64 MiB, 2M objetos, 200 mil níveis de aninhamento, 256 classes, strings de 1 MiB, listas de 1M itens, 1M palavras de memória (verificadas contra os bytes restantes antes de reservar memória), coordenadas finitas, nada depois do fim. Uma classe desconhecida ou um valor com a etiqueta errada é um erro limpo. As referências são verificadas pelo tipo (uma inválida conta como nula e fica no relatório). O resultado passa pela mesma validação que um projeto. O caminho do datasheet de uma macro importada fica só como texto e nunca é aberto.

Exportação para o Digital Works

  • O escritor (dwm/writer.rs) usa os mesmos programas de campos que o leitor, percorre o grafo com uma pilha explícita (sem recursão) e verifica os limites do leitor (objetos, classes, listas, strings, palavras de memória, profundidade da pilha, 64 MiB no total): o que escreve, o leitor aceita.
  • Como o Digital Works copia as macros para dentro de cada instância, o exportador conta os objetos à medida que copia: uma hierarquia que passe os 2 milhões de objetos é recusada com erro (contra "bombas de macros" na exportação); a profundidade de macros continua limitada a 16.
  • Antes de entregar o ficheiro, o exportador volta a lê-lo com o leitor; um ficheiro que o bitwerk recusaria nunca é escrito.
  • A gravação é atómica (.dwm e .map), e a exportação corre numa thread própria.
  • Texto fora do Windows-1252 passa a ? (nada é escrito fora da code page).

Sem rede

  • Nenhuma dependência de rede.
  • O eframe é compilado sem a feature links, por isso nem sequer abre URLs.
  • Os símbolos, a biblioteca de peças e o ícone estão dentro do binário; nada é descarregado.

Abrir ficheiros de datasheet

O único sítio onde a app abre algo fora dela é o ficheiro de datasheet de uma macro (bw_io::datasheet::resolve_link):

  1. só depois de um clique explícito em Open datasheet file;
  2. tem de ser um caminho de ficheiro (absoluto ou relativo à pasta do projeto), nunca um URL: qualquer esquema: é recusado (http:, file:, javascript:, mailto:, esquemas próprios);
  3. o caminho é canonicalizado (resolve .. e links simbólicos) e tem de ser um ficheiro regular (um bundle .app é uma pasta e é recusado);
  4. a extensão do caminho canónico tem de estar na lista permitida: pdf, html, htm, txt, md;
  5. ficheiros com permissão de execução são recusados;
  6. a app corre /usr/bin/open <caminho canónico> diretamente, sem shell.

Há testes com URLs, um script, um .app, um ficheiro executável com extensão .pdf e um link simbólico .pdf que aponta para um script.

Biblioteca do utilizador

Só ficheiros .bwmacro dentro de ~/Library/Application Support/bitwerk/Parts; a leitura não segue links simbólicos, ignora entradas escondidas e limita profundidade e número de ficheiros; as operações (Rename, Move, Delete) só aceitam nomes saneados (sem separadores, sem ponto inicial, sem caracteres de controlo).

Fuzzing e testes de mutação

fuzz/ é um workspace separado (não afeta o build principal) com cinco alvos cargo-fuzz:

Alvo Entrada Invariantes
load_project bytes arbitrários → .bitwerk Nunca entra em pânico; o que é aceite grava e volta a ler-se igual (componentes, segmentos, nós, hashes das macros); tamanho achatado dentro do limite.
load_memory_map → .map Nunca entra em pânico; ida e volta igual.
load_macro → .bwmacro Tabela válida e acíclica, a raiz usa todas as definições, volta a ler-se igual.
load_dwm → .dwm, .dwt, .map do Digital Works Nunca entra em pânico; o que é aceite cumpre as invariantes e volta a ler-se depois de gravado.
roundtrip_dwm → leitor e exportador do Digital Works, e projetos .bitwerk Qualquer stream que o leitor aceite é reescrito pelo writer e volta a ler-se como o mesmo grafo (e o mesmo cabeçalho); qualquer circuito importado de um .dwm ou lido de um .bitwerk exporta sem pânico (só pode falhar por ser grande demais), o resultado volta a importar, e o mesmo para cada macro.

As seeds estão em fuzz/seeds/<alvo> (as do load_dwm são fixtures oficiais do Digital Works, com NOTICE; as do roundtrip_dwm são três ficheiros oficiais, também com NOTICE, e o exemplo half-adder.bitwerk).

cargo install --locked cargo-fuzz     # uma vez (precisa de nightly)
make fuzz                             # os cinco alvos, 5 min cada
make fuzz-check                       # só compila o crate de fuzzing (stable)

Como o fuzzing precisa de nightly, há também testes determinísticos em stable:

  • bw-io (mutated_wiring_never_panics_and_accepted_files_are_valid): ≈2100 mutações dos números da parte dos fios (ids, coordenadas, pinos) dos exemplos — nada pode dar pânico e tudo o que é aceite cumpre as invariantes do grafo e volta a ler-se igual.
  • bw-io/tests/dwm.rs (mutated_fixtures_never_panic): ≈4000 mutações de fixtures do Digital Works (bits trocados, etiquetas e inteiros alterados, pedaços apagados ou repetidos); as aceites são todas válidas e voltam a ler-se.
  • hostile_streams_are_clean_errors: corta um ficheiro em todos os tamanhos e testa classes desconhecidas, versões futuras, 300 mil níveis de aninhamento e uma memória com 2³¹ palavras.
  • bw-io/tests/dwm_export.rs: 120 circuitos aleatórios (todos os tipos, rotações, macros DIL) exportam sem falhar e voltam a importar.

Nota: o alvo roundtrip_dwm foi compilado (make fuzz-check), mas ainda não há registo de uma sessão de fuzzing com ele.

Dependências (cargo-deny)

deny.toml (alvos aarch64-apple-darwin e x86_64-apple-darwin):

  • Advisories: qualquer advisory RustSec (vulnerabilidade, unsound, unmaintained) falha; versões yanked recusadas.
  • Licenças: só permissivas (MIT, Apache-2.0, Apache-2.0 WITH LLVM-exception, BSD-2/3-Clause, ISC, Zlib, 0BSD, Unlicense, CC0-1.0, BSL-1.0, Unicode-3.0). Única exceção: as fontes embutidas do egui (epaint_default_fonts: OFL-1.1 e Ubuntu Font License, que são dados).
  • Fontes: só o registo do crates.io; registos e repositórios Git desconhecidos recusados.
  • Bans: wildcards recusados; versões duplicadas dão aviso.
cargo install --locked cargo-deny     # uma vez
make audit                            # cargo deny check

Nota: a configuração existe e está ligada ao make audit / make check-all, mas o cargo deny check ainda não foi corrido no estado atual do projeto. Até lá, a conformidade das dependências com esta política não está verificada.

Clone this wiki locally