Trencant hashes amb Hascat

Abans de començar, si no saps ben bé que són i com funcionen els hashes, et recomano que facis un cop d’ull a l’entrada Funció de Hash. T’ajudarà a entendre com funcionen i la seva importància dins del món de la seguretat, tan a la part ofensiva com a la defensiva.

Habitualment et trobaràs que després de llençar un atac satisfactori el que aconseguiràs, a part de poder arribar a comprometre un equip, són hashes d’usuaris, ordinadors o serveis.

Hi haurà vegades que els hashes que trobis els podràs utilitzar directament, però la majoria et tocarà trencar-los per descobrir la contrasenya en text clar.

Hashcat

Hashcat és una eina que es va dissenyar per trencar hashes d’alta complexitat invertint el mínim temps possible.
Té dues variants, la basada en CPU (processador) i GPU (gràfica). Les eines basades en GPU acostumen a poder desxifrar els hashes més ràpid que les de CPU, però també són les més cares.

Algunes de les característiques de Hashcat són:

  • Completament gratis i de codi lliure
  • Compatible amb Linux, Windows i MacOS
  • Disponible en diverses plataformes com CPU i GPU
  • Permet desxifrar hashes en paral·lel
  • Més de 350 tipus diferents de hashes implementats.

Instal·lació

En Windows i MacOS, el més ràpid és accedir a la pàgina de Hashcat i descarregar l’última versió que conté els executables.

En sistemes Linux, pots instal·lar-lo amb la següent comanda:

sudo apt install hashcat

Si utilitzes distribucions de Linux preparades per fer pentesting, com Kali, l’eina ja hauria d’estar instal·lada per defecte.

Tipus de hashes

Hashcat suporta més de 350 tipus de hash diferents. Abans de llençar l’atac hauràs d’indicar quin tipus de hash vols trencar. Pots trobar-los tots a la seva web.

Els que més et trobaràs segurament són:

  • MD5: 0
  • SHA1: 100
  • NTLM: 1000
  • SHA256: 1400
  • SHA512: 1700
  • LM: 3000
  • NetNTLMv1: 5500
  • NetNTLMv2: 5600
  • Kerberos 5, etype 23, AS-REQ Pre-Auth: 7500

Si tens dubtes sobre el tipus de hash que tens, pots utilitzar eines com Hash-Identifier per esbrinar-ho.

Modes d’atac

Una vegada identificat el tipus de hash que vols trencar, toca escollir el mode d’atac. Aquest és un punt molt important, ja que depenent del mode tardaràs més o menys temps i pot ser decisiu a l’hora de trobar la contrasenya o no.

  • Mode 0: Straight: aquest atac és el conegut com atac de diccionari. Hashcat comprova si la contrasenya correspon a alguna de les entrades del diccionari.
  • Mode 1: Combinaion: en aquest cas, Hashcat rep dos diccionaris i comprovarà si la contrasenya correspon a alguna entrada resultant de la combinació de les del primer amb cada una de les del segon.
  • Mode 3: Brute-force: a diferència dels anteriors, a aquest atac és Hashcat qui genera les contrasenyes a comparar amb els hashes. Hi ha dos tipus d’atacs de força bruta que pots fer:
    • Força bruta convencional: prova totes les combinacions possibles. La probabilitat de trobar la contrasenya és del 100%, però el temps a invertir pot ser infinit.
    • Força bruta amb màscares: igual que l’anterior però permet acotar més els valors o caràcters a provar utilitzant màscares.
  • Hybrid: combina la potència dels atacs de diccionari amb la dels atacs de força bruta utilitzant màscares:
    • Mode 6: Diccionaris + màscares: primera part de la contrasenya donada pel diccionari i la segona a través de màscares.
    • Mode 7: Màscares + diccionaris: primera part de la contrasenya donada través de màscares i la segona pel diccionari.
  • Mode 9: Association attack: donat un usuari, un fitxer, una paraula clau o qualsevol tipus d’informació, Hashcat generarà contrasenyes per atacar un hash específic. Aquest mode és molt nou i encara no està implementat a producció.
  • Rule-based attack: aplica certes regles predefinides a les entrades dels diccionaris. Compatible amb els modes 0, i 9, tot i que t’ensenyaré com combinar-ho amb els 6 i 7.
  • Toggle-case attack: per cada paraula del diccionari, genera totes les possibles combinacions de majúscules i minúscules. Aquest atac actualment es fa amb regles.

Mode 0: Diccionaris

Quan vols atacar a una persona i robar-li la contrasenya, has de pensar que és un humà i no un ordinador. És a dir, que la contrasenya no serà una cadena de caràcters alfanumèrica sense sentit, sinó que serà una paraula o conjunts de paraules fàcils de recordar i que segurament tindran relació amb la seva vida.

Per aquest motiu els atacs de diccionaris són tant famosos, ja que hi ha la possibilitat de poder aconseguir la contrasenya amb molt menys temps. Si l’objectiu és una persona o empresa en contret, es pot arribar a crear un diccionari personalitzat i tot.

Si vols buscar o crear un diccionari has de tenir en compte la regla del 20/60/20, ja que no pots provar totes les combinacions de paraules i les seves variacions per falta de temps.

Aquesta regla diu el següent:

  • El 20% de les contrasenyes són fàcils i es poden trobar amb diccionaris genèrics, contrasenyes comunes o màscares senzilles.
  • El 60% de les contrasenyes tenen una dificultat moderada i són una lleugera variació i/o mutació del 20% anterior.
  • El 20% restant són difícils d’esbrinar, ja que són complexes i tenen una longitud superior a l’habitual o alguna característica única.

Preparació diccionaris

Els diccionaris acostumen a ser fitxers enormes amb milions de possibles contrasenyes. Aquests poden tenir contrasenyes populars, específiques de certes tecnologies o inclús contrasenyes reals extretes després d’un atac exitós.

Fer un bon diccionari és pot considerar un art. Com no podria ser de cap altra manera, hi ha moltes persones que es dediquen a recol·lectar tot tipus de contrasenyes i centralitzar-les. Alguns dels diccionaris més famosos són:

  • RockYou2009: contrasenyes obtingudes d’una filtració l’any 2009. És el diccionari més famós dins del món de la seguretat.
    • Té 14.442.063 de contrasenyes úniques
    • Està per defecte al següent directori de Kali: /usr/share/wordlists/
    • Actualment és considera desfasat.
    • Descàrrega
  • RockYou2021: és l’actualització del famós RockYou amb contrasenyes que s’han extret de la Deep Web.
    • Té 82 bilions de contrasenyes úniques de 6 a 20 caràcters, sense caràcters que no siguin ASCII i sense espais.
    • Aquest diccionari pesa 100GB
    • Descàrrega
    • Per crear-lo han utilitzat també les contrasenyes dels següents diccionaris:
      • CrackStation: enllaç
      • Hack3: enllaç
      • SecLists: enllaç
      • Probable Wordlists: enllaç
      • Weakpass: enllaç
      • El conegut Breach Combo List 3.2B que és una compilació de contrasenyes robades de Linkedin, Netflix, Exloit.in…
  • Kaonashi: diccionari presentat a la Rooted del 2019 que té 3 diccionaris diferents.
    • Té 866 milions de contrasenyes
    • També té regles i màscares
    • Descàrrega

Prova de concepte

Una vegada has escollit el diccionari, només que queda indicar el tipus de hash que vols trencar. La comanda bàsica de Hashcat és la següent:

hashcat -m ID_TIPUS_HASH -a 0 HASH.txt DICCIONARI.txt

Al següent exemple, he utilitzat un diccionari de contrasenyes de SecLists per trencar un conjunt de hashes del tipus SHA-256. Les contrasenyes són pikachu, projectenadki i violins respectivament.

El fitxer hashes.txt conté els hashes:

43999461d22f67840fcd9b8824293eaa4f18146e57b2c651bcd925e3b3e4e429
b7e1bdcf56567c2252cda827c462a5740982e0d13b5bbfdd4ae2f78d554b3117
435420c45be58ae67ee796f0f4abcafbadbd25e853cd79aba8717afd1731865a

A continuació, indico a Hashcat el tipus de hash, 1400 ja que són SHA-256, el fitxer que conté els hashes a trencar i el diccionari a utilitzar:

Tenint un ordinador no optimitzat per trencar hashes, ha tardat només uns 30 segons a provar unes 40.000 contrasenyes:

Com pots veure, els hashes que va trobant els mostra per terminal. També els emmagatzema tots al fitxer hashcat.potfile, pots accedir-hi amb la següent comanda:

hashcat -m ID_TIPUS_HASH --show HASH.txt

Així podràs veure tots els resultats agrupats:

De les tres contrasenyes, només ha trobat la primera i l’última, ja que projectenadki no és una paraula que estigués al diccionari.

Mode 3: Força bruta amb màscares

Una màscara és un conjunt de regles que indiquen com estan formades les contrasenyes que vols generar. És a dir, que la màscara especificarà quins conjunts de caràcters pot tenir cada posició de la contrasenya.

Els caràcters fixes s’escriuen tal qual, però el conjunt s’indica amb un ?:

  • ?l: lletres minúscules (a-z) 26 caràcters
  • ?u: lletres majúscules (A-Z) 26 caràcters
  • ?d: decimals (0-9) 10 caràcters
  • ?h: dígits hexadecimals minúscules (0-9, a-f) 16 caràcters
  • ?H: dígits hexadecimals majúscules (0-9, A-F) 16 caràcters
  • ?s: símbols ASCII bàsics (per exemple @) 33 caràcters
  • ?a: caràcters ASCII (números, lletres i símbols) (combinació de ?l, ?u, ?d i ?s) 95 caràcters
  • ?b: qualsevol byte (0x00-0xff)

Al crear màscares has de vigilar, ja que fàcilment pots arribar a generar llistes de milions i milions d’entrades, cosa que pot implicar que tardis anys a comprovar-les totes. Per exemple, el nombre d’entrades de contrasenyes de 8 caràcters de longitud és:

  • Només majúscules o minúscules: 208.827.064.576 entrades
  • Només majúscules i minúscules: 53.459.728.531.456 entrades
  • Només números: 100.000.000 entrades
  • Alfanumèrica: 6.634.204.312.890.625 entrades

Quan utilitzis màscares segurament voldràs tenir en compte diferents longituds, no només de 8 caràcters. Per evitar haver de crear una màscara per cada longitud de contrasenya que vulguis provar, Hashcat proporciona l’argument -i (-increment) amb el que Hashcat anirà provant iterativament les n primeres posicions de la màscara (-increment-min) per cada iteració fins al màxim de caràcters especificats (-increment-max).

Per exemple, provar tots els caràcters ASCII de les contrasenyes de longitud 3 a 5:

hashcat –m 1000 –a 3 HASH.txt ?a?a?a?a?a?a –i –increment—min 3 increment—max 5

Hashcat provarà seqüencialment les següents màscares:

  1. ?a?a?a
  2. ?a?a?a?a
  3. ?a?a?a?a?a

Per personalitzar encara més les màscares, Hashcat permet crear el que anomena charshet, que consisteix en definir diversos conjunts de caràcters personalitzats.

Per exemple, definint els següents conjunts de caràcters:

  • -1: ?u
  • -2: ?l?u?d
  • -3: ?d

Es pot executar la següent comanda per provar totes les contrasenyes que comencin amb majúscula i acabin amb números, com Nadki1234:

hashcat -m 0 -a 3 HASH.txt -1 ?u -2 -?l?u?d -3 ?d ?1?2?2?2?2?3?3?3?3

Preparació de màscares

Un aspecte claus a l’hora d’escollir quina màscara utilitzar és conèixer la política de contrasenyes del sistema a atacar. Per exemple, si obliga a l’usuari a posar una contrasenya no menor a 8 caràcters que contingui majúscules, minúscules i números, la màscara bàsica seria:

  • ?a?a?a?a?a?a?a?a

Això serien moltes combinacions possibles, però se li pot donar una volta. Al final, estem atacant a humans i els humans no volen invertir temps en seguretat normalment. Això implica que tindran un contrasenya que hauran de recordar i per tant, pots arribar a deduir un patró. Està clar que no funcionarà pel 100% com la màscara anterior, però segurament si pel 80%.

Si la persona té una certa edat, segurament va posar una contrasenya de petit al crear el seu compte d’email. En aquells temps no obligaven a posar majúscules ni números. Per tant, si s’ha vist obligat a actualitzar-la, el més probable és que la majúscula l’hagi posat al primer caràcter i els números al final:

  • ?u?a?a?a?a?a?a?a?d
  • ?u?a?a?a?a?a?a?a?d?d
  • ?u?a?a?a?a?a?a?a?d?d?d?d

També és molt probable que seguint el mateix patró, si l’ha de crear des de 0, directament esculli una de exactament 8 caràcters en lloc d’ampliar la longitud:

  • ?u?a?a?a?a?a?d?d
  • ?u?a?a?a?d?d?d?d

Es pot tunejar encara més si fas la suposició de que els dígits del final són anys de naixement o dates importants. Així que es pot incloure els anys des del 1940 al 1999 o del 2000 al 2010 per exemple:

  • Del tipus Xxxxxx85:
hashcat -m 0 -a 3 HASH.txt -1 456789 ?u?a?a?a?a?a?1?d
  • Del tipus Xxxxxx1985:
hashcat -m 0 -a 3 HASH.txt -1 456789 ?u?a?a?a19?1?d

Tal i com he comentat abans, hi ha gent que es dedica a fer recopilacions. Com no podria ser de cap altra manera, també n’hi ha de màscares:

Prova de concepte

Pel següent exemple, he utilitzat una màscara del tipus una majúscula, quatre minúscules i dos dígits finals (7 caràcters de longitud), per trencar un conjunt de hashes del tipus SHA-256. Les contrasenyes són Nadki20, Maria95 i Cl4r496, respectivament.

Una vegada has escollit la màscara, només queda indicar el tipus de hash que vols trencar. La comanda bàsica de Hashcat és la següent:

hashcat -m ID_TIPUS_HASH -a 3 HASH.txt MÀSCARA

El fitxer hashes.txt conté els hashes:

3d932a7d565dde61d2bba1939b87699e4794bf637183a9355012b560a84afeb7
6d3d8b54c3c8ac55623a6728cc33384fc069500ff5305c0fd2e5ea6d1572aa3a
9264687283a26524e73cb311ec2ba042f10f6903481a6db01d599394d8708d6d

A continuació, s’indica a Hashcat el tipus de hash, 1400 ja que són SHA-256, el fitxer que conté els hashes a trencar i la màscara a utilitzar:

Tenint un ordinador no optimitzat per trencar hashes, ha tardat només 21 segons a provar 1.188.137.600 contrasenyes:

Com pots veure, els hashes que va trobant els mostra per terminal. També els emmagatzema tots al fitxer hashcat.potfile, pots accedir-hi amb la següent comanda:

hashcat -m ID_TIPUS_HASH --show HASH.txt

Així podràs veure tots els resultats agrupats:

De les tres contrasenyes, ha trobat les dues primeres, ja que Cl4r496 no complia el patró de la màscara que he utilitzat.

Es poden agrupar les màscares a un fitxer per a poder llençar diverses a la vegada. Si ho fas així, tingues en compte que el format amb el que s’especifiquen les màscares canvia, ja que la separació es fa per comes en lloc d’espais:

456789,?u?l?l?l?l19?1?d
012,?u?l?l?l?l20?1?d

A la comanda només hauràs d’especificar el directori del fitxer:

hashcat -m ID_TIPUS_HASH -a 3 HASH.txt MÀSCARA.hcmask

Al següent exemple, he utilitzat una màscara del tipus majúscula, quatre minúscules i any de 4 dígits (9 caràcters de longitud), que podrien ser anys de naixement o dates importants, per trencar un conjunt de hashes del tipus SHA-256. Les contrasenyes són Paris1998, Tokio2016 i Mexic2030, respectivament.

El fitxer hashes.txt conté els hashes:

7bac7206381c4f0f36593a8d5610e9852f9ccfc9b4bb3740e21e3c36011d8087
fbfc393ff497e6c40cc094b7a1ed6ca3d9e1d0ea94b5db68a9eae5e1a996ea2e
3d79cfb8ff2b2188d536f86a9be5fc24dc02ba2e5fd63694a278538adab06fde

Les màscares que utilitzo són les mateixes que a l’exemple anterior, estan al fitxer masc.hcmask:

456789,?u?l?l?l?l19?1?d
012,?u?l?l?l?l20?1?d

A continuació, indico a Hashcat el tipus de hash, 1400 ja que són SHA-256, i els fitxers que contenen els hashes a trencar i les màscares:

En aquest cas, com que hi ha dues màscares es mostren dues pantalles d’estat. La primera és la de la primera màscara, on ha tardat 10 segons a provar 712.882.560 contrasenyes:

La segona màscara ha tardat 7 segons a provar-ne 356.441.280:

Els resultats els emmagatzema al fitxer hashcat.potfile, pots accedir-hi amb la següent comanda:

hashcat -m ID_TIPUS_HASH --show HASH.txt

Així podràs veure tots els resultats agrupats:

De les tres contrasenyes, ha trobat les dues primeres: Paris1998 amb la primera màscara i Tokio2016 amb la segona. Mexic2030 no l’ha trobat ja que a la segona màscara he especificat que provi des del 2000 al 2029.

Híbrid (Hybrid)

Els atacs híbrids amb Hashcat consisteixen en convidar les dues opcions que has vist amb anterioritat, la de diccionari i la de màscara. Específicament, aquesta categoria té dues variants:

  • Atribut -6: generarà contrasenyes afegint la màscara al final de cada paraula del diccionari.
  • Atribut -7: generarà contrasenyes afegint la màscara al començament de cada paraula del diccionari.

Prova de concepte

Pel següent exemple, he utilitzat una màscara per fer totes les combinacions de 4 dígits i un diccionari de noms de SecLists, per trencar un conjunt de hashes del tipus SHA-256. Les contrasenyes són: ursula1564, sofia2003 i nadki2020, respectivament.

Una vegada has escollit la màscara, només queda indicar el tipus de hash que vols trencar. La comanda bàsica de Hashcat és la següent:

hashcat -m ID_TIPUS_HASH -a 6 HASH.txt DICCIONARI.txt MÀSCARA

El fitxer hashes.txt conté els hashes:

527c5c6f09e3dc82765808431eebccc92b67b68026fd8299080e76b981200139
e8072e15e7a453ce1911dca29d909c23a5c849c774d2904641b5b3e0b2e45978
6b87c6a43bc6654076f95c76b38f65ce2cd7854f54b9766e0ed196cd2df66e64

A continuació, indico a Hashcat el tipus de hash, 1400 ja que són SHA-256, el fitxer que conté els hashes a trencar, el diccionari i la màscara a utilitzar:

Tenint un ordinador no optimitzat per trencar hashes, ha tardat només 9 segons a provar 101.770.000 contrasenyes:

Els resulstats els emmagatzema tots al fitxer hashcat.potfile, pots accedir-hi amb la següent comanda:

hashcat -m ID_TIPUS_HASH --show HASH.txt

Així podràs veure tots els resultats agrupats:

De les tres contrasenyes, ha trobat les dues primeres, ja que nadki2020 no és un nom que estigui al diccionari.

Tot i que els atacs que he fet com a proves de concepte funcionen bé i són exitosos en escenaris reals, a vegades ofereixen poca flexibilitat. Per exemple, si tens un diccionari de noms, per fer que la primera lletra sigui majúscula hauries de canviar-les totes manualment. Per evitar això i permetre una flexibilitat completa, Hashcat ofereix el que es coneix com a Regles.

Regles

L’atac basat en regles és un del atacs més complicats que existeixen a Hashcat. La raó és molt simple: és com un llenguatge de programació dissenyat per generar contrasenyes. Té funcions per modificar, tallar o estendre paraules i també té operadors condicionals. Això fa que sigui molt flexible i eficient, però complicat.

Pots trobar tota la informació i taules que explicaré a continuació a la pàgina web de Hashcat: web

Per a poder-ho explicar millor, posaré un exemple molt simple. Imagina que tens un llistat de contrasenyes com el següent:

nadki
maria
empresa

Si volguessis afegir els dígits 2020, quedaria així el diccionari:

nadki
nadki2020
maria
maria2020
empresa
empresa2020

També pots tenir en compte les que comencen amb majúscula:

nadki
nadki2020
Nadki
maria
maria2020
Maria
empresa
empresa2020
Empresa

Per últim, podries pensar en canvis típics de lletres a números, com a -> 4, e -> 3, i -> 1, o -> 0.

Tot i que aquest diccionari el pots crear fàcilment en 1 minut, imagina ara tenir un fitxer amb milions de contrasenyes. Gràcies a les regles, podràs afegir combinacions de paraules fàcilment.

Aquestes són algunes de les funcions que utilitzaré per crear la regla d’exemple. És una taula resum, la completa la pots trobar a la web de Hashcat:

NomFuncióDescripcióExemple ReglaInicialFinal
Res:No fer res:p@ssW0rdp@ssW0rd
MinúsculeslTotes les lletres minúsculeslp@ssW0rdp@ssw0rd
MajúsculesuTotes les lletres majúsculesup@ssW0rdP@SSW0RD
Primera majúsculacPrimera lletra en majúscula i la resta en minúsculacp@ssW0rdP@ssw0rd
Majúscules invertidesCPrimera lletra en minúscula i la resta en majúsculaCp@ssW0rdp@SSW0RD
Caràcter al final$XAfegeix un caràcter al final$1p@ssW0rdp@ssW0rd1
Caràcter a l’inici^XAfegeix un caràcter a l’inici^1p@ssW0rd1p@ssW0rd
InsereixiNXInsereix un caràcter X a la posició Ni4!p@ssW0rdp@ss!W0rd
SobrescriuoNXSobrescriu un caràcter X a la posició No3$p@ssW0rdp@s$W0rd
SubstituciósXYSubstitueix tots els caràcters X per Yss$p@ssW0rdp@$$W0rd

Creació

Per començar, crea un fitxer amb el nom que vulguis. Per aquest exemple utilitzaré regles.txt. I a partir d’aquí, només caldrà posar les diferents regles una sota l’altra.
Primer de tot, indico no fer res per tenir en compte les paraules inicials del diccionari, afegir el 2020 al final de la paraula i posar en majúscula la primera lletra:

:
$2 $0 $2 $0
c

Ara toca fer les substitucions de lletres a números:

sa4
se3
si1
so0

Les regles anteriors farien només una substitució per paraula, per exemple m4ri4 o mar1a. Si vols aplicar més d’una regla a la vegada, pots separar-ho en espais:

sa4 se3 si1 so0

Per tant, el fitxer regles.txt quedaria així (el caràcter # es per posar comentaris, Hashcat no executarà la línia):

# No fer res
:
# Afegir 2020 al final
$2 $0 $2 $0
# Primera en majúscula
c
# Substituir a per 4
sa4
# Substituir e per 3
se3
# Substituir i per l
si1
# Substituir o per 0
so0
# Substituir a per 4, e per 3, i per l i o per 0
sa4 se3 si1 so0

Verificar regles

Abans d’utilitzar la regla, es recomana que la provis. Amb la següent comanda no només podràs veure quines paraules genera la teva regla, sinó que Hashcat t’indicarà si hi ha alguna regla mal feta:

hashcat -r REGLA DICCIONARI --stdout

A aquest exemple, el resultat és el següent:

nadki
nadki2020
Nadki
n4dki
nadki
nadk1
nadki
n4dk1
maria
maria2020
Maria
m4ri4
maria
mar1a
maria
m4r14
empresa
empresa2020
Empresa
empres4
3mpr3sa
empresa
empresa
3mpr3s4

Cracking

Per últim, només queda executar el nostre diccionari i les regles per intentar trencar hashes. Les hashes a trencar contenen les contrasenyes Nadki, empresa2020, m4ri4, 3mpr3s4 i Empresa2020:

9d8e45cdf56f25e7da49b95507d5c2feb3218b40a147aec0ba6090d49ad2cbfb
94a57d717caa4936154d46505b4a930de84775f0ad420bc0042c0b5b690b403d
9535d81a08766346051abac69aefd23fe1dedc032edcaa22afaa19709ae11041
1e61c8754757c20cf4dabfbe7a2d9eaa9a0a1757d4dc0bdded8e270b5bb19514
5256339a38b4102df67e19cdc276209d19efd200c42a51420b668c398e88373e

La comanda a executa serà la següent:

hashcat -m ID_TIPUS_HASH HASH DICCIONARI -r REGLA

A continuació, indico a Hashcat el tipus de hash, 1400 ja que són SHA-256, el fitxer que conté els hashes a trencar, el diccionari i la regla a utilitzar:

Ha tardat molt poc en provar totes les contrasenyes:

Els hashes trobats els emmagatzema tots al fitxer hashcat.potfile, pots accedir-hi amb la següent comanda:

hashcat -m ID_TIPUS_HASH --show HASH.txt

Així podràs veure tots els resultats agrupats:

Ha trobat totes les contrasenyes menys l’última, ja que no he tingut en compte posar en majúscula la primera lletra a totes les regles.

Atac híbrid

Com no podia ser de cap altra manera, les regles es poden combinar amb qualsevol dels modes d’atac que he explicat amb anterioritat.

Per exemple, si volguessis aplicar les regles de l’apartat anterior però a més a més afegir un dígit al final de la paraula, del 0 al 9, hauries de o ve fer-ho manualment amb regles o utilitzar màscares.

Hi ha dues maneres de fer-ho, ja que Hashcat no és compatible per ara en utilitzar diccionari, màscara i regles a la vegada.

La primera és executar primer la màscara amb el paràmetre –stdout, guardar el resultat a un fitxer i després utilitzar aquest fitxer com a diccionari.

La segona forma és utilitzar el que es coneix com a pipes a Linux. És a dir, executar una comanda i utilitzar el resultat directament per a una segona:

hashcat -a 6 DICCIONARI MÀSCARA --stdout --session s2 | hashcat -a 0 -m ID_TIPUS_HASH HASH -r REGLA --session s1

Pots utilitzar –stdout a la segona comanda si vols veure el resultat només:

hashcat -a 6 DICCIONARI MÀSCARA --stdout --session s2 | hashcat -a 0 -r REGLA --stdout --session s1

És necessari afegir el paràmetre –session per crear dues sessions de Hashcat diferents, ja que sinó et sortirà l’error:

Already an instance '/usr/bin/hashcat' running on pid XXXX

Regles ja existents

Com no podia ser de cap altra manera, hi ha moltíssimes persones que han creat regles després d’analitzar millons de contrasenyes. Si no vols reinventar la roda, pots fer un cop d’ull als següents recursos:

  • Kaonashi: té tres families de regles.
  • Password Cracking Rules: és una recopil·lació i combinació de regles dels següents recursos:
    • Hob0Rules: regles basades en estadístiques i en patrons.
    • Hashcat: les regles per defecte de Hashcat
    • NSA Rules: regles extretes de diversos recursos, posades a prova per saber la efectivitat.
    • KoreLogic: regles creades per JohnTheRipper migrades a Hashcat.
  • Hashcat: al directori /usr/share/hashcat/rules hi ha algunes regles predefinides:

References

Etiquetes: , , ,

Deixa un comentari