Journal Générateur de mot de passe

Posté par SlowBrain (site web personnel) le 20 janvier 2018 à 12:03. Licence CC By‑SA.

Étiquettes :

jan.

2018

Bonjour.
Sans prétention aucune, j’ai créé un petit générateur de mot de passe, m’inspirant librement de l’idée du célèbre XKCD N° 936 sur le sujet.

C’est minimaliste (~50 lignes de codes, 300 de données, le tout dans un unique fichier), probablement plein d’erreur et d’amélioration à apporter.

C’est du JavaScript (avec une goutte de HTML et de CSS), sous licence MIT et disponible sur framagit : Lien vers le projet

XKCD N°936

# Hawpass

Posté par Adminrezo (site web personnel) le 20 janvier 2018 à 13:14. Évalué à 7.

Hawpass fait ça mais en anglais, il suffit peut-être de changer les dictionnaires.

Il y a quelque temps, j'avais essayé de franciser Hawkpass pour pouvoir le fournir à mes utilisateurs mais j'ai abandonné faute de temps.

https://www.petroskal.com/hawkpass/
# Diceware

Posté par Michaël (site web personnel) le 20 janvier 2018 à 13:25. Évalué à 10.

Il y a aussi la méthode Diceware qui propose de le faire avec des dés (des vrais dés!). Des listes de mots pour cette méthode existent dans plusieurs langues et Matthieu Weber a compilé une liste en français.
- [^] # Re: Diceware
  
  Posté par Ozz le 20 janvier 2018 à 15:10. Évalué à 3.
  
  Et il y a des listes alternatives ici: https://github.com/mbelivo/diceware-wordlists-fr
# et aussi XKPasswd

Posté par ZeroHeure (site web personnel) le 20 janvier 2018 à 13:37. Évalué à 3.

il y a encore le site XKPasswd basé sur le module perl xkpasswd.pm qui marche en plusieurs langues.

"La liberté est à l'homme ce que les ailes sont à l'oiseau" Jean-Pierre Rosnay
# 300^4 = 8100000000

Posté par Colin Pitrat (site web personnel) le 20 janvier 2018 à 14:26. Évalué à 6.

Le nombre de combinaisons est un peu faible pour que ce soit un bon générateur. Et mélanger le dictionnaire avec le code (et la présentation …) rend difficile l'utilisation d'un dictionnaire différent.
- [^] # Re: 300^4 = 8100000000
  
  Posté par Ozz le 20 janvier 2018 à 15:29. Évalué à 4.
  
  C'est pire que ça, ça tire 3 mots parmi 162 et en plus les mots sont réparti dans 6 catégories et les mots ne peuvent pas venir deux fois d'une même catégorie, ce qui réduit encore l'entropie. Je pense que ça fait des mots de passe extrêmement faible, on est très loin des 4 mots aléatoires parmi 2048 de xkcd.
  - [^] # Re: 300^4 = 8100000000
    
    Posté par Vincent Meurisse (site web personnel) le 20 janvier 2018 à 17:13. Évalué à 10.
    
    Pour calculer l’entropie (la sécurité) d'un mot de passe, on considère que l’attaquant connaît l’algorithme. Ensuite on calcule le nombre de chance de tomber sur un mot de passe donné.
    
    Ici le programme commence par choisir 3 catégories parmi les 6.
    Le nombre de mots dans chaque catégories est de 19, 43, 28, 28, 31, 13.
    Il y a donc 1 chance sur 10 ((6 * 5 * 4) / (1 * 2 * 3) * 2) de tomber sur les 3 catégories avec le moins de mots.
    
    Ensuite on compte le nombre de combinaisons de mots parmi ces catégories: 13 * 19 * 28.
    
    Au final on tombe sur 10 * 13 * 19 * 28 = 69160 soit 16.07 bits d’entropie ce qui est très très faible pour un mot de passe.
    
    Il faut moins d’une seconde pour le casser même si il est stocké de manière sécurisée. Un GPU peut tester plusieurs centaines de millier de mot de pas WPA par seconde. Si le mot de passe est en MD5, on atteint le milliard par seconde.
    
    Pour avoir un mot de passe sécurisé, il faut supprimer le système de catégories et utiliser vraiment beaucoup plus de mots. Par exemple avec 50000 mots on arrive à 46 bits d’entropie (50000 ^ 3). Sinon on peut aussi augmenter le nombre de mots du mot de passe généré: 4 mots dans une liste de 5000 donne 49bits.
    - [^] # Re: 300^4 = 8100000000
      
      Posté par SlowBrain (site web personnel) le 20 janvier 2018 à 23:26. Évalué à 9.
      
      Bon, j'ai un peu l'impression d'avoir juste fait ce qu'il ne fallait pas faire. Avec plein de fausses bonnes idée dedans.
      
      Je savais que le dictionnaire n'était clairement pas assez grand. Ce à quoi s'ajoute la mauvaise idée de le diviser.
      
      Je ne suis ni développeur, ni cryptographe. Je voulais juste faire partager une idée.
      Elle semble tout du moins avoir apporté des commentaires intéressant.
      - [^] # Re: 300^4 = 8100000000
        
        Posté par Faya le 21 janvier 2018 à 15:51. Évalué à 1.
        
        Je n'y connais rien donc dites moi si je me trompe svp…
        
        Le 1er commentaire du journal parle de https://www.petroskal.com/hawkpass/ et il me semble qu'ils utilisent la méthode des catégories pour obtenir des phrases plus faciles à retenir. Toutes les propositions sont de la forme AdjectifNomVerbeAdjectifNom :
        
        MistyBagCoordinatedFrankPatient
        
        Il n'y a donc que 3 catégories, mais 5 mots choisis. Si chacune d'entre elle est suffisament grande, ça pourrait pas fonctionner ? Du style
        
        GentilParpaingCaresseFougeuxTracteur
        
        143 adjectifs
        1977 verbes (tirés de https://leconjugueur.lefigaro.fr/frlistedeverbe.php, merci Vim pour le nettoyage)
        304 noms (merci à icefinger ci-dessous)
        
        Quelqu'un pour calculer l'entropie obtenue avec ces listes et cette méthode ? Je ne veux pas me ridiculiser en le faisant (mal) moi-même…
        
        [^] # Re: 300^4 = 8100000000
        
        Posté par kantien le 21 janvier 2018 à 16:10. Évalué à 4.
        
        L'entropie est de l'ordre de 40 bits.
        
        143 ~ 2^7, 1977 ~ 2^11 et 304 ~ 2^8, d'où un couple adjectif+nom donne une entropie de l'ordre de 15 (=7 + 8) bits, deux tels couples donnent une entropie de 30, plus les 11 pour le verbe, on arrive aux alentours de 40 (du même ordre que dans le xkcd : 4 parmi 2^11 possibilités soit 4 * 11 = 44 bits d'entropie).
        
        Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.
        
        [^] # Re: 300^4 = 8100000000
        
        Posté par Faya le 21 janvier 2018 à 17:19. Évalué à 3.
        
        Merci.
        
        D'après https://en.wikipedia.org/wiki/Password_strength#Required_bits_of_entropy : 29 bits of entropy needed if only online attacks are expected, and up to 128 bits of entropy needed for important cryptographic keys.
        Du coup ça pourrait être suffisament sécurisé pour des mots de passe sur le web. @SlowBrain ton programme n'est pas à jeter. Charge des listes plus grosses, depuis une URL possible à modifier, et change l'utilisation des catégories et c'est bon \ô/
        
        [^] # Re: 300^4 = 8100000000
        
        Posté par kantien le 21 janvier 2018 à 21:09. Évalué à 4.
        
        Merci.
        
        De rien. La prochaine fois que tu veux calculer une entropie de mot passe, si tu n'as pas en tête les puissances de 2, tu sors ton python et tu fais :
        
        >>> import math >>> math.log(143 * 304 * 1977 * 143 * 304, 2) 41.76469485617316
        
        voilà, l'entropie avec tes listes est de 41.76. ;-)
        
        Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.
      - [^] # Re: 300^4 = 8100000000
        
        Posté par Yves Bourguignon le 21 janvier 2018 à 22:10. Évalué à 9.
        
        L'erreur c'est surtout d'avoir entré les mots manuellement avec plein de fautes plutôt que de les importer d'une liste ou d'un dictionnaire. J'ai peur de ne pas me rappeler du mot de passe généré : "Penthère-Beterave-Comercial"…
        
        [^] # Re: 300^4 = 8100000000
        
        Posté par ylsul le 22 janvier 2018 à 10:28. Évalué à 9.
        
        C'est une protection contre les attaques par dictionnaire.
        
        [^] # Re: 300^4 = 8100000000
        
        Posté par Larry Cow le 22 janvier 2018 à 11:54. Évalué à 10.
        
        Mais en échange, c'est vulnérable aux attaques par dixionère.
- [^] # très exactement 2'190'756
  
  Posté par steph1978 le 25 janvier 2018 à 15:43. Évalué à 2. Dernière modification le 25 janvier 2018 à 15:47.
```
In [1]: cards = [ 19, 43, 28, 28, 31, 13 ]

In [2]: from itertools import permutations
   ...: from functools import reduce
   ...: from operator import mul
   ...: 

In [3]: sum([ reduce(mul, x, 1) for x in permutations(cards, 3) ])
Out[3]: 2190756
```
# Dictionnaire

Posté par icefinger le 20 janvier 2018 à 15:06. Évalué à 5.

Pourquoi ne pas utiliser un dictionnaire externe de ce genre:
http://www.lexique.org/listes/liste_mots.txt
En plus avec l’occurrence ça permet d'éviter d'utiliser des mots rares et inconnus.
- [^] # Re: Dictionnaire
  
  Posté par Wrap le 21 janvier 2018 à 19:40. Évalué à 3.
  
  Je me suis amusé avec la liste au format xlsx pour créer ce fichier pour hawkpass :https://www.zerobin.net/?a07f4fb317971413#ppu+zs/JbHTxA5NdQ1C/XdoyeKiKttxqk/fzw8PCnOA=
  
  Ça génère des mot de passe sympa. par exemple:
  HydraulicienAutogèneIncinèreChiendentMotorisé
  RobinStudieuxPomponneToutouRonflant
  BullPolyvinyliqueDisciplinaitCentonBlafard
  
  Je suis fan.
  - [^] # Re: Dictionnaire
    
    Posté par steph1978 le 25 janvier 2018 à 16:08. Évalué à 3.
    Si j'ai bien compris ta liste et l'article :
```
diceware : 7776 ; 7776 ^ 5 = 2,8E19

adjective : 12617
noun : 12088
verb : 15520
article : 9
phrase : 12617 * 12088 * 15520 * 12617 * 12088 = 3,6E020
```
    - [^] # Re: Dictionnaire
      
      Posté par Wrap le 25 janvier 2018 à 22:45. Évalué à 1. Dernière modification le 25 janvier 2018 à 22:46.
      
      Pour ce qui est de ma liste, tu as bien compris. J'ai dû inverser "adjective" et "noun" pour obtenir une phrase qui ressemble a quelque chose en français.
      
      Du coup pour le calcul, je pense que c'est ça.
      
      Par contre la liste http://www.lexique.org/listes/liste_mots.txt contient pas mal de mot anglais. Pour bien faire, il faudrait utiliser l'indicateur d'occurrence pour garder seulement les mots français mais la liste est plûtot bien fourni et travailler le fichier excel avec libreoffice sur mon PC était difficile mon CPU (un i5-2500K) avait du mal à suivre.
# Le mien

Posté par Ozz le 20 janvier 2018 à 18:13. Évalué à 6. Dernière modification le 20 janvier 2018 à 18:14.

J'en profite pour montrer mon générateur de mot de passe, parce que les 3 millions d'autres ne suffisaient pas: https://pacific-sea-76848.herokuapp.com

C'est une application gadget/demo pas finie que j'avais préparée pour démontrer le style de mot de passes générés avec mes listes de mots.

Le source est là: https://github.com/mbelivo/nodiceware-web (yep, y a zéro documentation et c'est le bazar).
# mauvaise idée

Posté par bunam le 20 janvier 2018 à 22:37. Évalué à -5.

Il faut se méfier de type de conseil, ce XKCD a tout faux.
Les méchants ont déjà un dico avec tous les mots du coup il y à moins de coups à tester que du pur random. De plus ils connaissent les permutations que l'on peut trouver malines.

https://blog.dashlane.com/five-lessons-can-learn-15-million-password-mistakes/

Je n'utilise pas ce soft… mais je trouve leurs conseils pertinents

Un mot de passe bien chiant pour ouvrir une base 1Password, et j'ajoute de la complexité a ce mot de passe maitre régulièrement. Ensuite c'est du pur random pour chaque service, et aucun identique.
Quelques fois je tombe sur des sites qui ne veulent pas de mots de passe trop longs…
- [^] # Re: mauvaise idée
  
  Posté par Ozz le 20 janvier 2018 à 22:48. Évalué à 10.
  
  Je pense que tu n'as pas bien compris le XKCD, parce que justement il dit de ne pas faire de permutations malines, mais de tirer 4 mots purement aléatoirement dans une liste de mots communs (en l’occurrence dans une liste de 2048 mots pour avoir 44 bits d'entropie). Si tu veux avoir 60 bits d'entropie comme indiqué dans l'article, tu peux tirer 5 mots dans une liste de 4096 mots, l'idée reste la même et elle est valide.
  - [^] # Re: mauvaise idée
    
    Posté par flagos le 21 janvier 2018 à 09:13. Évalué à -10.
    
    Si tu sais que le mot de passe a été constitue de 5 mots parmi 4096 mots, ca ne fait que 5*4096 tirages avant de le retrouver, soit 24530 (~ 16 bits d'entropie) tirages possible.
    
    Au final, ce xkcd est une bonne méthode personnelle pour se souvenir ses mots de passe, mais pas une méthode systématisable via un algorithme, car elle réduit significativement l'aléatoire sur les mots utilises.
    - [^] # Re: mauvaise idée
      
      Posté par Ozz le 21 janvier 2018 à 10:19. Évalué à 10.
      
      Non, c'est 4096⁵ soit 60 bits d'entropie.
      
      Arrêtez d'essayer de contredire Randall Munroe, il est plus fort que vous.
      - [^] # Re: mauvaise idée
        
        Posté par Faya le 21 janvier 2018 à 22:35. Évalué à 6.
        
        Le plus drôle c'est qu'il avait prévu le coup. Le "title text" dit :
        
        "To anyone who understands information theory and security and is in an infuriating argument with someone who does not (possibly involving mixed case), I sincerely apologize."
    - [^] # Re: mauvaise idée
      
      Posté par wismerhill le 21 janvier 2018 à 10:21. Évalué à 10.
      
      Si tu sais que le mot de passe a été constitue de 5 mots parmi 4096 mots, ca ne fait que 5*4096 tirages avant de le retrouver, soit 24530 (~ 16 bits d'entropie) tirages possible.
      
      Non, ça fait 4096^5, ce qui donne bien 60 bits.
      
      Ton calcul ne serait correct que si on pouvait tester chaque mot individuellement, mais ce n'est pas le cas, ils sont concaténés pour former un mot de passe qui ne peut être testé que dans son intégralité, pas par morceaux.
- [^] # Re: mauvaise idée
  
  Posté par KiKouN le 20 janvier 2018 à 23:38. Évalué à 5.
  
  Les wallets de cryptomonnaies utilisent beaucoup une association de mots qui corresponds à une adresse. La suite de mots n'est pas de la même longueur que la clé mais ils ont la même entropie.
  
  L'avantage de cette suite de mots est quelle est bien plus facile à recopier et l'utilisation de mots permets d'ajouter une sorte de correction/détection d'erreur car les mots utilisés sont correct orthographiquement et doivent donc l'être aussi après copie, ce qui est très facile lorsque l'on parle la langue utilisée pour le dico de cette suite de mots.
  
  Un exemple :
  
  bovine logic cupcake onto eggs wetsuit vowels agony orders apart birth number wetsuit
  
  44uv2rwmQVNVmPZmrxRDQu6yUTuaBmX38geaAf1ceYTWjBVQjnazBPj39ZGqvFo5ZqFxXBs7mANuDBuBD4ta3im9Ac3dzwf
  
  Pour les mots de passe, l'avantage est que l'on peut décomplexifier un mot de passe avec tous les caractères recommandés en une suite de mots facilement identifiable pour l'homme.
  
  Pour les sites demandant de tel mots de passe, un tel procédé permet d'associer un mot de passe mémorisable et/ou difficile à recopier pour un humain en une suite de mots mémorisable et recopiable. Il faut toutefois l'application pour faire ce calcul.
  
  Je préféré toutefois un bon mot de passe immémorisable pour les sites sauf pour mon gestionnaire de mots de passe dont le mot de passe maître est stocké au chaud sous forme de mots. Les mots de passe que j'utilise pour y accéder tout les jours sont plus simple à mémoriser et à copier.
# coreutils / wfrench

Posté par symp le 27 janvier 2018 à 23:24. Évalué à 1.
Salut tout le monde,

Étant donné que:
```
> wc -l /usr/share/dict/french
139719 /usr/share/dict/french
```
que penser de quelque chose comme:
```
> shuf -n 5 /usr/share/dict/french
remuerais
préférerez
imiterons
inexperts
innocenteras
```
qui, pour pas cher, donnerait accès, sauf erreur, à environ 17 bits d'entropie par mot, soit aux alentours de 85 bits dans cet exemple?

# en 3 lignes de python

Posté par luxcem le 28 janvier 2018 à 12:48. Évalué à 1. Dernière modification le 28 janvier 2018 à 12:48.

    def xkcd_pass(lang="french"):
        words = [word.rstrip('\n') for word in open("/usr/share/dict/{}".format(lang))]
        return " ".join([random.choice(words) for _ in range(3)]).lower()

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.