# Forense Digital

### Sistemas Operacionais Forensics

| SISTEMA OPERACIONAL                           | URL                                                      |
| --------------------------------------------- | -------------------------------------------------------- |
| `CAINE`                                       | <https://www.caine-live.net/>                            |
| `DEFT`                                        | <http://na.mirror.garr.it/mirrors/deft/>                 |
| `Helix3 Free`                                 | --                                                       |
| `SANS Investigative Forensics Toolkit (SIFT)` | <https://digital-forensics.sans.org/community/downloads> |
| `Santoku Linux (Perícia Móvel)`               | <https://santoku-linux.com/>                             |

###

### Métodos de Captura

#### Captura Física

É criado uma cópia da unidade de disco bit a bit / setor a setor. Metadados do sistema de arquivos, arquivos excluídos, fragmentos de arquivos excluídos e espaço não alocados são capturados. A imagem resultado é um cópia exata.

#### Captura Lógica

Neste, espaço não alocado, dados do sistema de arquivos e arquivos excluídos e/ou parcialmente apagados, arquivos ocultos e espaço não usado, não são capturados

#### Captura Esparsa

Semelhante a Captura Lógica, porém este captura dados excluídos e seus fragmentos. Normalmente é usado em sistemas RAID

### gdb (com Script Bash)

Crie um aquivo chamado `dump-memory.sh` (pode ser o nome que preferir) e insira o seguinte conteúdo:

```bash
#!/bin/bash
grep rw-p /proc/$1/maps \
| sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \
| while read start stop; do \
        gdb --batch --pid $1 -ex \
                 "dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \
done
```

Dê permissão de execução para o arquivo sh.

```bash
chmod +x dump-memory.sh
```

E para executar, primeiro precisamos pegar o PID do processo em questão.

```bash
ps aux
```

Agora que já sabemos o PID, podemos executar nosso script.

```bash
./dump-memory.sh <pid>
```

Feito isso, note que no mesmo diretório do script, foram criados alguns arquivos com extensão `.dump`. Filtre esse arquivo com palavras-chave com um dos comandos abaixo:

```bash
grep -irn password
strings *.dump | grep -i password
```

### Mozilla Firefox

#### Despejo de Memória

```bash
# Aceita os termos contrato. Obrigatório fazer isso pela primeira vez que for usar
procdump64.exe -accepteula

# Realizando o Dump
procdump64.exe -ma <service_or_pid>
```

#### Lendo Histórico e Favoritos

```sql
sqlite3 /home/<user>/.mozilla/firefox/<profile.default>/places.sqlite

# Histórico
SELECT * FROM moz_places;

# Favoritos
SELECT * FROM moz_bookmarks;
```

#### E-mail utilizados em Formulários

```bash
sqlite3 /home/<user>/.mozilla/firefox/<profile.default>/formhistory.sqlite
SELECT DISTINCT(value) FROM moz_formhistory WHERE instr(`value`, '@') > 0;
```

#### Quantidade de Perfis

Cada  `[Profile<num>]` é um perfil. Note que em cada profile existe um campo chamado `Path` e no mesmo diretório de `profiles.ini`, deve ter um diretório com o mesmo nome do valor de `Path`. Caso não exista esse diretório, significa que o perfil foi excluído.

```bash
cat /home/<user>/.mozilla/firefox/profiles.ini
```

#### Verificando addons que foram adicionados

```bash
cat /home/<user>/.mozilla/firefox/<profile.default>/addons.json | jq
```

#### Capturando senhas com firepwd

Antes de executar o comando abaixo, certifique-se de os arquivos `login.json`, `key3db` ou `key4.db` estão no diretório correto.

```bash
python firepwd.py -d </path/directory/>
```

#### Capturando Detalhes de Senhas Salvas

```bash
cat /home/<user>/.mozilla/firefox/<profile.default>/logins.json | jq
```

#### Brute Force para Descobrir Senhas

```bash
for x in $(cat firefox_decrypt.py) ; do echo $x | python firefox_decrypt.py ; done
```

#### Cookies

```bash
sqlite3 /home/<user>/.mozilla/firefox/<profile.default>/places.sqlite

# Cookies de todos os sites
SELECT * FROM moz_cookies;

# Cookies de um determinado site
SELECT * FROM moz_cookies WHERE baseDomain = "<site.com>";

# Cookies acessados recentemente
SELECT * FROM moz_cookies WHERE (lastAccessed) in (SELECT MAX(lastAccessed) FROM moz_cookies);

# Retornando os cookie que não expiraram
SELECT * FROM moz_cookies WHERE expiry > <timestamp_now>;
```

### Google Chrome

Vendo Histórico de Sites

```bash
sqlite3 /home/<user>/.config/google-chrome/Default/History
SELECT * FROM urls;
```

URL de Arquivos baixados

```bash
sqlite3 /home/<user>/.config/google-chrome/Default/History
SELECT * FROM downloads_url_chains;
SELECT * FROM downloads;
```

Pesquisas realizadas no site do Google.

```bash
sqlite3 /home/<user>/.config/google-chrome/Default/History
SELECT * FROM keyword_search_terms;
```

Cookies

```bash
sqlite3 /home/<user>/.config/google-chrome/Default/Cookies
SELECT host_key FROM cookies WHERE expires_utc > <timestamp_now>;
```

### Lendo BMC

Carregue o arquivo no `BMC Viewer`, selecione o tamanho do `BPP` (tile) e clique em `LOAD`. \
**OBS.:** O tamanho do `tite` é uma questão de tentativa a erro

### Lendo Arquivos Apagados do Pendrive

Primeiro veja onde está o `Filesystem` do pendrive

```bash
df -h
```

Agora vamos ler o seu conteúdo

```bash
strings </dev/filesystem>
```

### USB

```bash
usbrip events violations <auth_file.json> --file <syslogfile>
```

### Imagens de Disco

#### img\_stat

Verificando os tipos de formato imagens que o `img_stat` trabalha.

```bash
img_stat -i list
```

Verificando o tipo de formato de uma determinada imagem de disco.

```bash
img_stat -t <file.img>
```

#### fsstat

Verificando o tipo de sistema de arquivos. Utilize o `img_stat` acima para pegar o tipo de formato de imagem.

```bash
fsstat -i <image_type> -t <file.img>
```

Buscando detalhes sobre o SO.

```bash
fsstat -i <image_type> -f <type_system_file> <file.img>
```

#### fls

Listando diretórios da imagem.

```bash
fls -i <image_type> -f <type_system_file> <file.img>
```

Agora que já sabemos os nomes dos diretórios, podemos listar os arquivos desse diretório utilizando o seu número de indicação. Vamos supor que na saída acima tenha retornado `d/d 17: photos` em uma das linhas, então 17 é o número que irá identificar o diretório `photos`.

```bash
fls -i <image_type> -f <type_system_file> <file.img> 17
```

Assim como os diretórios possuem um número para identificá-los, os arquivos também possui, então ler um arquivo utilizando seu número de identificação com `icat`, logo abaixo.

#### icat

Lendo arquivos

```bash
icat -i <image_type> -f <type_system_file> <file.img> <numero_identificao_arquivo>
```

#### Sites

```bash
# Blogs / Fóruns / Tutoriais
https://lifeinhex.com
https://resources.infosecinstitute.com
https://www.us-cert.gov/ncas/alerts

http://www.darknessgate.com
https://osint.link 
http://www.edrm.net
https://www.secjuice.com
http://cyberforensicator.com
https://www.darkreading.com/
https://www.dfir.training

# Despejo de memória com ProcDump
https://support.microsoft.com/pt-br/help/4294410/how-to-use-procdump-to-troubleshoot-virtual-machine-manager-service-vm  

# Protegendo a unidade de disco contra gravações. Utilize caso não tenha um hardware para isso
www.darknessgate.com/computer-forensic/computer-forensic-prerequisites/windows-os-write-protection-with-usb-devices

# Lista de assinaturas de arquivos
https://filesignatures.net

# firefox_decrypt
https://github.com/unode/firefox_decrypt

# firepwd
https://github.com/lclevy/firepwd

# Lista de extensões e seus formatos
https://fileinfo.com/filetypes/common

# Identifica tipos de arquivos (extensão) e o programa utilizado para executar
https://www.openwith.org

# Trabalha com Binários, Hexas, Decimais, etc
https://hexed.it

# Diversos tipos de assinaturas para determinar o tipo real do arquivo
https://www.garykessler.net/library/file_sigs.html
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mysther.gitbook.io/knowledge-base/forense-digital.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.