gorilla

gorilla é a ferramenta definitiva de wordlists, reunindo muitas utilidades incríveis, como:

• construção de wordlists baseadas em padrões (como crunch)
• construção de wordlists baseadas em formatos comuns de senhas/nomes de usuário (como cupp)
• extração de palavras de uma página web para construir uma wordlist (como cewl)
• extensão de wordlists existentes usando mutações (como o ataque baseado em regras do hashcat)

instalando com cargo

Com o Cargo do Rust instalado, execute cargo install --git https://github.com/d4rckh/gorilla --branch main

Agora você deve conseguir executar gorilla --help

compilando com cargo

cargo build --release
# the binary will be located in target/release folder

gerando senhas

O argumento --from-pattern/-p é usado para dizer ao gorilla para gerar senhas com base em um padrão. Por exemplo, o seguinte comando imprimirá todas as palavras contendo 5 letras minúsculas.

gorilla --from-pattern "{a-z}{a-z}{a-z}{a-z}{a-z}"

Outros exemplos de padrões são administrator{0-9} (administrator0 -> administrator9); hello_world{a-z}{0-9} (hello_worlda0 -> hello_worldz9).

Se você quiser salvar a saída em um arquivo, pode usar o argumento --output-file/-o.

O Gorilla agora também suporta conjuntos de caracteres. Eles são definidos em src/char_sets.rs. Aqui estão alguns exemplos de padrões que os utilizam: {l} => a b c d ... z; {u} => A B C D ... Z; {d} => 1 2 3 4 ... 9; {s} => (espaço) ! " # $ ... ~. Você pode combinar vários deles, então {luds} resultaria em um conjunto de caracteres contendo todos os outros conjuntos descritos (#45).

Se você usar um intervalo e cada extremidade tiver 1 caractere, estará fazendo um intervalo de caracteres. Por exemplo:

• {a-z} resultará na adição de cada caractere do alfabeto, um de cada vez: a, b, c, d, e, f, g,...., x, y e z;
• {a-c} resultará na adição apenas de a, b e c, um de cada vez;
• {0-9} resultará na adição apenas de 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, apenas um de cada vez. Se você usar um intervalo e uma das extremidades tiver mais de 1 caractere, cada extremidade será interpretada como um número de 32 bits sem sinal e resultará em um intervalo numérico. Por exemplo:
• {2020-2026} resultará na adição de 2020, 2021, 2022, 2023, 2024, 2025 e 2026, um de cada vez.
• {1-100} resultará na adição de números de 1 a 100 (inclusive), um de cada vez.

Experimental: Se o interior dos seus colchetes contiver uma vírgula, a string será dividida por ela e cada parte será adicionada, uma de cada vez. Por exemplo, {Jan,Feb,Mar} resultará na adição de Jan, Feb e Mar, um de cada vez.

Opcionalmente, você pode iniciar várias threads de padrão usando o parâmetro --pattern-threads. Recomendo defini-lo como a quantidade máxima de threads disponíveis no seu computador.

modificando wordlists existentes usando mutações/regras

Usando os argumentos de linha de comando, você pode fazer qualquer mutação suportada, mas está limitado a apenas 1 conjunto de mutações. Um conjunto de mutações é um conjunto de mutações aplicadas a uma palavra. Pela CLI, as mutações são fornecidas pelo argumento --mutation/-m.

gorilla --from-pattern "administrator" --mutation "prepend:_"

Normalmente, nesse caso, você vai querer usar o argumento --from-file/-i em vez de --from-pattern para especificar uma wordlist em vez de uma única palavra, mas, para manter as coisas simples, usarei isso.

O comando acima recebe 1 palavra e gera 1 palavra: _administrator. Você pode adicionar várias mutações usando o mesmo parâmetro.

gorilla --from-pattern "administrator" \
  -m "prepend:_" \
  -m "append:{0-9}"

Isso novamente recebe uma única palavra, mas gerará 10 diferentes. Adicionar a sintaxe {0-9} a prepend e append resultará na geração de várias palavras. O comando acima gera as seguintes palavras.

_administrator0
_administrator1
_administrator2
[.. snip ..]
_administrator8
_administrator9

Se fornecêssemos uma wordlist pelo arquivo -i, obteríamos de volta a quantidade de palavras que tínhamos naquela wordlist vezes 10.

Até agora aplicamos apenas 1 único conjunto de mutações. Normalmente, você vai querer combinar vários deles. Isso é feito por meio dos arquivos yaml. Você especifica um usando o argumento --mutations-file/-f. Um exemplo está localizado no arquivo sets/simple.yml neste repositório e se parece com isto:

name: simple

mutation_sets:
  - [ nothing ] # => word
  - [ reverse ] # => drow
  - [ remove_last_letter ] # => wor
  - [ remove_first_letter ] # => ord
  - [ uppercase_all ] # => WORD
  - [ "append:{0-9}" ] # => word1, word2, word3
  - [ "2 append:{0-9}" ] # => word11, word22, word33
  - [ "replace:o:0", "replace:a:4", "replace:e:3" ] # => w0rd, h3ll0

Cada arquivo de mutações precisa ter um valor name e um valor mutation_sets, como mostrado no exemplo. Os conjuntos de mutações acima gerarão, a partir de uma única palavra, outras 27 palavras.

administrator
administrator
rotartsinimda
administrato
dministrator
ADMINISTRATOR
administrator0
[.. snip ..]
administrator9
administrator00
[.. snip ..]
administrator99
4dministr4t0r

Se você quiser verificar se o arquivo de mutações tem erros antes de usá-lo, pode usar a seguinte sintaxe para analisá-lo e imprimir o resumo.

gorilla --mutations-file muts.yml 

extraindo palavras de páginas web

(Por enquanto) você só pode extrair palavras de uma página específica. Tags de estilo e script são removidas automaticamente.

Você pode especificar uma página usando o argumento --from-website/-w. Por exemplo

gorilla --from-website https://example.org/

O comando acima imprimirá todas as palavras daquele site. Você pode adicionar outros argumentos mostrados anteriormente, como --mutations-file/-f, --mutation/-m e, é claro, --output-file/-o para salvá-los (em vez de imprimir).

mutações condicionais

Você pode aplicar um conjunto de mutações a palavras específicas que atendem a determinadas condições/condição. Isso só faz sentido em arquivos yaml.

O seguinte arquivo de mutações removerá palavras que não contenham a string admin. Ao contrário das mutações anteriores, isso pode remover palavras.

name: filtering_words

mutation_sets:
  - [ "if_contains:admin" ]

Outro exemplo é o seguinte, que adicionará um sublinhado apenas a palavras com mais de 5 caracteres.

name: conditional_mutation

mutation_sets:
  - [ "if_length:>5", "append:_" ],
  - [ "! if_length:>5" ]

Observe que tivemos que adicionar outro conjunto de mutações que começa com a versão negada da primeira mutação if, pois, caso contrário, as palavras com menos de 6 caracteres seriam removidas.

outras mutações

gorilla suporta muitas outras mutações e, como a ferramenta está em desenvolvimento inicial, seria muito trabalhoso manter uma lista delas aqui. Se você estiver curioso sobre as outras mutações, pode conferir o enum Action no arquivo src/mutation.rs.

usando formatos comuns de senha/nome de usuário para construir wordlists