gorilla

gorilla è lo strumento definitivo per wordlist, con tantissime utility fantastiche come:

• creare wordlist basate su pattern (come crunch)
• creare wordlist basate su formati comuni di password/username (come cupp)
• fare scraping di una pagina web e creare una wordlist dalle sue parole (come cewl)
• estendere wordlist esistenti usando mutazioni (come l'attacco basato su regole di hashcat)

installazione con cargo

Con Cargo di Rust installato, esegui cargo install --git https://github.com/d4rckh/gorilla --branch main

Ora dovresti essere in grado di eseguire gorilla --help

compilazione con cargo

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

calcolo delle password

L'argomento --from-pattern/-p viene usato per dire a gorilla di calcolare password basate su un pattern. Ad esempio, il seguente comando stamperà ogni singola parola composta da 5 lettere minuscole.

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

Altri esempi di pattern sono administrator{0-9} (administrator0 -> administrator9); hello_world{a-z}{0-9} (hello_worlda0 -> hello_worldz9).

Se vuoi salvare l'output in un file, puoi usare l'argomento --output-file/-o.

Gorilla ora supporta anche i set di caratteri. Sono definiti in src/char_sets.rs. Ecco alcuni esempi di pattern che li usano: {l} => a b c d ... z; {u} => A B C D ... Z; {d} => 1 2 3 4 ... 9; {s} => (spazio) ! " # $ ... ~. Puoi combinarne più di uno, quindi {luds} risulterà in un set di caratteri contenente tutti gli altri set descritti (#45).

Se usi un intervallo e ciascuna estremità ha 1 carattere, stai facendo un intervallo di caratteri. Per esempio:

• {a-z} risulterà nell'aggiungere ogni carattere dell'alfabeto, uno alla volta: a, b, c, d, e, f, g,...., x, y e z;
• {a-c} risulterà nell'aggiungere solo a, b e c, uno alla volta;
• {0-9} risulterà nell'aggiungere solo 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, solo uno alla volta. Se usi un intervallo e una delle estremità ha più di 1 carattere, ciascuna estremità verrà interpretata come un numero a 32 bit senza segno e il risultato sarà invece un intervallo numerico. Per esempio:
• {2020-2026} risulterà nell'aggiungere 2020, 2021, 2022, 2023, 2024, 2025 e 2026, uno alla volta.
• {1-100} risulterà nell'aggiungere i numeri da 1 a 100 (inclusi), uno alla volta.

Sperimentale: se l'interno delle parentesi contiene una virgola, la stringa verrà divisa da essa e ogni parte verrà aggiunta, una alla volta, ad esempio {Jan,Feb,Mar} risulterà nell'aggiungere Jan, Feb e Mar, uno alla volta.

Opzionalmente, puoi generare più thread per i pattern usando il parametro --pattern-threads. Ti consiglio di impostarlo al numero massimo di thread disponibili sul tuo computer.

modificare wordlist esistenti usando mutazioni/regole

Usando gli argomenti della riga di comando puoi eseguire qualsiasi mutazione supportata, ma sei limitato a un solo set di mutazioni. Un set di mutazioni è un insieme di mutazioni applicate a una parola. Tramite la CLI, le mutazioni vengono fornite tramite l'argomento --mutation/-m.

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

Di solito in questo caso vorrai usare l'argomento --from-file/-i invece di --from-pattern per specificare una wordlist invece di una singola parola, ma per semplicità userò quello.

Il comando precedente prende 1 parola e restituisce 1 parola: _administrator. Puoi aggiungere più mutazioni usando lo stesso parametro.

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

Anche questo prende una singola parola, ma restituirà 10 parole diverse. Aggiungere la sintassi {0-9} a prepend e append genererà più parole. Il comando precedente genera le seguenti parole.

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

Se invece fornissimo una wordlist tramite il file -i, otterremmo il numero di parole presenti in quella wordlist moltiplicato per 10.

Finora abbiamo applicato un solo set di mutazioni. Di solito vorrai combinarne più di uno. Questo viene fatto tramite i file yaml. Puoi specificarne uno usando l'argomento --mutations-file/-f. Un esempio si trova nel file sets/simple.yml di questo repository e appare così:

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

Ogni file di mutazioni deve avere un valore name e un valore mutation_sets come mostrato nell'esempio. I set di mutazioni precedenti genereranno, a partire da una singola parola, altre 27 parole.

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

Se desideri controllare il tuo file di mutazioni per errori prima di usarlo, puoi usare la seguente sintassi per analizzarlo e stamparne il riepilogo.

gorilla --mutations-file muts.yml 

scraping di pagine web per parole

(Per ora) puoi fare scraping solo di una pagina specifica per estrarre parole. I tag style e script vengono rimossi automaticamente.

Puoi specificare una pagina usando l'argomento --from-website/-w. Per esempio

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

Il comando precedente stamperà ogni parola di quel sito web. Puoi aggiungere altri argomenti mostrati in precedenza come --mutations-file/-f, --mutation/-m e ovviamente --output-file/-o per salvarle (invece di stamparle).

mutazioni condizionali

Puoi applicare un set di mutazioni a parole specifiche che soddisfano determinate condizioni. Questo ha senso solo nei file yaml.

Il seguente file di mutazioni rimuoverà le parole che non contengono la stringa admin. A differenza delle mutazioni precedenti, questo può rimuovere parole.

name: filtering_words

mutation_sets:
  - [ "if_contains:admin" ]

Un altro esempio è il seguente, che aggiungerà un underscore solo alle parole più lunghe di 5 caratteri.

name: conditional_mutation

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

Nota che abbiamo dovuto aggiungere un altro set di mutazioni che inizia con la versione negata della prima mutazione if, altrimenti le parole più corte di 6 caratteri verrebbero rimosse.

altre mutazioni

gorilla supporta molte altre mutazioni e, poiché lo strumento è in fase di sviluppo iniziale, sarebbe molto faticoso mantenere qui un elenco di tutte. Se sei curioso di conoscere le altre mutazioni, puoi dare un'occhiata all'enum Action nel file src/mutation.rs.

usare formati comuni di password/username per creare wordlist