在线hashcat解密 Hash et crypto ? Qu ' est-ce que le hachage, le chiffrement du hachage, le déchiffrement du hachage
Hashing et cryptage
Il existe un malentendu courant selon lequel le hash et le cryptage sont la même chose. Ils ne le sont pas. Le hash est irréversible. Prenons l'exemple suivant:
$ echo-n Password123 | md5sum
42f749ade7f9e195bf475f37a44cafcb-
On passe la chaîne "Password123" à l'algorithme MD5 (algo) qui effectue les opérations mathématiques et renvoie le hash codé hexadécimal généré. La seule façon d'obtenir la même valeur de sortie de hachage est de saisir algo à l'origine. Il y a des conflits, mais nous pourrons en parler plus tard.
La sortie de la plupart des algorithmes de hachage est une chaîne binaire de longueur fixe codée hexadécimalement. D'autres, comme cet exemple, utilisent une chaîne encodée base64 comme sortie. Notez que la longueur est toujours la même:
{SHA} uNF8eZRJ8jmr8WTjyocRJPVpe7w =
{SHA} lqdu/Zr6o2dgIER8Up1/7lcUtgw =
{SHA} qYUOwLMlDEuukA5HCT4LR1kQzco =
{SHA} MXZBCpyWJ7TTs1w2kgGJslwNwTg =
{SHA} 2sAPLaUh9Mz0bI + XxKEg7qyABe8=
TL; Dr
Le chiffrement est réversible, le hash n'est pas
Je ne veux pas trop parler de chiffrement (parce que ces trucs sont pour les livres), mais il est important de pouvoir faire la différence entre les chaînes de hash et les chaînes de chiffrement. Le chiffrement remplit généralement la chaîne de caractères pour satisfaire une longueur spécifique avant que le chiffrement ne se produise. Il nécessite également une clé (ou un mot de passe) pour le déchiffrer. Si un mot de passe chiffré est utilisé, la chaîne varie en fonction de la longueur de l'entrée. Si vous voyez un tas de mots de passe chiffrés, dont la longueur varie, vous avez peut-être affaire au chiffrement plutôt que au hachage. AES-256-CBC Exemple de chiffrement de chaînes et de texte simple associé (avec la clé "ASDF"):
foobar | U2FsdGVkX19G + KtytNHdj6yH2AVvX26pEmtunS/PRnU = foobarfoobar | U2FsdGVkX18sPpIvN6nVh68lOUCcb3gR2fKbCCnBxog = foobarfoobarfoobar | U2FsdGVkX1/EOnUt57TCW4Rh0EdNnWX + ldatuqv2xexeaeoww0xg/EXJUe9aSUz $ cat encrypted_passwords U2FsdGVkX19G + KtytNHdj6yH2AVvX26pEmtunS/PRnU = U2FsdGVkX18sPpIvN6nVh68lOUCcb3gR2fKbCCnBxog = U2FsdGVkX1/EOnUt57TCW4Rh0EdNnWX + lDatuQv2xEXXeAeowW0XG/EXJUe9aSUz $ pour i dans `cat encrypted_passwords`; do echo $i | openssl enc -base64 -d -aes-256-cbc -pass pass:asdf; écho Fait foobar foobarfoobar foobarfoobarfoobar
Maintenant vous pensez peut-être: vous avez peut-être raison. Cependant, le fait que le matériel critique doit être accessible au système signifie qu'il s'agit essentiellement d'un mot de passe maître en texte pur qui se trouve quelque part-qu'il s'agisse d'une clé RSA ou d'un mot de passe ou d'un fichier, intégré dans une base de données, codé dur dans une application ou un mot de passe quelque part dans la mémoire. pfft, personne ne va utiliser asdf comme clé pour chiffrer les mots de passe de leurs utilisateurs '
Utilisez la même chaîne pour MD5:
foobar | 3858f62230ac3c915f300c664312c63f foobarfoobar | 59faa421729e846dd800dce59943bfc0 foobarfoobarfoobar | 1352aadab322d1a033c27964be0965db
Le mot de passe hash est loin d'être parfait, en fait c'est un peu mauvais, mais c'est pire que le cryptage à cause de ce qu'il essaie d'atteindre. Les utilisateurs choisissent les exigences minimales absolues plus fréquemment que not et peuvent également l'utiliser sur plusieurs sites. Beaucoup de «hacks» ne sont en réalité rien de plus que des attaques de réutilisation d'identifiants. Si le compromis initial consiste à utiliser le chiffrement, le seul effort que l'attaquant doit faire est de trouver la clé pour déchiffrer tous les mots de passe. Pour les hash, ils doivent au moins faire des efforts pour les craquer. Lorsqu'elle est utilisée avec des algorithmes modernes tels que sha512crypt, bcrypt, scrypt ou argon2, les valeurs de hash peuvent nécessiter un effort considérable pour être craquées.
Marinage
Ajouter du sel consiste à ajouter une chaîne de caractères au mot de passe avant le hash. Le sel de chaque hash doit être unique et généralement sélectionné au hash, car l'intérêt est de faire que la même valeur de hash «mot de passe» en texte clair ait une valeur différente à chaque fois. Cela rend la vie difficile pour les craqueurs de mots de passe, car pour vérifier le mot «mot de passe» pour chacun des 1 000 utilisateurs, chaque utilisateur a un SALT unique, ils doivent le faire 1 000 fois-une fois par utilisateur/SALT. Cela signifie également qu'ils ne peuvent pas utiliser efficacement des dictionnaires précompilés ou des tables arc-en-ciel (souvent...), car ils nécessitent un per-sel personnalisé.
Les sites Web gâchent parfois cela et utilisent des sels génériques pour tous les utilisateurs; Cela va à l'encontre du but.
Voici les hachs SHA1 avec sel:
b353977827f67a4ae0318f3a9447fae1c13d9d90:b8d18ca |___________________________________________| hash | sel | séparateur
Le texte clair de ce hash est «mot de passe». Sa valeur de sel est "b8d18ca" et utilise SHA1 ($salt.$pass) dans l'API. Cela signifie que l'algorithme obtient le texte clair du mot de passe, génère le sel et l'ajoute devant le texte clair. Lorsqu'un site Web ou une application tente de vérifier votre mot de passe à l'avenir, il prend votre mot de passe en texte clair comme entrée, lit la valeur salt dans le Hash stocké, l'ajoute devant le mot de passe que vous avez choisi et compare la valeur de Hash générée avec la valeur de Hash stockée. Cracking Si vous ne savez pas qu'une partie de celui-ci est du sel, le hachage produira le texte simple suivant:
b8d18capassword
Puisque l'algorithme fait une entrée de texte simple, le sel et les valeurs de hachage générées peuvent rester transparentes pour l'utilisateur. Lors du craquage, si l'algorithme est salé, nous devons connaître le sel afin que nous puissions le fournir lors de la génération de plaintext candidat.
Si elle est correctement mise en œuvre, le salage peut rendre la fissuration plus longue. Avec des sels aléatoires, vous forcez Cracker à perdre du temps à essayer de craquer des valeurs de hachage pour lesquelles le sel ne correspond pas. Cela complète à peu près l'effort requis pour device_speed/number_of_salts, car nous devons générer un candidat pour chaque sel. Si le sel est statique, alors les opérations mathématiques sont les mêmes... speed_of_device/1. Une autre façon de voir ceci:
notre GTX 980 cracks SHA1 ($salt.$pass) à 3576,8 MH/s ou 3,5 milliards candidats par seconde Notre hashlist contient 1000 uniques sels 3 500 000 000 / 1000 = 3 500 000 candidats par seconde
Cela est de trois ordres de grandeur plus lent, avec une perte de 99,9%. Avec le sel statique, cela ressemble à ceci:
Our GTX 980 cracks SHA1 ($salt.$pass) at 3576,8 MH/s ou 3,5 milliards candidats par seconde Notre hashlist contient 1 unique sel 3 500 000 000 / 1 = 3 500 000 000 candidats par seconde
Si cela n'a pas de sens, continuez à lire, nous aurons un beau graphique plus tard...
Iteration
Une autre amélioration courante par rapport au simple «hachage de ce texte clair» est que «hachage de ce texte clair, puis hachage de ce résultat, puis hachage de ce résultat» est répété des milliers de fois. Cela permet d'essayer un seul mot de passe candidat lorsque le programme de craquage de mot de passe doit effectuer des milliers de travaux. Cela est appelé itération, boucle ou coût variable. Certains algorithmes de hachage de mot de passe utilisent des tours d'itération codés; Autre Git. Il est alors configurable dans une partie du hachage lui-même. Par exemple, md5crypt () utilise MD5, y compris salt, et boucle exactement 1000 fois. sha512crypt () utilise sha512, inclut un sel et boucle un nombre configurable de fois (par défaut 5 000).
Les itérations affectent principalement le coût du cycle de calcul de l'algorithme de hachage plutôt que son utilisation en mémoire ou d'autres facteurs. Ces attaques sont également importantes lors de la conception d'attaques optimisées pour résister à certains types de types de hachage, mais c'est trop mauvaise pour être discutée ici.
Effet du type de hachage sur la vitesse de craquage
Regardons quelques exemples pour démontrer l'impact du choix de l'algorithme de hachage, que ce soit salté, utilisant plusieurs itérations, etc. Supposons que l’attaquant recueille 1 000 hash d’utilisateurs provenant d’un site Web infecté et qu’il ne veut qu’effectuer une simple attaque en testant chaque hash de mot de passe-143 millions de mots de passe candidats.
Le type de hachage utilisé par le site infecté aura un impact considérable sur le temps nécessaire à l'attaquant pour passer par cette attaque. Voici un graphique (relatif, approximativement) de combien il faut des secondes pour terminer cette attaque, selon le type de hash utilisé, où la carte graphique standard:
Bon, ça ne sert à rien! Les types de hachage les plus forts sont beaucoup plus lents, mais les types plus rapides sont simplement écrasés à rien. Essayons à nouveau la même taille de données en utilisant le temps logarithmique de l'axe X. Lorsque les barres se déplacent de gauche à droite, elles augmenteront de la puissance de 10:
Donc quelques points importants sont les suivants: une seule ronde est plus facile que de multiples rondes et sans sel que d'ajouter du sel lorsque vous voulez craquer un hash de mot de passe. Au contraire, lorsque certaines entreprises ou sites Web annoncent une violation de données contenant des données d'utilisateurs, a) le mot de passe a préférablement été haché et non seulement du texte simple; b) ils sont mieux salés et non seulement hachés; c) Ils feraient mieux d'avoir utilisé de puissants hachs salés multi-tours tout le temps, pas seulement un seul tour.
Identification du type de hachage
Avant de tenter de craquer un hachage de mot de passe donné, il appartient au cracker de déterminer quel algorithme de hachage est utilisé pour l'implémenter. L'identification des types de hachage est généralement simple, mais pas toujours. Les Crackers font souvent des suppositions éclairées basées sur des indices tels que la longueur de hachage et le format. En fin de compte, la seule façon de se convaincre que la devination du type de hash est correcte est si le hash a été piraté.
Quelques excellentes ressources pour cette tâche sont fournies ici et ici, et elles montrent toutes les deux à quoi ressemblent les valeurs de hachage communes.
Le package "hash-identifier" (disponible ici) est disponible dans Kali Linux pour aider à identifier les types de hash inconnus.
Collision
Une collision survient lorsque deux entrées différentes donnent la même sortie de hachage. C'est mauvais (évidemment). Pour les mots de passe, cela signifie peut-être que je n'ai pas craqué votre mot de passe réel, mais comme j'ai trouvé une entrée qui produit la même valeur de hachage, je peux utiliser une valeur de texte simple pour tromper le système de penser que le mot de passe est légitime.
Microsoft Office utilise dans sa protection des documents un algorithme sujet aux conflits depuis des années. Il n'est pas rare de découvrir plusieurs conflits pour un seul hash, tous déverrouillant le document.
Une fois un conflit découvert, l'algorithme est effectivement corrompu. Si cela se produit une fois, il est statistiquement probable que cela se reproduise. La seule chose qui nous empêche, c'est le temps et la capacité de traitement. À mesure que les algorithmes deviennent plus robustes, il faut plus de capacité et de temps pour générer des algorithmes candidats et comparer les sorties hachées pour les rechercher. Par conséquent, les concepteurs sont de plus en plus doués pour créer des algorithmes moins sujets aux conflits.