Forense Computacional

From Prof. Vinicius Vieira
Jump to navigation Jump to search

A perícia forense analisa meios de armazenamento digital. Ela trabalha com memória (forense in vivo) e disco (forense pos mortem).


Forense em Disco (pos mortem) - Dicas gerais

Abaixo iremos abordar a arquitetura de um disco e como a estrutura de um sistema de arquivos é implementada fisicamente neste escopo, para então entendermos como funciona a cópia e extração de dados em um disco.

Arquitetura de Disco

A gravação do disco é feita em cilindros (vistos de cima pra baixo), onde todos os discos são gravados por cima e por baixo do disco.

Não existe formatação física fora da fábrica de discos. Ela é feita gerando círculos concêntricos na superfície do HD (microscópicos) a quantidade de trilhas é chamada tecnicamente de “densidade”. Estas trilhas possuem espaços mínimos de distância uma das outras por que a gravação é feita de forma eletromagnética, onde em cada trilha é gerado um campo eletromagnético.

Nos antigos disquetes a cabeça encosta na superfície do disco. Nos discos atuais (SCSI por exemplo) essa formatação não é feita, a não ser nas fábricas.

Os setores são radiais que “fatiam” as trilhas em partes. Os setores não existem fisicamente, somente as trilhas.

O setor (lógico) é a base do disco e possui 512 bytes. Em cima deles que as informações são gravadas (padrão IBM PC 1981).

Mesmo que um software possua menos de 512 bytes, ao gravar em disco, esse software ocupará no mínimo 512, pois essa é a unidade básica de armazenamento.


O comando fdisk -l mostra essas informações:

               fdisk -l
               Disk /dev/sda: 931,5 GiB, 1000204886016 bytes, 1953525168 sectors
               Units: sectors of 1 * 512 = 512 bytes
               Sector size (logical/physical): 512 bytes / 4096 bytes
               I/O size (minimum/optimal): 4096 bytes / 4096 bytes


O tamanho de um disco está diretamente ligado a quantidade de setores (multiplique a quantidade de setores por 512 que dará o tamanho do disco em bytes).

Num disco atual (Sector size (logical/physical): 512 bytes / 4096 bytes) cada vez que é feita uma escrita ou leitura, sempre é feito de 4096 em 4096 bytes. O processo de transferência é sempre feito em cima de 4096 bytes, mesmo que o que está sendo lido/escrito tenha tamanho menor. Isso é feito buscando aumento de velocidade pois ocorrem menos pausas entre transferência e verificação dos dados.

Um bloco seria então um agrupamento de setores. Quando nos deparamos com um erro de “bad block” na verdade seria um problema de setor e não de um bloco, pois como o setor lógico é a menor unidade, se um pedaço desse setor der problema, todo ele é inutilizado.

  • Resumo: na hora de ler/gravar usamos o setor físico (4096) - transferência. Na hora de fornecer espaço de armazenamento, usamos o setor lógico (512) - processamento.

O “dd” é um programa que faz cópia setor a setor, não bit a bit, pois pelo exposto acima isso seria impossível.

Um pendrive é uma simulação eletrônica de um HD, logo ele também possui setores físicos e lógicos.

Utilizando o dmesg -T vemos como se dá o reconhecimento de um pendrive, por exemplo. Na perícia é importante, dentre outros aspectos, pegar o numero de série no dispositivo com o dmesg -T para que seja preenchida a cadeia de custódia.

A BIOS é um sistema operacional e ela controla um computador durante o boot do sistema (todos dispositivos de I/O, memória, processamento e etc). Ela lança um agente no início do HD o MBR para carregar o Sistema Operacional principal. Ele endereça até 232 bytes (2TB de disco) e é um tipo de partição MS-DOS.

Em 1991 a Intel iniciou o desenvolvimento do EFI (que depois de se tornar um consórcio de empresas, foi chamado de UEFI), que substitui a BIOS. No caso da MBR, ela é substituída pela GPT. O GPT indexa discos de até 9.4ZB (1021 bytes).

Logo, se quero colocar discos maiores de 2TB na máquina terei que usar UEFI e não MBR.

O comando gdisk -l [disco] é o analisador de GPT via linha de comando.

gdisk -l /dev/sda

                        GPT fdisk (gdisk) version 1.0.3

                        Partition table scan:
                          MBR: MBR only
                          BSD: not present
                          APM: not present
                          GPT: not present


                        ***************************************************************
                        Found invalid GPT and valid MBR; converting MBR to GPT format
                        in memory. 
                        ***************************************************************

                        Disk /dev/sda: 1953525168 sectors, 931.5 GiB
                        Model: ST1000LM014-1EJ1
                        Sector size (logical/physical): 512/4096 bytes

A MBR ocupa 1 setor e o GPT ocupa 68 setores (34 de informação e 34 de backup no fim do disco).

A UEFI é um firmware que inclusive pode ser substituído. Ela é escalável e usa toda potencialização do seu hardware.

Por default os SO não começam nos primeiros setores após a MBR ou GPT, e sim no setor 2048. Pois lá atrás já se pensava que a MBR, GPT ou outros, poderiam utilizar mais espaço na inicialização.

Por default o dd copia unidades de 512, apesar de receber 4096 do disco. Ele pega os 4096 da memória e só usa 512, fazendo isso até terminar estes 4096 e partir pros próximos setores.

Se quiser copiar de 4096 em 4096 eu uso assim:

dd if=/dev/sda of=/dev/sdb bs=4096

Esse comando é útil se ambos os discos possuírem setores físicos de 4096. A dica é usar o fdisk -l e ver a linha I/O size (minimo/optimal) para conferir se ambos são de 4096 para que a cópia se dê de forma mais rápida entre os discos.


Estrutura de um File System (FS)

Formatar é estabelecer um sistema de arquivos; colocar uma camada eletromagnética no HD que se chama sistema de arquivos (File System), e é nela que escrevemos nossos dados.

O sistema de arquivos (FS) possui duas partes:

→ área de controle: onde controlamos os dados
→ área de dados: onde despejamos nossos dados

Quando formatamos estabelecemos blocos (estão presentes nas duas áreas do FS), que tem seu tamanho default em 4096 bytes (podem ser alterados na hora da formatação mas tem que ser múltiplo de 512). Um bloco tem 8 setores lógicos (512 cada um), no mínimo (8 * 512). Quando colocamos informações em um disco, estamos colocando informações nos blocos. Não conseguimos colocar diretamente no disco, colocamos no FS e ele coloca no HD.

Um arquivo é gravado no bloco. Se ele não ocupar um bloco inteiro, o espaço sobrando se perde. O próximo arquivo é colocado em outro bloco livre e assim por diante. Por exemplo: um arquivo que ocupa 12kb de disco na realidade não tem 12kb de tamanho, tem 10kb. 2kb se perdem e não podem ser usados por outros arquivos.

A fragmentação pode ser de arquivo e de espaço.

→ de arquivo: quando gravo um único arquivo em blocos não contínuos no disco (FS de Windows). Ela gera problema de desgaste e perda de velocidade do disco.
→ de espaço: quando não tenho o espaço contínuo ocupado/livre em disco. Ela não representa problemas para o disco

Os FS do Linux, FreeBSD, Unix e etc fazem o possível para não fragmentar o arquivo durante a gravação.

Na área de controle teremos pelo menos 1 bloco fazendo o controle de um determinado arquivo na área de dados, que é chamado de “inode” ou index node.

O primeiro bloco da área de controle é chamado de superbloco. Nele constam os dados básicos do FS (tamanho, tipo e etc).

O segundo bloco é designado como o diretório raiz (C:, / e etc)

O diretório é um arquivo que contém o nome de outros arquivos ou diretórios. Ele é chamado de “arquivo especial”. A função dele é dar um nome para o inode (os nomes só servem para nós humanos).

O inode é o elemento que controla determinado arquivo e sabe tudo sobre esse arquivo (tipo, tamanho, permissões, setores ocupados), exceto o nome. Quem sabe o nome é o diretório ou arquivo especial.

Os inodes são numerados, assim como os setores. Quando me refiro a um determinado arquivo, me refiro ao número do inode dele.

ls -i mostra o número do inode de cada arquivo do diretório corrente.

O hard link é uma entrada em diretório que “linka” um nome a um número de inode. No linux o hard link é feito com o comando ln. Ele não copia ou duplica o arquivo, ele faz outra entrada em diretório para o mesmo inode. Ele seria um outro nome para o mesmo inode. Ex.:

                    lua.txt  ->  5
                    profile  ->  8
                    teste    ->  8

Num ls -l a segunda coluna mostra a quantidade de hard links de cada arquivo/diretório possui.

Ao criar um novo diretório, ele irá sempre se referenciar a quem está acima dele e abaixo (por isso tenho o . e o .. dentro de todos os diretórios).

Para eliminar um arquivo/diretório por completo, tenho que eliminar todos os seus hard links e inodes.

O softlink (criado com ln -s) é um atalho, ele só aponta para outro arquivo, porém terá um inode diferente. O tamanho de um arquivo de link simbólico é exatamente o tamanho do caminho completo para o arquivo a qual ele aponta. Se eu deletar o softlink o original se mantém, mas se deletar o original o softlink se quebra e continua ocupando um espaço na área de controle.

Eu só posso fazer hard link dentro do mesmo FS (mesma partição, por exemplo) pois cada número de inode só existe dentro dele mesmo.

Resumo:

→ hard link: atalho para um inode, no diretório
→ soft link: atalho para um nome, na área de controle


Em disco, quando algo importante acaba existe uma assinatura. Num editor HEX você consegue ver a assinatura 55 AA, geralmente no final de um MBR, final de uma área de controle e etc.

Ao copiar um arquivo, ele faz a copia completa em background até todos os dados serem copiados. Para acelerar esse processo uso o comando sync.

No caso de montagem ou desmontagem de disco, a sincronização está implícita. Ele só devolve o prompt após terminar a sincronização.

Ao apagar um dado de um disco, um hard link é removido. O inode e os dados continuam no disco para serem sobrescritos.

Assim como todos os arquivos tem um pattern (magic number) os FS também tem.

OBS.: Não alocado: arquivo que existe porém não está descrito em nenhum diretório

Quando eu formato eu estabeleço uma nova área de controle. Porém no caso de formatar com troca de FS, existe a probabilidade de que haja sobrescrita de arquivo (que é justamente o que apaga o dado).

Journaling ou Jormalados = FS que permitem mais integridades aos dados por trabalharem com log de alterações no disco. Este tipo de FS escreve sem parar no disco.

Os FS com jornal, além da área de controle e área de dados, possui uma área reservada contínua para evitar fragmentação de arquivos. Se ele tem que salvar um arquivo e não tem espaço contínuo para isso, ele usa a área reservada para salvar e reserva os espaços aleatórios vazios como área reservada. Dai que sai o aviso: este disco está ficando cheio. Ele ainda reserva 5% (por default) do seu espaço para recuperação em caso de disco cheio.

O ext2 é mais rápido do que o ext3 e 4 pois ele não “perde” tempo escrevendo o journal.

Discos sólidos (SSD, Pendrive e etc) = vida útil em cima da quantidade de escritas nele (em torno de 4000). Dica: não se coloca FS jornalado em discos sólidos pois reduz a vida útil do disco assustadoramente.


Criar um sistema de arquivos em Linux

O comando mkfs.vfat -F 32 /dev/disco cria um FS FAT32 em um disco

O comando mkfs.ext3 /dev/disco cria um FS ext3 em um disco.


The Sleuth Kit (TSK) - suíte para perícia forense em disco

apt install sleuthkit 

fls -r /dev/disco      # ls de file system. O * diz que determinado arquivo não está alocado. -r é recursivo

fls -rd                      # mostra todos os arq deletados em uma imagem 

fls -rFd /dev/disco     # arquivos não deletados

fls -rDd  /dev/disco          # diretórios não deletados

fls -ruF                    # mostra todos os arq não deletados e que podem ser acessados

fls -rm / /dev/disco             # mactimes em EPOC. Essa barra antes do /dev tem que existir

fls -rm / /dev/disco | mactime -z brt           # Mostra a linha do tempo

fls -rm / /dev/disco | mactime -z brt  2015-01-01..         # delimitador com inicio e sem fim, até a data corrente

fls -rm / /dev/disco | mactime -z brt  2015-01-01..2018-02-20           # delimitador com inicio e fim

fls -ro 2048 imagem.img         # ler imagem de disco usando o “o” de offset e o 2048 como sendo o superbloco do FS

fls -r -m / pen.dd > mac.txt        # gera os mactimes de todos os arquivos dentro da imagem no arquivo mac.txt


mmls /dev/disco         # mostra a construção do disco com suas áreas alocadas e não

OBS: Existem duas maneiras de fazer forense:

  • linha do tempo -> indicado para invasões, infecção por vírus
  • descubra o que puder -> achar artefatos e indícios de crime (pedofilia, por exemplo)
istat /dev/disco [nr do inode]        # vejo o interior de um inode

icat /dev/disco [nr do inode]        # cat de inode. Ele entra no inode e verifica os setores que tem dados, exibindo o conteúdo em binários.

icat /dev/disco [nr do inode] > arquivo   # eu jogo o conteúdo do binário dentro do “arquivo”

blkls /dev/disco    # vai trazer todas as áreas não alocadas
                
blkls /dev/disco > arquivo     # salvo estes binários como arquivos
                
blkls -s /dev/disco    # traz o que está em slack space

fsstat /dev/disco      # mostra as informações do FS (metadados)

fsstat -o 2048 imagem.img           # exibe informações da imagem do disco, lendo ele a partir do seu superbloco


Recuperar arq deletado de imagem com dd

fls -d imagem.dd

istat imagem.dd [nr do inode]

icat -r imagem.dd [nr inode] > saida.arq


Deleção de arquivos

Deletar e remover é apagar hard link. Só existe um jeito de remover, que é sobrescrever a informação. Se é sobrescrito uma vez, via software, é impossível recuperar. Via hardware dá pra fazer por leitura espectral, porém só o fabricante faz isso (mesmo assim só pega até 3 sobrescreções). Ou seja, se sobrescrever 4 vezes no mesmo disco, é impossível recuperar o dado.

O Slack space é um conceito de um espaço “livre” com restos de arquivos que foram escritos ali antes de serem sobrescritos.

Esse comando abaixo extrai um arquivo de dentro de uma imagem de disco ou outro arquivo. O bs default é 512 bytes, nesse caso coloquei como 1 byte. A posição do skip posso pegar com o hexedit

dd if=arquivo_entrada of=arquivo_saida bs=1 skip=posicao_do_arquivo_a_Ser_capturado count=tamanho_estimado_do_arquivo


Apagar o disco com deleção completa:

dd if=/dev/zero of=dev/sda           # preenche o disco com zeros em todas os setores.

ou

dcfldd if=/dev/zero of=dev/sda     # mais indicado por mostra o andamento e é indicado para forense. No windows é conhecido como zerofill ou wipe. Não é indicado pois ainda deixa os inodes e os slack spaces que podem ser recuperados.

dcfldd if=/dev/zero of=arquivo     # apaga as áreas desalocadas

fallocate -l 10M teste          # cria um arquivo de 10mb 


Data Carver

Operação que procura por patterns (magic numbers) conhecidos e tenta "remontá-los".

Programas: foremost, scalpel, magicrescue, photorec (testdisk), scrounge-ntfs


scrounge-ntfs

Recupera arquivos em NTFS onde se perdeu a área de controle. Ele atua como o foremost, scalpel, magicrescue e etc. Ele procura por patterns É o mais indicado carver para sistemas NTFS


Mactimes

M - Modify - data e hora da ultima alteração de dados do arquivo ou diretório (dados, não metadados!!!)
A - Access - data e hora do último acesso ao conteúdo do arquivo ou diretório
C - Change - data e hora de alteração dos metadados do arquivo ou diretório
B - Birth - (nem todos os FS tem) data e hora da criação do arquivo ou diretório. Quando ele nasce gera um change (metadado) tb
T - Times
ls -l    # a data apresentada é o Modify
ls -lu  # mostra o Access
stat  [arquivo]     # apresenta os metadados de um arquivo

OBS: o kernel Windows só apresenta a última alteração dos mactimes, já o ext4 apresenta as 3 últimas gerações de mactimes


Unix EPOC - 00h 1 jan 1970 -> quantidade de segundos decorridos de lá até agora (esta data é o marco zero do Unix)

date ‘+%s’ -> mostra o EPOC
date --date @epoc  -> transforma um epoc em data

A data de última modificação apresentada no /etc/shadow é EPOC


Modificando o mactime
touch       # altera o modify do arquivo para data de agora
touch -d data       # altera para uma data especificada
touch -t  datahora          # altera para um timestamp especificado

Integridade de arquivos

Hash -> é uma análise bit a bit do conteúdo de um arquivo (dados, não metadados)

Em forense sempre vou produzir dois hashs diferentes para garantir a integridade, credibilidade do laudo

O hash tem duas finalidades: provar que aquilo é integro e não foi adulterado e em caso de suspeita de adulteração de prova, aplica-se o hash para ver se a prova ainda está íntegra.


Obtendo a imagem de discos e partições

dcfldd if=/dev/disco of=imagemdodisco.img           # Melhor que o dd pois mostra o progresso da operação de cópia

dcfldd if=/dev/disco of=imagemdodisco.img  hash=md5         # copia fazendo o hash

# divide a imagem em discos de 10gb, gerando hash e criando log destes hashs

dcfldd if=/dev/sourcedrive hash=md5,sha256 hashwindow=10G md5log=md5.txt sha256log=sha256.txt hashconv=after bs=512 conv=noerror,sync split=10G splitformat=aa of=driveimage.dd

# unir imagens de disco

cat img1 img2 img3 img4 > img_final

# montar imagens

# Se ela estiver particionada, podemos fazer o procedimento abaixo:

            fdisk -l imagem.img     # verifica onde inicia o FS (geralmente no 2048)

            mount -o ro,offset=1048576 imagem.img /diretorio       # montar imagem em modo somente leitura no diretório /mnt. O 1048576 é o 2048 multiplicado por 512

            ou

            mount -o ro,offset=$[2048*512] imagem.img /diretorio            # usando a expansão do Shell para chegar no início do FS (superbloco)


# Perdi a tabela de partições q quero recuperar isso (ou não sei onde começa o FS ou onde é seu superbloco):


ls -l      # pegar o tamanho da imagem. Divido por 512 pra saber q qtd de setores. Suponhamos abaixo que sejam 62800 setores

foremost -Tq /dev/disco      # ele “caga” para o FS e busca por aquivos que que conhece. O T mostra a data/hora e o q é o quick, que não pega os arquivos embutidos (ex.: imagens em PDF, imagens em PowerPoint e etc)

for i in $(seq 1 62800); do echo $i; fsstat -o $i imagem.img && break; done

Esse comando varre a imagem a procura de um superbloco, caso ache ele para e encontra o inicio do FS. Para saber onde inicia e termina o FS pego o total range do comando acima e somo com o seu superbloco (32678 + 20148, por exemplo).

Feito isso posso usar o fdisk para recriar as tabelas de partição. Ele não destrói dados porque ele escreve a tabela na MBR

Ou melhor ainda:

gpart imagem.img            # ele já faz tudo isso acima 

O testdisk também faz isso de forma automatizada

losetup -o $[2048*512] -f imagem.img        # já monta a imagem a partir do seu superbloco. O “-o” é de offset

losetup

mount -o ro /dev/loopX /diretorio     # O X é o numero do loop que o losetup criou


### No mount NUNCA se esqueça de usar o read only “-o ro” ###


Máquina Virtual

Num caso de uma imagem de VM, posso usar o loop for explicado anteriormente para encontrar o inicio do FS e montar com o mount a partir dali a VM em um diretório


Comando find
find -name ‘*recuper*’          # busco um arquivo que no nome tenha qualquer coisa + recuper + qualquer coisa

find -name ‘*recuper*’ -mtime -360          # modificado a menos de 360 dias

find -mmin -10       # modify alterado nos últimos 10 minutos

find -amin - 10     # access acessados

find -cmin -10      # change modificados

find -inum [nr inode] #busca um inode por nr

find -inum 82623 -exec rm {} \;      # remove o arquivo que era apontado para o inode 82623

find caminho -type f -perm 755          # pega os arquivos do diretporio caminho com permissão 755

find caminho -type -perm 755 -exec chmod 644 {} \;      #  pega os arquivos do diretporio caminho com permissão 755 e altera as permissões para 644

find -size +700M        # mostra todos os arquivos com mais de 700mb

find -size -700M        # mostra todos os arquivos com menos de 700mb


Permissão de arquivos
|   | Arquivos  | Diretórios |
| R | ler - cat | ler - ls   |
| W | gravar    | alterar    |
| X | exec      | acesso - cd|


Atributos Especiais
lsattr
chattr

Forense em memória (in vivo) - Dicas gerais

Procedimentos iniciais:

A primeira coisa a fazer com uma maquina apreendida é fazer o dump de memória, independente da mesma estar ligada ou não, porém seu estado é que irá definir o tipo de análise que será realizada. Se a máquina estiver ligada é possível realizar tanto a analise visual quanto a binária, e caso esteja desligada somente é possível a análise visual, dado que ao carregar uma mídia removível de um SO para forense, as variáveis de ambiente serão as suas e não as da máquina periciada.

Quatro possibilidades de estouro de memória:

→ menos memória do que a capacidade do que se precisa para operação
→ geração contínua de dados (editores de texto modernos trabalham em blocos para abrir documentos grandes e evitar isso)
→ memory leak - nãot ter a capacidade de liberar a memória que você usou (vilões firefox, apache e etc)
→ CPU ineficiente (se ela for muito lenta causa acumulo de dados na memória e estoura)


O hexedit é um dos poucos que trabalha em blocos, dai é indicado a usar em forense para evitar estouro de memória

Quando executamos um free -m vemos que aproximadamente 200mb de RAM é “perdido”. Esse pedaço é usado no boot do sistema para carregar o kernel em RAM. Em sistemas Linux o kernel é montado em RAM

Montando uma partição em RAM (Ideal para executar processos com mais velocidade, pois executa em RAM):

mount -t tmpfs -o size=512m tmpfs /diretorio


Existem dois tipos de análise de memória: - visual - binária

Análise Visual

Como tudo passa pela memória (modelo de Von Neumann) podemos recuperar dados importantes da memória, como senhas e etc.

Por conta da nanotecnologia e pelos modelos de fontes que possuímos, desktops ainda permanecem com energia residual na máquina, o que faz não perder os dados salvos na memória. No caso de tablets, smartphones e etc, ainda tem a bateria para alimentar. Ou seja, desligou o dispositivo e mesmo assim ainda ficam dados salvos em memória.

programas para análise de memória: lime-forensics, dumpit, volatility

lime-forensics

Instalação:

apt install lime-forensics

É um módulo de kernel, logo necessita carregar:

modprobe lime path=/lugar/do/dump.dump format=lime

ou

insmod /usr/lib/modules/4.19.0-kali1-amd64/extra/lime.ko path=arquivo.dump format=lime

Ao executar o comando acima, ele já roda um dump de memoria da própria maquina

Em caso de upgrade de kernel, use:

dpkg-reconfigure lime-forensics-dkms

Toda vez que for refazer o dump de memoria tenho que remover o modulo do lime no kernel e adicionar novamente.

Remover: modeprob -r lime

strings

Verificação inicial com strings (achar conteúdo em ASCII)

strings mem.dump > mem.dump.str

Agora dou um cat e vejo o que está salvo na memória de forma legível

cat mem.dump.str | grep “termo pesquisado”

mcview mem.dump     # memoria não "estringada". Pressione F7 e efetue a busca (Sensível a capitalização)

Podemos usar também o foremost (data carver) pra análise de memória:

foremost -T mem.dump

Dentro do diretório de output rode:

gwenview .      # visualiza as imagens (pode usar o visualizador de imagens nativas do seu SO)

file .      # vai mostrar o que é cada arquivo

testdisk (photorec)

apt install testdisk

photorec /d diretorio/ mem.dump


Apagar a memória RAM

apt install secure-delete

sdmem       # sobrescreve a memória RAM por completo
sfill       # sobrescreve o disco com zeros
srm     # escreve por cima de determinado arquivo e do inode
sswap   # sobrescreve a swap por completo

Análise Binária de memória

Volatility

Pra Linux ele não pega os dados perfeitamente, mas no Windows ele pega TUDO!!!

volatility --info  # vê os profiles disponíveis

lista os profiles que ele trabalha. Para Windows usamos os do programa, para Linux e Mac temos que fazer os nossos profiles.

/usr/share/doc/volatility-tools/README.Debian           # documentação de como faz um profile pra linux

Ele vai analisar a imagem para descobrir qual o profile que deveremos usar neste caso. A primeira é a mais recomendada. Exemplo:

volatility -f imagem.dump imageinfo

volatility -f imagem.dump --profile [profile dado pelo cmd anterior] [plugin escolhido]

    plugins: para senhas -> hashdump  /  comandos -> cmdscan  /  sessões de usuarios -> sessions
    para mais plugins: volatility -h

Análise Forense de Tráfego de Rede

A nível de hardware, para realizar a captura de um determinado segmento de rede (sniffing) pode-se utilizar algumas técnicas como Port Mirroring (ou SPAN) em um switch, Network TAP (dispositivo capaz de capturar tráfego) ou até um Hub. No caso de redes sem fio, bastaria colocar sua interface wireless em modo "monitor".

A nível de software, esse tráfego capturado pode ser armazenado através do wireshark ou tcpdump.

Ferramentas de Análise

WireShark

apt install wireshark

TCPDump

Analisando o tráfego da interface eth1 (-i), sem resolver nomes (-n), relativos ao host 192.168.0.1 (origem ou destino)(host) e (and) que estejam passando pela porta 80 (port 80)

tcpdump -i eth0 -n host 192.168.0.1 and port 80

Analisando o tráfego da interface eth1 (-i), sem resolver nomes (-n), com destino (dst) ao host 192.168.0.1 (host) e (and) que não (not) estejam passando pela porta 80 (port 80)

tcpdump -i eth0 -n dst host 192.168.0.1 and not port 80

Analisando o tráfego da interface eth1 (-i), sem resolver nomes (-n), relativos ao host 192.168.0.1 (origem ou destino)(host) e (and) que sejam do protocolo icmp (icmp)

tcpdump -i eth0 -n net 192.168 and icmp


TCP Flow

Ferramenta que separa um arquivo pcap em flows (sequências) de conexões TCP

tcpflow -r arquivo.pcap -o diretorio_destino/

Para juntar novamente os arquivos que foram separados em seus flows em um único arquivo, porém que mantenha os flows, faça:

cat diretorio_destino/* > /diretorio_destino/imagem.dump


Foremost

Ferramenta de carving de dados para extração de arquivos em imagens binárias (discos, dumps e etc):

foremost -i /diretorio_destino/imagem.dump -o diretorio_saida_foremost/


Xplico

Ferramenta gráfica que realiza a AFTR gerando gráficos

https://xplico.org


Network Miner

Ferramenta gráfica que realiza a AFTR gerando gráficos (mais completa)

Passo 1: Instalação do Mono

Ubuntu (e distros baseadas em debian)

sudo apt-get install libmono-system-windows-forms4.0-cil
sudo apt-get install libmono-system-web4.0-cil
sudo apt-get install libmono-system-net4.0-cil
sudo apt-get install libmono-system-runtime-serialization4.0-cil
sudo apt-get install libmono-system-xml-linq4.0-cil

Passo 2: Instalação do NetworkMiner

wget www.netresec.com/?download=NetworkMiner -O /tmp/nm.zip
sudo unzip /tmp/nm.zip -d /opt/
cd /opt/NetworkMiner*
sudo chmod +x NetworkMiner.exe
sudo chmod -R go+w AssembledFiles/
sudo chmod -R go+w Captures/

Passo 3: Executando o NetworkMiner

mono /opt/NetworkMiner_2-0/NetworkMiner.exe


Instalação no Windows

https://www.netresec.com/?download=NetworkMiner (NNF)