Guida a John the Ripper
llora John The Ripper e' un password cracker, ovvero serve per crakkare
delle password in un file passwd trovato su sistemi Unix.
Come usarlo
------------
Per eseguire John, e' normale che hai bisogno di un file delle password,
devi anche specificare il modo del crakkaggio, per esempio,
usando il modo "single crack" , e facendo finta che passwd sia una copia
del vostro file delle passwd, dovrete fare:
john -single passwd
e poi, con una wordlist:
john -wordfile:/usr/dict/words -rules passwd
Le password crakkate saranno stampate a video e salvate in un file chiamato
john.pot (in Linux sara' salvato nella tua home directory).
Questo file sara' usato anche la prossima volta che eseguirai John.
Per mostrare le password crakkate, esegui:
john -show passwd
Durante il crakkaggio, puoi digitare ogni tasto per lo status,
o Ctrl+C per fermare. Se premerai ctrl+C John non salvera' nulla.
Mentre le informazioni sono salvate ogni 10 minuti (guarda src/params.h) in
caso di un crash. Per continuare una sessione interrotta, esegui:
john -restore
Opzioni di Jonh
========================================
Queste sono tutte le opzioni di John:
-single usa modo "single crack"
Abilita il modo "single crack" , usando i rules da [List.Rules:Single].
-wordfile:FILE modo wordlist, legge le parole da FILE,
-stdin o da stdin
Queste opzioni sono usate per abilitare il modo wordlist.
-rules abilita i rules per il modo wordlist
Abilita le rules per il wordlist, che sono lette da [List.Rules:Wordlist].
-incremental[:MODE] modo incrementale [usando la sezione MODE]
Abilita il modo incrementale, usando le specifiche contenute in john.ini
(sezione [Incremental:MODE], o [Incremental:All] da default).
-external:MODE modo esterno o filtro parola
Abilita il modo esterno, usando funzioni esterne definite in john.ini
[List.External:MODE].
-restore[:FILE] riprende una sessione interrotta
Continua una sessione di crakkaggio interrotta, leggendo le informazioni
da un file specifico, (restore da default).
-session:FILE setta il nome della sessione a FILE
Ti lascia specificare uno specifico file di informazioni da usaree per
quella sessione. Questo e' comodo per eseguire diverse instanze di
John in parallelo, o solo per abilitare al ricovero una vecchia sessione,
non sempre continua l'ultima.
-makechars:FILE costruisce un set di caratteri, scrivendo su FILE
Genera un file di caratteri, basati sulla frequenza di caratteri da john.pot,
per usarlo con il modo incrementale. L'intero john.pot sara' usato per
il file di caratteri. Puoi anche usare una routine di filtro esterno con questa opzione.
-show mostra le password crakkate
Mostra password crakkate. Potresti anche specificare il file delle password.
-test per testare un benchmark
Tutti i benchmark sono abilitati per l'opzione del formato ciphertext ,
e testa essi per le operazioni corrette allo stesso tempo.
-users:[-]LOGIN|UID[,..] carica solo questo/i utente/i
Ti permette di filtrare un po' di accounts per il cracking, ecc.
-groups:[-]GID[,..] carica solo questo/i gruppo/i
Dice a John di caricare solo gli utenti di quel specifico gruppo .
-shells:[-]SHELL[,..] carica solo questa/e shell/s
Questa opzione si usa per caricare solo accounts con una valida shell ,
o non per caricare accounts con una brutta shell.
-salts:[-]COUNT setta un limite di modifiche per un file password
Questa opzione qualche volta permette di velocizzare il cracking.
Per esempio tu puoi crakkare solo alcuni campi usando '-salts:2',
e poi crakki il resto usando '-salts:-2'. Alla fine il tempo sara' lo stesso
solo che cosi' puoi ottenere un password piu' facilmente.
-format:NAME specifica il formato del file
Ti da' la possibilita' di specificare il formato del file. Formati validi
sono DES, BSDI, MD5, BF. Puoi usare questa opzione quando crakki o quando
usi l'opzione test. Nota che John non puo' crakkare un file con differenti
formati all'interno.
-savemem:LEVEL abilita il salvataggio, a livello 1..3
Necessiti di questa opzione se non hai abbastanza memoria, o non vuoi che
John disturbi molto gli altri processi. Il Livello 1 dice a John di non sprecare
memoria sui login , se non vuoi vederli durante il crakkaggio. I livelli piu'
alti hanno una perfomance sul risultato. Vi consiglio di usare il livello 1
Modi di crakkaggio di John the Ripper
=====================================
Questa e' una breve descrizione dei modi possibili con il programma.
Modo Wordlist
---------------
Questo e' un modo facile supportato da John. Quello che devi fare
e' specificare una wordlist (file di testo contenente una parola per linea), e
il file delle password. Puoi abilitare i rules (che sono usati per modificare
le parole) se desideri, essi saranno poi applicati ad ogni parola della lista.
John, pero', non ordina le parole per non usare molta memoria,
visto che carichera' l'intera wordlist nella memoria,
mentre ora e' letta dall'hard disk durante il cracking.
Pero', lasciando le parole come sono, ti permettera' di mettere
prima le parole frequenti.
In ogni caso, molte delle wordlist che trovi sulla rete sono gia' ordinate.
Comunque non potrai inserire parole lunghe piu' di 8 (o lunghe oltre a quando
permette il tuo corrente algoritmo della passwd) caratteri, inserendo
la stessa parola se i loro primi 8 caratteri coincidono. John puo' ovviare a
questa situazione quando le parole vanno una dietro l'altra
(questo quando la wordlist e' ordinata). Comunque non dovrai troncare le
parole a 8 caratteri nella tua wordlist, puoi risolvere abilitando i rules.
La via raccomandata, con i rules di default, per ordinare una wordlist e'
questa:
tr A-Z a-z < SOURCE | sort -u > TARGET
Guarda il funzionamento dei rules, spiegato dopo, per avere un'idea piu'
chiara.
Modo crack singolo
---------------------
Questo e' il metodo con il quale puoi iniziare a crakkare facilmente.
Esso crakkera' usando le informazioni di login, nomi, ecc. come password.
E' ovvio che trovera' delle password solo se ci sara' qualche utente stupido
che abbia messo informazioni riguardo al suo nome o cognome.
Nota che questo metodo e' consigliato farlo solo su un file alla volta.
Modo Incrementale
-------------------
Questo e' il piu' potente metodo di crakkaggio, esso puo' provare tutti
le possibili combinazioni di caratteri come password.
Comunque, assumendo questo metodo di crakkaggio, non terminerai mai
visto che il numero delle combinazioni e' molto alto
(potra' terminare solo se setterai un limite di lunghezza delle password,
e potrai interromperlo facilmente.
Per usare questo metodo hai bisogno di una definizione specifica per i
parametri (inclusi il limite della lunghezza delle password e il set di
caratteri). Questi parametri sono specificati in john.ini in una sezione
chiamata [Incremental:MODE], dove MODE e' un nome che vuoi assegnare al
metodo (esso e' il nome che dovrai specificare quando avvierai John).
Tu puoi anche usare un metodo incrementale predefinito ('All', 'Alpha',
o 'Digits'), o crearne uno noi.
Modo Esterno
--------------
Puoi definire un metodo esterno di crakkaggio per usare John. Questo e' fatto
con la sezione di john.ini chiamata [List.External:MODE], dove MODE e' un
nome che assegni al metodo. La sezione dovra' contenere qualche funzione
che John usera' per generare le parole. Le funzioni sono codificate
in una sottosessione del linguaggio C , e sono compilate da John all'inizio
(se abiliti il metodo quando avvii John).
Definire un metodo esterno
----------------------------
Per definire un metodo esterno di crakkaggio devi creare una sezione
nel file di configurazione chiamata [List.External:MODE], dove MODE e'
un qualsiasi identificatore che vuoi assegnare al metodo.
John compilera' e usera' le funzioni scritte in C se tu abiliti questo metodo
quando lo avvii.
Funzioni esterne
------------------
Correntemente John usa le seguenti funzioni:
init() chiamata all'inizio, inizializza le variabili globali
filter() chiamata per ogni parola da essere provata, puo' filtrare
qualche parola
generate() chiamata per generare parole, quando non e' usato nessun altro
metodo
restore() chiamata quando si riprende una sessione interrotta
Tutte queste sono del tipo 'void', senza argomenti, e dovranno usare delle
variabili 'word' (per esempio 'int word[]'), eccetto per init() che e'
chiamata prima di 'word' . La variabile 'word' contiene la corrente parola
da essere provata, in ASCIIZ.
Le funzioni, se definite, dovranno fare cio' con 'word':
* filter() puo' modificare la parola, o 'word[0]' per uscire;
* generate() non dovra' assumere un particolare valore di 'word' quando essa
viene chiamata, ma dovra' settare essa alla prossima parola da essere provata,
o assume 'word[0]' quando il cracking e' completo (cio' fara' finire John);
* restore() dovra' settare le variabili globali per continuare dalla 'word'.
Puoi usare un metodo esterno separatamente, o con qualche altro metodo di
crakkaggio, in quel caso solo init() e filter() saranno usati.
L'uso di un filtro esterno e' compatibile con tutti gli altri metodi
di crakkaggio e con l'opzione '-makechars'.
E' raccomandato che non usi filter(), cioe' non filtrare
molte parole quando usi un metodo esterno con il tuo generate().
Il linguaggio
---------------
Il compilatore supporta alcuni comandi C. John e' un cracker,
non un compilatore, dopo non avrete bisogno di nient'altro.
Questa e' una lista di tutte le parole chiave supportate:
void, int, if, else, while, continue, break, return.
Puoi dichiarare le funzioni standard da essere chiamata da John,
dichiarare variabili globali e locali (inclusi gli array di dimensione
singola), usare tutte le operazioni intere supportate in C, e usare i
commenti C.
Le seguenti operazion si perdono nel compilatore di John:
* supportate solo le funzioni standard, non puoi dichiararne delle tue;
* supportato solo il ciclo 'while';
* supportati solo i tipi di dati 'int' e 'void';
* supportati solo array di dimensione singola;
* le structs/unions non sono supportate;
* i puntatori non sono supportati (il nome array si riferisce al primo
elemento);
* probabilmente qualcos'altro...
Puoi trovare qualche esempio di modo esterno nel file di configurazione di
default insieme a John.
Regole di sintassi del modo Wordlist
--------------------------------------
Ogni regola di wordlist consiste in uno o piu' comandi, tutti inseriti
su una linea e opzionalmente separati dagli spazi. C'e' anche un preprocessore,
che genera delle regole multiple per una singola linea sorgente. Qui sotto
troverai la descrizione dei comandi rules e la sintassi del preprocessore.
Codici di posizione
---------------------
Le posizione dei caratteri sono numerate partendo con 0, e specificate in
rules dai seguenti caratteri:
0...9 for 0...9
A...Z for 10...35
* for max_length
- for (max_length - 1)
+ for (max_length + 1)
Qui max_length e' la massima lunghezza del testo supportato dal corrente
formato.
Gli stessi caratteri sono anche usati per specificare altri parametri numerici.
Le Classi di caratteri
------------------------
?? confronta '?'
?v confronta le maiuscole: "aeiouAEIOU"
?c confronta le consonanti: "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ"
?w confronta spazi bianchi: " \t"
?p confronta la punteggiatura: ".,:;'\"?!`"
?s confronta i simboli: "$%^&*()-_+=|\\<>[]{}#@/~"
?l confronta le lettere minuscole [a-z]
?u confronta le lettere maiuscole [A-Z]
?d confronta i numeri [0-9]
?a confronta le lettere [a-zA-Z]
?x confronta le lettere e i numeri [a-zA-Z0-9]
Il complemento di una classe puo' essere specificato mettendo in maiuscolo
il suo nome. Per esempio, '?D' confronta ogni cosa ma numeri.
Sempici Comandi
-----------------
: non fare niente alla parola immessa
l converte in minuscolo
u converte in maiuscolo
c scrive in maiuscolo
C scrive in minuscolo il primo carattere, in maiuscolo il resto
t toglie il case a tutti i caratteri della parola
r capovolge: "Fred" -> "derF"
d duplica: "Fred" -> "FredFred"
f riflette: "Fred" -> "FredderF"
{ ruota la porola verso sinistra: "jsmith" -> "smithj"
} ruota la parola verso destra: "smithj" -> "jsmith"
$X aggiunge il carattere X alla parola
^X toglie il carattere X alla parola
Comandi di controllo lugnhezza
--------------------------------
<N caccia la parola finche' essa e' piu' piccola della lunghezza del
carattere N
>N caccia la parola finche' essa e' piu' grande della lunghezza del
carattere N
'N tronca la parola alla lunghezza N
Comandi di grammatica inglese
-------------------------------
p mette al plurale: "crack" -> "cracks", etc (solo minuscole)
P "crack" -> "cracked", etc (solo minuscole)
I "crack" -> "cracking", etc (solo minuscole)
Inserisci/Cancella Comandi
----------------------------
[ cancella il primo carattere
] cancella l'ultimo carattere
DN cancella il carattere nella posizione N
xNM estrae una stringa dalla posizione N fino al carattere M
iNX inserisce il carattere X nella posizione N e sposta il resto a destra
oNX sostituisce il carattere nella posizione N con il carattere X
Nota che '[' e ']' sono caratteri di controllo al preprocessore:
tu dovrai uscire da essi con '\' se usi questi comandi.
Comandi di conversione del Charset
------------------------------------
S shift case: "Crack96" -> "cRACK(^"
V minuscolizza le vocali: "Crack96" -> "CRaCK96"
R sostituisce ogni carattere con quello alla destra, sulla tastiera:
"Crack96" -> "Vtsvl07"
L sostituisce ogni carattere con quello alla sinistra, sulla tastiera:
"Crack96" -> "Xeaxj85"
Comandi di accesso alla memoria
---------------------------------
M memorizza la parola
Q restituisce la parola se e' stata cambiata
Comandi delle classi di caratteri
-----------------------------------
sXY sostituisce tutti i caratteri X della parola con Y
s?CY sostituisce tutti i caratteri della classe C con Y
@X purifica tutti i caratteri X dalla parola
@?C purifica tutti i caratteri di classe C dalla parola
!X restituisce la parola se contiene il carattere X
!?C restituisce la parola se contiene un carattere nella classe C
/X restituisce la parola finche' contiene il carattere X
/?C restituisce la parola finche' contiene un carattere nella classe C
=NX restituisce la parola finche' il carattere nella posizione N e' uguale
a X
=N?C restituisce la parola finche' il carattere nella posizione N e' nella
classe C
(X restituisce la parola finche' il suo primo carattere e' X
(?C restituisce la parola finche' il suo primo carattere e' nella classe C
)X restituisce la parola finche' il suo ultimo carattere e' X
)?C restituisce la parola finche' il suo ultimo carattere e' nella
classe C
%NX restituisce la parola finche' contiene il minimo N casi di X
%N?C restituisce la parola finche' contiene il minimo di N caratteri della
classe C
Comando extra del metodo "Single Crack"
-----------------------------------------
Quando definiamo il modo "single crack", comandi extra sono disponibili per
il supporto di due parole, per controllare se altri comandi sono applicati al
primo, secondo, o tutte e due:
1 solo la prima parola
2 solo la seconda parola
+ per concatenarle
Se usi uno di questo comandi in un rule, esso processera solo due parole
(nome completo, dalle informazioni GECOS), e restituisce le singole parole.
Il '+' e' assunto alla fine di ogni rule che usa qualcuno di questi comandi,
finche' lo specifichi manualmente. Per esempio, '1l2u' convertira' la prima
parola in minuscolo, la seconda in maiuscolo, e usa il concatenamento di
entrambe. Per usare il segno '+' dovra' essere applicato dopo altri comandi:
'1l2u+r' capovolgera' il concatenamento, dopo aver applicato gli altri
comandi.
Il Preprocessore dei rule
---------------------------
Il preprocessore e' usato per combinare rules simili in una linea sorgente.
Per esempio, se hai la necessita' di far provare a Jonh parole minuscole con
numeri aggiunti, potrai scrivere un rule per ogni numero, 10 rules in totale.
Ora immagina farlo con due cifre, avrai 99 rule ed un file molto grande!
Con il preprocessore puoi fare cio' facilmente. Basta scrivere una linea
sorgente contenente le parti comuni di questi rules, e la lista dei caratteri
che vorrai mettere in un rules separato, in parentesi . Il preprocessore poi
generera' il rules per te . Per esempio, la linea sorgente sara' 'l$[0-9]'
(minuscolo e aggiungi un numero) e 'l$[0-9]$[0-9]' (minuscolo e aggiungi due
numeri). Queste linee sorgenti si espanderanno rispettivamente a 10 e 100
rules . I comandi del preprocessore sono processati da destra a sinistra,
e i caratteri sono processati da sinistra a destra. Comunque, oltre ai numeri
puoi combinarli anche in caratteri, come '[aeiou]' che usera' le vocali, e
'[aeiou0-9]' che usera' le vocali e i numeri.
Ci sono alcuni comandi di controllo caratteri nei rules ('[' fa partire
una lista di caratteri del preprocessore, '-' segna un range all'interno della
lista, etc). Se necessiti di far partire la lista dei caratteri del
preprocessore ad ogni inizio di una linea, dovrai prefissarli con ':'.
Utilita' addizionali
----------------------
Assieme a John vengono dati anche questi programmi:
unshadow PASSWORD-FILE SHADOW-FILE
Combina il passwd e lo shadow files (quando gia' hai accesso ad entrambi)
per usarli con John. Se userai solo il file shadow, le informazioni
GECOS non saranno usate dal metodo "single crack",
e non potrai nemmeno usare l'opzione '-shells'.
Di solito vorrai reindirizzare l'output di 'unshadow' ad un file.
mailer PASSWORD-FILE
Uno script shell per spedire una e-mail a tutti gli utenti che hanno
una password debole. Potrai anche modificare il messaggio da mandare.
Personalizzare John
---------------------
Il comportamento di John puo' essere personalizzato editando il suo file
di configurazione, john.ini. Puoi settare il default per le opzioni da
linea di comando, definire una wordlist e i rules per il "single crack",
definire i parametri per il metodo incrementale, o definire un nuovo metodo
di crakkaggio.
Il file di configurazione constiste in molte sezioni. Ogni sezione inizia
con una linea contenente il suo nome, in parentesi.
Le sezioni consistono in varie assegnazioni di contenuto a delle variabili
, o qualche altro testo specifico ad una particolare tipo di sezione
(il nome della sezione parte con 'list.'). Le sezioni e i nomi delle variabili
non sono case sensitive. Le linee che iniziano con '#' or ';' e quelle vuote
sono ignorate, puoi usarle per commenti.
Opzioni generali
------------------
Il default per qualche opzione di linea di comando puo' essere definita in
[Defaults]. Correntemente puoi definire solo una variabile:
Wordfile Setta il nome della wordlist. Questo assumera' il metodo wordlist
per default -- non richiede l'uso del comando '-wordfile' .
Definire i rule per wordlist
------------------------------
Il rules per wordlist e il metodo "single crack" sono definiti in sezioni
separate, rispettivamente [List.Rules:Wordlist] e [List.Rules:Single] .
I parametri del metodo Incremental
------------------------------------
Per definire i paramentri del metodo incremental necessiti di creare una
sezione chiamata [Incremental:MODE], dove MODE e' ogni identificativo che
assegni al metodo. Ci sono gia' dei metodo incrementali predefiniti come
default.
Sono supportati i seguenti parametri:
File Setta il nome del tuo file di charset.
MinLen La minima lunghezza della password, in caratteri (0 di default).
MaxLen La massima lunghezza della password, in caratteri (CHARSET_LENGTH e'
definita in src/params.h, per default normalmente e' 8).
CharCount Ti permette di limitare il numero dei differenti caratteri
usati, per far in modo che John parti provando gia' password grandi.
Da default (quando questo parametro non e' usato) tutti i caratteri
definiti saranno usati.
Extra Questo puo' essere usato per far provare qualche carattere extra a
John, che non appare nel file di charset.
Esempi d'uso di John
==================================
Questi esempi sono per darti delle informazioni sulle opzioni di John.
Linea di comando
-------------------
1. Primo, necessiti di prendere una copia del tuo file delle password. Se hai
il file shadow basta che digiti (come root):
unshadow /etc/passwd /etc/shadow > passwd.1
Poi fai:
cp /etc/passwd passwd.1
2. Facciamo finta che hai il file delle password, si chiama passwd.1, e vuoi
crakkarlo. Il metodo piu' semplice e' quello del crack singolo:
john -single passwd.1
o, con l'opzione abbreviata:
john -si passwd.1
Se non hai molti file da crakkare puoi farlo insieme:
john -single passwd.1 passwd.2
o anche:
john -single passwd.*
3. Ora, hai qualche password crakkata, sono salvate in ~/john.pot.
Puoi leggerle attraverso:
john -show passwd.1
Se l'output e' grande puoi sempre ridirigerlo attraverso un ('>')
Ora, vieni a sapere che molti account hanno una shell disabilitata, puoi far
in modo che John ignori queste (facendo finta che quella shell e' chiamata
'/etc/expired'):
john -show -shells:-/etc/expired passwd.1
o, corrispondente con '/any/path/expired':
john -show -shells:-expired passwd.1
o, se vuoi ignorare qualche altra shell '/etc/newuser':
john -show -shells:-expired,newuser passwd.1
Per vedere e' stato crakkato qualche account root:
john -show -users:0 passwd.1
o, in tutti i files:
john -show -users:0 passwd.*
Per mostrare solo l'account di root:
john -show -users:root passwd.1
Ed alla fine, controllare i gruppi privilegiati:
john -show -groups:0,1 passwd.1
4. Per trovare molte password complicate, puoi usare molti metodi potenti di
crakkaggio. Primo, prova una wordlist:
john -w:words.lst passwd.1
o, con i rules abilitati:
john -w:words.lst -rules passwd.1
Questo si prendera' un po' di tempo, allora tu lo metterai in background
aggiuncedoci la & alla fine:
nice -n 20 john -w:words.lst -rules passwd.1 &
Per crakkare solo account con shell buone:
john -w:words.lst -rules -shells:sh,csh,tcsh,bash passwd.1
Per crakkare piu' files con i rules e la wordlist:
john -w:words.lst -rules passwd.*
Questo invece provera' a crakkare solo le password di root in tutti i file
john -w:words.lst -rules -users:0 passwd.*
Qualche volta e' preferibile spezzare il tuo file delle password ed avviare
due processi di john:
john -w:words.lst -rules -salts:2 passwd.*
john -w:words.lst -rules -salts:-2 passwd.*
Questo fara in modo che John controlli solo le password velocemente, e poi
prova il resto. Il tempo totale del cracking e' simile ma potrai scovare
qualche password piu' facilmente, senza fare il resto.
Nota che il metodo wordlist di default include ':' (che significano prova
le parole che sono nella lista) alla prima linea.
Se hai gia' usato qualche volta il metodo wordlist e hai capito come funziona
puoi far diventare commento quella linea.
5. Il metodo piu' potente di crakkaggio in John e' chiamato "incremental"
Basta che digiti:
john -i passwd.1
Cio' fara' in modo che John usi i parametri di default del metodo incrementale
che sono definiti in john.ini [Incremental:All]. Nel file di configurazione
questi parametri sono usati dal set di 95 caratteri e provano tutte le
lunghezze di password da 0 a 8. Non dimenticare di togliere cio' per usarne
uno tuo.
In qualche caso, pero', e' molto utile usare qualche metodo incremental
predefinito. Il seguente comando provera' solo 26 caratteeri.
Da 'a' a 'zzzzzzzz'.
john -i:alpha passwd.1
Ancora, puoi crakkare solo l'account di root e usare qualche altra opzione
di John con il metodo incrementale. Questo programma provera' tutti gli
account di root (uid 0) in tutti i files di password, questo funzionera'
soprattutto se hai parecchi files di password. Per esempio con l'estenzione
*.pwd :
john -i -users:0 -salts:2 *.pwd
6. Se hai un file di password e hai gia' molte password crakkate, e sono
inusuali, potresti provare a generare un nuovo set di caratteri basati solo
su quel file di password:
john -makechars:custom.chr passwd.1
Poi usi il nuovo file per il metodo incrementale.
Se hai molti file di password, per esempio della tua universita', ti conviene
usare lo stesso set di caratteri.
john -makechars:custom.chr passwd.1 passwd.2
[ Add your custom incremental mode to ~/john.ini now. See below. ]
john -i:custom passwd.3
Pero' puoi anche usare qualche filtro di parole predefinito quando generi
il set di caratteri.
john -makechars:my_alpha.chr -external:filter_alpha passwd.1
Per usare i tuoi nuovi set di caratteri:
john -makechars:all.chr
john -makechars:alpha.chr -external:filter_alpha
john -makechars:digits.chr -external:filter_digits
In questo caso John sovrascrivera' i vecchi set di caratteri e li rimpiazzera'
con i nuovi.
7. Finalmente, puoi avvisare i tuoi utenti per comunicargli che la loro
password e' stata scoperta. Non e' una buona idea perche' potrebbero
arrabbiarsi, comunque in ogni caso edita lo script del mailer di john,
poi esegui:
mailer passwd.1
Configuration File
--------------------
1. Facciamo finta che in qualche filedi passwd molti utenti hanno le loro
password con i simboli '?!' aggiunti al login. A te basta creare un nuovo
metodo del crack singolo e lo metti vicino l'inizio. In questo caso:
[List.Rules:Single]
$?$!
Sugg.: se volete temporaneamente commentare tutti i rules di default,
potete semplicemente rinominare la sezione con qualcosa che John non usa,
e definirne una nuova con il vecchio nome.
Tutto cio' si puo' applicare anche al metodo wordlist.
2. Se generate u set di caratteri personalizzato hai bisogno anche di definire
dei parametri del metodo incrementale in una sezione del John.ini.
In un caso semplice potrebbe essere cosi' (dove custom e' un nome a piacere):
[Incremental:Custom]
File = custom.chr
Cio' fara in modo che John usi i caratteri che erano in password usate per
generare solo il set di caratteri. Per fare in modo che John provi altri
caratteri fai:
Extra = !@#$%
Sono stati aggiunti questi caratteri extra. Se vuoi essere sicuro, con i tuoi
caratteri extra, che John provi tutti i 95 caratteri, puoi aggiungere:
CharCount = 95
Questo fara' in modo che John stampi un warning solo se e' stato superato
il 95 carattere nel suo set di caratteri.
Puoi anche usare CharCount per limitare il numero dei caratteri che John
prova, sempre se il set di caratteri ne ha molti:
CharCount = 25
Se non usi nessun filtro quando generi un set di caratteri, imposta
CharCount molto basso, e fai in modo che John provi delle password lunghe..
Per fare in modo che John provi password solo di una certa lunghezza
usa la seguente linea:
MinLen = 6
MaxLen = 8
Imposta 'MinLen' ad high, se le password che vuoi crakkare non sono corte.
Imn caso contrario dovrai impostare 'MaxLen' a low, se vi sono molte password corte.
3. Un altro esempio: molti utenti in qualche sito prefissano la loro password
con un '1'. In questo caso potete aggiungere il seguente filtro di parole
esterno:
[List.External:Filter1]
void filter()
{
int i;
i = 0;
while (word[i] && word[i] >= 'a' && word[i] <= 'z') i++;
if (word[i] != '1' || word[i + 1]) word = 0;
}
Questo filtro lascera' solo le parole con qualche carattere alfabetico e
'1' alla fine. Ora potete usare esso con qualche altro metodo di crakkaggio,
ma cio' sara' molto lento, finche' molte parole non sono state filtrate.
Esso e' migliore da usare per generare il set di caratteri.
Se non vorrete usare la tabella di frequenza per qualche motivo, puoi farlo
lo stesso utilizzando un metodo esterno totalmente nuovo:
[List.External:Suffix1]
int length, current[9];
void init()
{
int i;
current[length = 6] = 0; current[i = length - 1] = '1';
while (i--) current[i] = 'a';
}
void generate()
{
int i;
i = length + 1;
while (i--) word[i] = current[i];
i = length - 2;
while (++current[i] > 'z')
if (i) current[i--] = 'a'; else current = -1;
}
void restore()
{
int i;
i = length + 1;
while (i--) current[i] = word[i];
}