Auditor

Cadeia de Integridade

O processo de auditoria utilizado auditor baseia-se no conceito de uma cadeia de integridade, fornecida por arquivos de auditoria que armazenam informações de integridade.

Os termos envolvidos neste processo são:
Audit_FullList: É o arquivo de auditoria que contém informações de integridade de cada arquivo de dados original processado.

Stamp: São as informações de integridade atuais do arquivo Audit_FullList. Stamp é sempre recalculado e exibido ao executar ações relevantes.

Audit_Stamp: É o arquivo de auditoria que armazena Stampo Audit_FullList, quando foi criado.

A cadeia de integridade é gerada na seguinte ordem (no comportamento padrão):

Os arquivos de dados contidos em input_path são processados e geram informações de integridade (hash, tamanho, caminho relativo do arquivo, etc.) que são armazenadas no arquivo Audit_FullList.

Audit_FullList também é processado, gerando Stamp, que é impresso no terminal e armazenado em Audit_Stamp.

A verificação da cadeia de integridade é feita na ordem inversa do processo acima, reprocessando os arquivos de dados e verificando se a integridade corresponde ao que consta nos arquivos de auditoria. Stamp também é recalculado, impresso no terminal e comparado com as informações em Audit_Stamp, para verificar se há correspondência.

Para prosseguir com a geração dos arquivos de auditoria e garantir que a futura verificação da cadeia de integridade seja realizada de forma correta e segura, siga os passos abaixo:

Organize seus arquivos de dados em uma pasta específica (denominada input_path). Com o auditor instalado, abra um terminal de comandos e execute auditor hash input_path. Por padrão, este comando criará os arquivos de auditoria Audit_FullList e Audit_Stamp na raiz da pasta `input_path`. (Isso pode ser alterado, se necessário.)
Salve todos os dados, incluindo os arquivos de auditoria, e imprima Stamp ou assine digitalmente o arquivo Audit_Stamp (que contém Stamp).
Essa etapa do registro de Stamp é fundamental, pois caso não seja executada, qualquer pessoa poderá alterar os dados e simplesmente gerar novos arquivos de auditoria, comprometendo a verificação de integridade. Se você não tiver acesso a uma impressora ou a um certificado digital no momento, poderá usar uma autoridade de carimbo de tempo (timestamp) gratuita para assinar o arquivo online, como o freetsa.org (usando a opção de Assinatura Online) .
Opcionalmente, para armazenar todos os dados, você pode criar um arquivo do tipo contêiner (como um arquivo ZIP, RAR, TAR ou outro contêiner) que inclua tanto seus arquivos de dados quanto os arquivos de auditoria. Faça cópias de segurança desse arquivo contêiner em mídias diferentes.
Posteriormente, quando alguém realizar a verificação com auditor check, a cadeia de integridade descrita acima é executada. Ao final do processo, o Stamp será recalculado e impresso no terminal e DEVEM corresponder exatamente ao valor impresso ou assinado digitalmente na etapa anterior. Caso contrário, a verificação de integridade é inválida .
Você também pode verificar a integridade de arquivos de dados originais individuais usando os dados em Audit_FullList. Veja exemplos na seção de uso de auditor check.

Uso

Consulte um breve manual aqui.

Com ele auditorinstalado em seu sistema, você pode usá-lo da seguinte forma:

auditor subcommands:

hash

lock

check

info

clone

chkcopy

hashÉ o primeiro passo da auditoria forense. Gera arquivos de auditoria que permitem verificar a integridade dos arquivos.

Uso básico do subcomando hash

auditor hash input_path

Isto irá:

Arquivos hasheados input_pathcom algoritmo padrão ( sha256)
Gerar arquivos de auditoria (Caminho padrão: dentro da raiz de input_path):
- Audit_FullList: contém os dados de integridade (hash, tamanho, nome) dos arquivos em input_path. Nome padrão: _auditor_hashes.txt
- Audit_Stamp: contém apenas os dados de integridade de Audit_FullList. Nome padrão: _auditor_stamp.txt. Este é o arquivo que precisa ser impresso ou assinado digitalmente para garantir a verificação de toda a cadeia de integridade.
Exibir dados de integridade deAudit_FullList

Depois disso hash, você pode executar checko comando para verificar a integridade. Para garantir a verificação de integridade adequada no futuro, leia a seção Cadeia de Integridade e siga as recomendações ali contidas.

Outros exemplos:

Basta gerar hashes, mas não crie nenhum arquivo (-l)
```
auditor hash input_path -l
```
Sobrescrever arquivos de auditoria (-o), usando um disco rápido (-z) com algoritmo padrão (útil com discos SSD, para maior velocidade):
```
auditor hash input_path -o -z 
```
O mesmo que acima, mas com o modo estrito ativado, para garantir que TODOS os arquivos em input_path sejam criptografados:
```
auditor hash input_path -o -z --strict
```
Sobrescrever arquivos de auditoria (-o), sem usar o método thash (-d):
```
auditor hash input_path -o -d 
```
Sobrescrever arquivos de auditoria (-o), incluir apenas arquivos txt (-i "**/*.txt") somente na pasta raiz (-u 1) (as opções -i e -e usam padrão glob, veja as Notas para detalhes).
```
auditor hash input_path -o -i "**/*.txt" -u 1
```
Sobrescrever arquivos de auditoria (-o), incluir todos os arquivos, exceto arquivos txt (-e "**/*.txt")
```
auditor hash input_path -o -e "**/*.txt" 
```
Sobrescrever arquivos de auditoria (-o), incluir apenas arquivos com nome "file1.doc" (-i "**/*/file1.doc") e "file2.xls" (-i "**/*/file2.xls")
```
auditor hash input_path -o -i "**/*/file1.doc"  -i "**/*/file2.xls" 
```
Sobrescrever arquivos de auditoria (-o), incluir TODOS os arquivos, exceto os arquivos dentro das pastas $RECYCLE.BIN e "System Volume Information". Obs.: O caractere $ em $RECYCLE.BIN pertence ao nome e precisa ser escapado com um caractere \ antes dele para ser analisado corretamente!
```
auditor hash input_path -o -e "**/\$RECYCLE.BIN/**" -e "**/System Volume Information/**" 
```
Sobrescrever arquivos de auditoria (-o), incluir todos os arquivos txt (-i "**/*/*.txt"), exceto aqueles dentro do diretório chamado folder1 (-e "**/*/folder1/*")
```
auditor hash input_path -z -o -a blake3 -i "**/*/*.txt" -e "**/*/folder1/*" 
```
Sobrescrever arquivos de auditoria (-o), usar disco rápido (-z) e algoritmo 'blake3' (muito rápido):
```
auditor hash input_path -o -z -a blake3
```
Sobrescrever arquivos de auditoria (-o), usar tamanho de bloco de 10 MB e função hash 'whirlpool'
```
auditor hash input_path -o -b 10MB -a whirlpool
```

)

lockÉ útil quando os arquivos de auditoria existentes precisam ser preservados. Pode ser usado após o comando hash e evitar a geração acidental de novos arquivos de auditoria input_path.

Uso básico do subcomando lock

auditor lock input_path

Isto irá:

Crie um arquivo _auditor_lock.txtcom input_path um registro de data e hora de criação.
O subcomando Hash não será executado em um input_pathsistema bloqueado.

Para desbloquear input_path, você precisa excluir o arquivo manualmente._auditor_lock.txt

)

checkÉ a segunda etapa da auditoria forense. Ela verifica a integridade dos dados usando informações nos arquivos de auditoria e pode ser usada após a geração do hash.

Uso básico do subcomando Check

auditor check input_path

Isto irá:

Obter arquivos de auditoria (Caminho padrão: dentro da raiz de input_path):
Utilize os dados de integridade listados em Audit_Stampe verifique em relação a Audit_FullList.
Use os dados de integridade listados em Audit_FullListe verifique-os em relação aos arquivos originais em input_path.
Mostre os dados de integridade recalculados de Audit_FullList.

Outros exemplos:

Verifique no modo de disco rápido (-z), usando arquivos de auditoria padrão.
```
auditor check input_path -z 
```
Semelhante ao anterior, mas com o modo estrito ativado, para garantir que TODOS os arquivos em input_path sejam verificados.
```
auditor check input_path -z --strict
```
Verificar apenas arquivos txt (-i "**/*.txt"), usando arquivos de auditoria padrão (as opções -i e -e usam padrões glob; consulte as Notas para obter detalhes).
```
auditor check input_path -i "**/*.txt"
```
Verificar em modo silencioso (-q) e parar no primeiro erro (-x), usando arquivos de auditoria padrão.
```
auditor check input_path -q -x
```
Verifique F:\data_path usando arquivos de auditoria com nomes específicos. (-f para <Audit_FullList> e -s para <Audit_Stamp>)
```
auditor check F:\data_path -f C:\other_path\personal_fullList.txt -s C:\other_path\personal_stamp.txt -q -x 
```
Verificar a integridade de apenas um arquivo em <caminho_de_entrada> em relação a um arquivo de auditoria.
```
auditor check F:\data_path\file1.txt -f C:\other_path\some_audit.txt -q -x 
```

Nota: A verificação do auditor é compatível com o formato fsum.

)

cloneÉ utilizado para copiar dados de dentro input_pathpara fora dest_pathe, ao mesmo tempo, verificar a integridade dos dados copiados.

Uso básico do subcomando clone

auditor clone input_path dest_path

Isto irá:

Obter arquivos de input_path, gerar dados de integridade (hash, tamanho, nome);
Copiar arquivos para dest_path;
Verificar a integridade dos arquivos em dest_pathrelação aos dados de integridade gerados em input_path.
Se os arquivos de auditoria NÃO existirem, você pode criá-los em `/etc/audit` input_pathe/ou em `/etc dest_path/audit` com a opção `-g`. Se os arquivos de auditoria já existirem, você não poderá criá-los.

Em caso de erro, o programa tentará novamente (o padrão é 3 vezes, mas isso pode ser alterado).

Outros exemplos:

No modo de disco rápido (-z).
```
auditor clone input_path dest_path -z 
```
O mesmo que acima, mas com o modo estrito ativado, para garantir que TODOS os arquivos em input_path sejam clonados:
```
auditor clone input_path dest_path --strict
```
Em modo silencioso (-q) e para no primeiro erro (-x).
```
auditor clone input_path dest_path -q -x
```
Clonagem com geração de arquivos de auditoria nos diretórios input_path e dest_path (Consulte as notas!).
```
auditor clone input_path dest_path -g both 
```
Clonagem com geração de arquivos de auditoria apenas no caminho de destino.
```
auditor clone input_path dest_path -g dest 
```
Clonagem com geração de arquivos de auditoria apenas no caminho de entrada.
```
auditor clone input_path dest_path -g input 
```
Você pode usar -i e/ou -e para incluir ou excluir arquivos do processo (Não pode ser usado com --strict).
```
auditor clone input_path dest_path -q -x -i "**/*.txt" -e "**/dir1/**/*
```

Observação: Para gerar arquivos de auditoria, input_pathnão é possível ter arquivos de auditoria (Audit_FullList e Audit_Stamp)! Isso evita confusão com arquivos de auditoria já existentes.

Veja todas as opções com o comando `auditor clone --help`.

)

chkcopyé usado para verificar os dados internos input_pathem relação aos arquivos de auditoria e copiá-los para dest_path, e ao mesmo tempo verificar a integridade dos dados copiados em dest_path.

Uso básico do subcomando chkcopy

auditor chkcopy input_path dest_path

Isto irá:

Obter arquivos input_pathe verificar a integridade dos dados de arquivos de auditoria;
Copiar arquivos para dest_path;
Verificar a integridade dos arquivos dest_pathcomparando-os com os dados de integridade dos arquivos de auditoria.
Observação: o comando chkcopy não gera arquivos de auditoria!

Em caso de erro, o programa tentará novamente (o padrão é 3 vezes, mas isso pode ser alterado).

Outros exemplos:

No modo de disco rápido (-z) para discos rápidos como ssd, m.2, etc.
```
auditor chkcopy input_path dest_path -z 
```
Semelhante ao anterior, mas com o modo estrito ativado, para garantir que TODOS os arquivos em input_path sejam verificados e copiados:
```
auditor chkcopy input_path dest_path --strict
```
Em modo silencioso (-q) e para no primeiro erro (-x).
```
auditor chkcopy input_path dest_path -q -x
```
Você pode usar -i e/ou -e para incluir ou excluir arquivos do processo (Não pode ser usado com --strict).
```
auditor clone input_path dest_path -q -x -i "**/*.txt" -e "**/dir1/**/*
```

Observação: input_path é necessário ter arquivos de auditoria (Audit_FullList / Audit_Stamp)!

)

infoNão realiza verificação de integridade de hash. Apenas testa os arquivos de auditoria e seu conteúdo, input_pathexibindo informações úteis. Pode ser usado após a execução do hash.

Exemplo de Informação Forense

auditor info input_path

Isto irá:

Obter arquivos de auditoria (Caminho padrão: dentro da raiz de input_path):
Verifique se os arquivos de auditoria Audit_Stampexistem Audit_FullList.
Verifique se os arquivos listados em Audit_Stampe Audit_FullListexistem e se o tamanho listado é o mesmo que em input_path.
Verifique se todos os arquivos em input_pathestão listados em Audit_FullList.
Recalcular os dados de integridade Audit_FullList e verificar em relação ao arquivo de auditoria.Audit_Stamp
Apresente um relatório com o tamanho dos arquivos e de todos os input_path.

)

Notas

1: No Windows PowerShell, caminhos com nomes que contêm espaços devem ser colocados entre aspas simples, sem a barra invertida final \. Se desejar, use duas barras invertidas no final \\. Isso ocorre porque a barra invertida simples escapa as aspas finais, e o terminal não consegue interpretar o caminho corretamente.

Isto funciona: "C:\My Data Path" ou"C:\My Data Path\\"

Isso falha: "C:\My Data Path\"

2: As opções -i e -e (incluir e excluir padrões) usam a sintaxe glob. Veja um breve manual aqui!

Download

Download e dados de integridade dos binários (dentro do arquivo zip):

Aviso: Esta versão auditoré fornecida como software em fase de desenvolvimento, SEM garantia ou suporte de qualquer tipo , e é gratuita apenas para uso não comercial . Use por sua conta e risco.

Licença: Esta versão auditoré licenciada apenas para uso não comercial . Consulte os termos completos da licença para obter detalhes.

Extras

Formato dos arquivos de auditoria

O formato dos arquivos de auditoria é simples. Cada linha contém:

hash_value ?ALGORITHM[<THASH-BlockSize>]|file_size[:hex]*relative_filepath

onde [ ] são opcionais:

hash_value: valor do hash.

ALGORITHM[<THASH-BlockSize>]O ALGORITMO usado para gerar o hash é armazenado em letras maiúsculas para manter a compatibilidade com outras ferramentas. O parâmetro `<THASH-BlockSize>` é opcional e indica que o método `thash` e o tamanho do bloco (`BlockSize`) foram usados. O `BlockSize` deve estar em KB, MB, GB ou TB. Exemplo: 10MB.

file_sizeTamanho do arquivo original após a geração do hash. Útil para verificação e para melhorar a velocidade quando o tamanho não corresponde. Por que gerar o hash de um arquivo grande se já se sabe que seu tamanho não corresponde ao original?

[:hex]: Flag opcional para indicar que o caminho do arquivo está em formato hexadecimal. Isso é necessário porque caracteres como '\n', '\r' ou '\0' são permitidos em alguns sistemas operacionais, e o formato hexadecimal evita problemas com a formatação dos resultados.

relative_filepath: O caminho relativo do arquivo que gerou o hash.

Exemplo 1: usando o método thashCom o algoritmo sha256 e tamanho de bloco de 50 MB:

281d5d93464f1165ea7c403ca99d63ff4bf9a360864f8df4bd0e8e6c03774e98 ?SHA256<THASH-50MB>|500000*file_hashed.bin

Exemplo 2: usando o método normal, apenas com o algoritmo blake3, com o caminho do arquivo em formato hexadecimal.

7357b67824d086dc53f5e1ded565f500456bea1812783f1fbcddc08fddc3944c ?BLAKE3|2233:hex*1aCb344356e4e2b2b6

Outros formatos poderão ser implementados no futuro.

Indicadores de desempenho

Usando o Hyperfine , testes entre auditorOs comandos fsum, rhash e hashdeep64 foram executados e os resultados são mostrados abaixo.

Machine configs:

S.O.: Windows 11 Home 64bits
Processor: AMD Ryzen 7 (7800X3D 4.20 GHz)
RAM: 64 GB of RAM (Corsair Vengeance DDR5 64GB - 5200MHz)
Disk: SSD M.2 2TB (Corsair MP600 Pro NVMe)

Data Source 1:

Benchmarks using Data Source 1:

Data Source 2

Benchmarks using Data Source 2: