# Offline

Geralmente encontramos senhas e/ou outras credenciais em SO, interceptações e em bancos de dados. Provavelmente a senha será um hash e, portanto, precisamos primeiro identificar qual é o hash e depois tentar decifrá-lo. Os hash podem ser identificados por informações como:

* O comprimento do hash
* Conjunto de caracteres
* Quaisquer caracteres especiais

Podemos também utilizar ferramentas como `hashid` e `hash-identifier` (vide na sessão de criptografia) para identificar alguns hashes.

###

### Quebrando WPA-2 (Handshake)

```bash
aircrack-ng -a 2 -w <wordlist.txt> <arquivos_salvo.cap>
```

###

### John The Ripper

#### Docker

Caso não tenha o John dispinível, utilize o comando abaixo para iniciar via Docker:

```bash
sudo docker run -it -v $(pwd):/home/john/examples nbaars/john-the-ripper
```

#### Unshadow

Antes de começar, vá no terminal e jogue as senhas para um único arquivo:

```bash
unshadow /etc/passwd /etc/shadow >> senhas.db
```

#### Modo gráfico

Para abrir o JTR em modo gráfico, basta executar o comando `johnny`.

#### Quebrando Senhas

```bash
# Modo simples do John
john senhas.db

# Pesquisando em dois arquivos ao mesmo tepo
# OBS.: Caso os hashes dos arquivos sejam diferentes, o John pode não conseguir processar
john --single <senha1.txt> <senha2.txt>

# Para que o John ignore contas que não tenham acesso ao shell (em caso de hash linux)
john --show --shells=-/bin/false <senhas.txt>

# Caso queria utilizar uma Wordlist, utilize o seguinte comando
# OBS.: Se você utilizar novamente o comando acima para quebrar uma senha que já foi quebrada, irá devolver mensagem que não foi possível quebrar a senha
john --wordlist=wordlist.txt <senhas.db>

# O John armazena as senhas que já foram quebradas. Para visualizar quais senhas já foram quebradas, utilize o seguinte comando
john --show <senhas.db>

# Caso queira utilizar um arquivo específico com uma senha em MD5
john hash.txt --format=md5crypt
john --wordlist=wordlist.txt --format=Raw-MD5 <hash.txt>

# Quebrando SHA1
john --wordlist=wordlist.txt --format=Raw-SHA1 <hash.txt>

# Listando os tipos de "format"
john --list=formats

# Testar chaves
john --test
```

#### Quebrando Senhas em Arquivos DOC

```bash
python office2john.py <file.docx> > <output_hash.txt>
john --wordlist=<wordlists.txt> <hash.txt>
```

#### Sessions

JTP salva seu progress em sessões. Mesmo dando `CTRL` + `C`, ele continua em background

```bash
john --format=raw-md5 <arquivo-hashes.txt> --session=<nome-sessao>
```

Restaurando a sessão salva com `--session-<nome-sessao>`

```bash
john --restore=<nome-sessao>
```

**OBS.:** Utilize o comando restore no mesmo diretório onde utilizou o comando `--session-<nome-sessao>`, pois irá ser criados dois arquivos com extensões `.log` e `.rec`.

#### Rules

```bash
# Utiliza variantes de cada palavras da wordlist
john <file_hash> --wordlist=<file> --rules 

# Pega uma wordlist atual e adiciona uma regra a ela, como por exemplo adicionar números no início, meio ou fim
john --rules=Single --wordlist=<wordlist.txt> --stdout

# Para criar uma própria regra (rule), edite o arquivo /etc/john/john.conf e adicione essa seguinte linha
[List.Rules:MinhaRegra]
$[@]$[2]$[0]$[0-1]$[1-9]

john --rules=MinhaRegra --wordlist=<wordlist.txt> --stdout
```

**OBS.:** Com essa regra, será adicionado `@20xx` no final de cada palavra da wordlist. Caso queira adicionar no início da palavra, use o `^` ao invés do `$`

#### Incremental

```bash
# Utiliza incrementadores (com letras e números) até achar a senha
john --incremental <arquivo-hashes.txt>

# Igual o comando acima, porém este define que a senha é do tipo MD5
john --incremental format=raw-md5 <arquivo-hashes.txt>

# Mostra a saída do incrental com no máximo 4 caracteres, útil para criar arquivos para realizar quebra de senhas
john --incremental --stdout=4

# O mesmo que a saída anterior, porém este só terá dígitos.
john --incremental=Digits --stdout=4

# O mesmo que a saída anterior, porém este será alfanumérico.
john --incremental=alnum --stdout=4

# O mesmo que a saída anterior, porém este será alfanumérico mas somente com letras maiúsculas.
john --incremental=LanMan --stdout=4
```

**OBS.:** Pode se utilizar mais opções para o `--increment`, como `alnum`. Ver em `/etc/john/john.conf` as demais opções



### HashCat

Procurando tipos de hash para o hashcat quebrar. Utilize um `grep` para ajudar na localização

```bash
hashcat --example-hashes
```

#### Quebrando Senhas UNIX

{% hint style="warning" %}
**DICA**: Algumas vezes o Hashcat retorna erro "Already an instance running on pid 5". Para corrigir, execute o comando: **`rm -rf ~/.hashcat/sessions/hashcat.pid`**
{% endhint %}

```bash
hashcat <hash.txt> <wordlist.txt> -m 1800
```

A opção `-m 1800` equivale a senhas SHA-512 (Unix). Utilize a opção `-h` (help) para ver a lista de códigos completa.\
O arquivo `hash.txt` contém o hash salvo. Para quebrar uma senha UNIX, devemos remover alguns valores da hash, como no exemplo abaixo:

```bash
# HASH ORIGINAL DO ARQUIVO /etc/passwd
visit:$6$tRymH4k.$G9XBOrE2hQTsJO3tZ0R0/uo8Y4GQNEQdSzyHL9S5osZufEKxEB00obJ.BiY0qcRCwKkG7IqDGQP9yRb9ahqK4.:17022:0:99999:7:::

# HASH MODIFICADA PARA O HASHCAT CONSEGUIR QUEBRAR
$6$tRymH4k.$G9XBOrE2hQTsJO3tZ0R0/uo8Y4GQNEQdSzyHL9S5osZufEKxEB00obJ.BiY0qcRCwKkG7IqDGQP9yRb9ahqK4
```

#### Brute Force

Tentando diversas senhas sem a utilização de uma wordlist. No exemplo abaixo estamos utilizando 6 caracteres, sendo cada caracter (letras minúsculas/maiúsculas, números e caracteres especiais) representado pelo `?a`. Vide tabela abaixo para saber qual parâmentro utilizar.

```bash
hashcat -m <module_number> -a 3 <hash.txt> ?a?a?a?a?a?a
```

| PARÂMETRO | CHARS                                        |
| --------- | -------------------------------------------- |
| `?l`      | abcdefghijklmnopqrstuvwxyz                   |
| `?u`      | ABCDEFGHIJKLMNOPQRSTUVWXYZ                   |
| `?d`      | 0123456789                                   |
| `?h`      | 0123456789abcdef                             |
| `?H`      | 0123456789ABCDEF                             |
| `?s`      | «space»!"#$%&'()\*+,-./:;<=>?@\[]^\_\`{\|}\~ |
| `?a`      | ?l?u?d?s                                     |
| `?b`      | 0x00 - 0xf                                   |

Caso prefira, também é possível selecionar os determinados de caracteres que irão fazer parte do Brute Force. No exemplo abaixo, selecionamos os caracteres `abcdefgABCDEF1234!@#$`, mas sinta-se a vontade para adicionar ou remover caracteres.

```bash
hashcat -a3 -m <module_number> <hash.txt> -1 $(echo 'abcdefgABCDEF1234!@#$') ?1?1?1?1?1?1 --force
```

#### Adicionando Prefixo e Posfixo nas Palavras

Adiciona o ano no final das palavras do wordlist

```bash
hashcat -a 0 -m 1000 <hash-ntlm.txt> <wordlist.txt> -r rules\add-year.rule
```

Primeira letra maiúscula seguida de 7 letras minúsculas e número no final

```bash
hashcat -a 3 -m 1000 <hash-ntlm.txt> ?u?l?l?l?l?l?l?l?d
```

Semelhante ao comando anterior, porém nesse, o final será caracteres esepcias e números, ao invés de somente números

```bash
hashcat -a 3 -m 1000 ntlm.txt -1 ?d?s ?u?l?l?l?l?l?l?l?1
```

Podemos também criar arquivos com regras específicas, como no exemplo abaixo, onde teremos regras para diferentes tamanhos:

```bash
?d?s,?u?l?l?l?l?1
?d?s,?u?l?l?l?l?l?1
?d?s,?u?l?l?l?l?l?l?1
?d?s,?u?l?l?l?l?l?l?l?1
?d?s,?u?l?l?l?l?l?l?l?l?1
```

Também podemos trabalhar com prefixos, sendo útil em muitos casos, já que as pessoas costumam utilizar nas suas senhas, nomes de empresas, parceiros, filhos, animais de estimação, etc. No exemplo abaixo estou utilizando o nome `Mysther` como prefixo, então ajuste para o seu cenário.

```bash
Mysher?d
Mysher?d?d
Mysher?d?d?d
Mysher?d?d?d?d
?dMysher
?d?dMysher
?d?d?dMysher
?d?d?d?dMysher
```

Para utilizarmos nossa regra personalizada, basta executar:

```bash
hashcat -a 3 -m 1000 <hash-ntlm.txt> <regra-personalizada.hcmask>
```

#### Combinator

Junta as palavras de duas wordlist. No exemplo do comando abaixo, irá pegar uma palavra de `wordlist-1.txt`, adicionar um `-`, depois uma palavra de `wordlist-2.txt` e para finalizar, uma `!`.

```bash
hashcat -a 1 -m 1000 <hash-ntlm.txt> <wordlist-1.txt> <wordlist-2.txt> -j $- -k $!
```

#### Híbrido

Utilizando a opção `-a 6`, iremos anexar valores a uma wordlist. Para exemplo abaixo, considere que sua wordlist contém a palavra `Senha`, então o hashcat irá tentar de `Senha0000` até `Senha9999`

```bash
hashcat -a 6 -m 1000 <hash-ntlm.txt> <wordlist.txt> ?d?d?d?d
```

Caso queira que os números fiquem antes da palavra, ficando de `0000Senha` à `9999Senha`, utilize a opção `-a 7`, ficando da seguinte maneira:

```bash
hashcat -a 7 -m 1000 <hash-ntlm.txt> ?d?d?d?d <wordlist.txt>
```

#### kwprocessor

Existe um utilitário externo que fica separado do Hashcat principal, chamado `kwprocessor` (deve ser baixado manualmente). Este, é um utilitário para gerar senhas `key-walk`, que são senhas baseadas nas sequências das teclas do computador, por exemplo `qwerty` e `1q2w3e4r`. Com o kwprocessor, podemos definir as direções e o tipo de teclado para gerar uma wordlist.

```bash1
kwp64 basechars\custom.base keymaps\uk.keymap routes\2-to-10-max-3-direction-changes.route -o <output-keywalk.txt>
```

#### NTLM (Windows)

```
hashcat -m 1000 <hash.txt> <wordlist.txt>
```

#### Tipos de Ataques

| ATAQUE         | DESCRIÇÃO                                                                                                                                                                                                                                               |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Combination`  | Usa mais do que um dicionário para fazer a quebra. Se você possui 1 dicionário com 50 palavras e no outro 100, então ele irá mesclar esses 2 dicionários, criando então uma lista com 50 \* 100 = 5000 palavras                                         |
| `Table-Lookup` | Este modo de ataque também é baseado em dicionários, porém você pode adicionar caracteres a serem substituídos em seus dicionários, por exemplo: `a=A` ou `a=@` ou `e=3`                                                                                |
| `Toggle-case`  | Este método utiliza todas as letras maiúsculas e minúsculas de um dicionário. Por exemplo, vamos usar a palavra test. Neste caso ele irá tentar as seguintes combinações: `Test`, `tEst`, `teSt` e `tesT`                                               |
| `Permutation`  | <p>Esta técnica não funciona muito bem, mas caso um dia precise, está aqui para usá-la. Com este modo, você inverte caracteres de posição, por exemplo, usaremos a palavra pass123:</p><p>pass123, pass321, 1pass23, 3pass21, 32pass1, 21pass, etc.</p> |
| `Brute Force`  | Ataque baseado em máscara, você define as regras de ataques e ele executa de acordo com a máscara que você selecionou. Ex: admin123 onde você queira que cada número seja entre 0 e 9                                                                   |
| `Straight`     | Opção básica e simples. Você seta uma wordlist e a hash a ser quebrada                                                                                                                                                                                  |



### Windows

Caso tenha acesso aos arquivos do Windows, pegue os o arquivo de registro `system` e o `SAM`. Esses dois arquivos provavelmente está em um dos seguintes locais:

```bash
# SAM
%SYSTEMROOT%\repair\SAM
windows\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM

# system
SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\RegBack\system
```

Caso consiga os dois arquivos mencionados acima, podemos gerar um hash com o comando:

```bash
pwdump system sam
```



### SSH (RSA)

Esse tipo de ataque pode ser feito quando temos uma chave SSH criptografada como no exemplo abaixo:

```
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: AES-128-CBC,AEB88C140F69BF2074788DE24AE48D46

DbPrO78k...
...
...
...
GHJE8MkhD3
-----END RSA PRIVATE KEY-----
```

{% hint style="info" %}
**DICA**: Antes de executar o comando abaixo, verifique se o comand&#x6F;**`ssh2john`** está disponível, e caso não esteja, verifique se o script pode ser encontrado em **`/usr/share/john/ssh2john.py`**
{% endhint %}

```bash
# Gerando o hash da chave
ssh2john.py <crypt_id_rsa> > <output_hash>

# Realizando brute force
john <output_hash> --fork=4 -w=</path/to/wordlist>
```



### findmyhash

Quebrando senhas utilizando serviços online. Note que precisamos antes do hash para que seja quebrado, por isso, mesmo utilizando serviços online, este é considerado um Brute Force Offline, pois não estamos acessando diretamente o alvo para realizar o cracking

```bash
findmyhash MD5 -h <hash>
```



### PDF

```
pdfcrack -w <wordlist.txt> <file.pdf>
```



### Zip

#### fcrackzip

```bash
fcrackzip -u -v -D -p '<wordlist.txt>' '<file.zip>'
```

#### John the Ripper

```bash
zip2john <encrypted_file.zip> > output_hash
john --wordlist=<wordlist.txt> output_hash
```

#### Hashcat

```bash
hashcat -a 0 -m 13600 <hash.txt> <wordlist.txt>
```



### XLS / XLSX

```bash
python office2john.py <file.xlsx> > <output_hash.txt>
john --rules --wordlist=<wordlist.txt> <output_hash.txt>
```



### SuCrack

Este apesar de ser um brute force offline, é preciso ter acesso ao terminal do Linux, seja ele no seu próprio host ou em um host remoto. Basicamente, vai tentar quebrar a senha de outros usuários, através do comando `su`, porém de uma forma automatizada.

```bash
./sucrack -a -w 20 -s 10 -u <user> <wordlsit.txt>
```

#### Script Personalizado

Obviamente, nem sempre podemos contar com o uso desse script, então podemos criar um script próprio para realizar a mesma tarefa que o SuCrack.

Crie um arquivo chamado `xpl.sh` com o seguinte código (altere `<user>` pelo usuário em questão):

```bash
#!/usr/bin/expect -f
log_user 0
set password [lindex $argv 0]
spawn /bin/su <user> -c whoami
expect "Password:"
send "$password\r"
interact
```

Agora crie um arquivo chamado `xpl.py` com o seguinte código:

```bash
#!/usr/bin/python
import sys, subprocess
with open(sys.argv[2], 'r') as ins:
	for line in ins:
		print "Trying Password: " + str(line)
		if sys.argv[1] in subprocess.check_output(['./xpl.sh', str(line)]):
			print "Password: " + str(line)
			exit(0)
		count += 1
```

Agora bastar dar acesso de execução para ambos os arquivos e chamá-lo

```bash
chmod +x xpl.sh xpl.py
./xpl.py <user> <wordlist.txt>
```



### CISCO

#### Cisco IOS Enable 5

Essas senhas do Cisco são baseadas em MD5 com Salt. No arquivo `config.txt` (ou `config.text`), iremos achar uma linha parecida com essa:

```
username cisco-admin secret 5 $1$.vTq$m3rHbbqITE.sxlHB0K5ca/
```

Pegando como exemplo, vamos utilizar o hash `$1$.vTq$m3rHbbqITE.sxlHB0K5ca/` para quebrar.\
**OBS.:** Note que antes da hash tem o número `5`, que indica que a senha foi misturada usando o algoritmo MD5 mais potente.\
O hash é dividido em 3 partes, que estão separadas por um `$`.

```bash
# Parte 1 = Indica que o hash se trata de um MD5
1

# Parte 2 = Salt utilizado para gerar a senha  
.vTq

# Parte 3 = Hash da senha
m3rHbbqITE.sxlHB0K5ca/
```

Agora para quebrar vamos utilizar o seguinte comando:

```bash
openssl passwd -1 -salt <parte_2> -table -in <wordlist.txt> | grep <pedaço_da_parte_3>
```

**OBS.:** A senha nesse caso é `cisco`, então utilize essa senha na wordlist para fins de teste.

#### Cisco IOS Enable 7

A versão 7 possui um hash fácil de quebrar e, assim como a versão 5, está localizado no arquivo `config.txt` (ou `config.text`). Nele iremos acha uma linha parecida com o trecho abaixo:

```
username rout3r password 7 0242114B0E143F015F5D1E161713
```

No final desse artigo possui um site para quebrar esse hash.

####

### Sites

```bash
# Quebra hashes 
https://hashkiller.io/leaks
https://crackstation.net/

# Identifica o tipo de Hash
https://md5hashing.net/hash_type_checker
https://www.onlinehashcrack.com/hash-identification.php

# Kwprocessor
https://github.com/hashcat/kwprocessor.git

# SuCrack
https://github.com/hemp3l/sucrack

# Quebrar senha Cisco (Enable 5)
http://www.ifm.net.nz/cookbooks/cisco-ios-enable-secret-password-cracker.html

# Quebrar senha Cisco (Enable 7)
http://www.ifm.net.nz/cookbooks/passwordcracker.html
```
