Regex mot de passe bug pour nombre caractère supérieur a 1

**Math71** · 30/07/2018, 13h35

Bonjour,

J'ai une regex qui vérifie la conformité du mot de passe saisie par l'utilisateur.

Elle fonctionne dans presque tous les cas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^(?=.{1,}[a-z])(?=.{2,}[A-Z])(?=.{1,}[0-9])(?=.{1,}[&#@=€$%*?\/:!\-+])([a-zA-Z0-9&#@=€$%*?\/:!\-+]){8,}$

MdpS100! passe
Mdps100! ne passe pas
mdpS100! passe et c'est la le problème, il y a qu'une seule majuscule.

Je ne comprends vraiment pas pourquoi.

Si vous avez des idées.

Invité · 30/07/2018, 14h23

Bonjour,

À lire :

Quelles sont les règles à suivre pour concevoir un bon système d'authentification ?

(extrait)

5.Ne pas bloquer les mots de passe longs et complexes

En aout 2017, l’ingénieur du NIST, Bill Burr, qui avait recommandé l’adoption des mots de passe difficiles à retenir (composés d’une une série combinée de chiffres, lettres majuscules et minuscules et de caractères spéciaux) a ouvertement reconnu qu’il regrettait d’avoir avancé ce conseil, car dans la pratique, cela créait plus d’inconvénients aux utilisateurs que cela ne les protégeait.

Le NIST qui a repris les travaux de Bill Burr recommande désormais de composer des mots de passe avec des phrases longues et faciles à retenir au lieu de mots de passe courts et difficiles à retenir.

**YCL-1** · 30/07/2018, 14h24

Bonjour,

vous devriez tester séparément chaque condition ce sera beaucoup plus simple à comprendre d'où provient l'erreur.

Il y a quelques sites pratiques en ligne qui permettent de tester dynamiquement une expression régulière :

avec de la doc disponible

https://www.regexpal.com/

https://regex101.com/

ou avec Notepad++ par exemple en faisant une recherche de texte regex sensible à la casse.

Car la première condition est mal formée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

.{1,}[a-z]

Les accolades permettent de définir une longueur fixe {longueur} ou longueur minimale/maximale {min, max} sur l'élément passé avant, ici c'est le point, alors que je suppose vous souhaitez tester la longueur sur les caractères [a-z].

Ça serait plutôt ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[a-z]{1,}

**Math71** · 30/07/2018, 14h41

Je sais que les mots de passe composés comme ceci, ne sont pas les meilleurs.
Mais c'est le politique de gestion utilisée, ou je n'ai pas la main dessus.
Mais merci pour l'information.

YCL-1 :

J'ai changé mon expression mais je rencontre encore des problèmes :

^(?=[a-z]{1,})(?=[A-Z]{2,})(?=[0-9]{1,})(?=[&#@=€$%*?\/:!\-+]{1,})([a-zA-Z0-9&#@=€$%*?\/:!\-+]){8,}$

MdpS100! ne passe pas (pas normal)
mdpS100! passe (pas normal)
MDps100! ne passe pas (pas normal)
Mdps100! passe (pas normal)
mdps100! passe (pas normal)
mdPS100! ne passe pas (pas normal)

En changeant comme vous le l'avez dit, le fonctionnement n'est plus du tout bon.
Je test avec regex101.com

Peut ètre que je n'ai pas compris ce que vous m'avez dit.

**YCL-1** · 30/07/2018, 15h15

Je viens de tomber sur un site qui donne la solution en fait il faut avoir une approche différente :

https://dzone.com/articles/use-regex-test-password

La syntaxe (?=term) Positive Lookahead
permet de regarder avant la terme à rechercher, c'est utilisé pour l'extraction de balise par exemple.

mais on peut l'utiliser pour vérifier qu'il contient un terme sans l'extraire et peu importe l'ordre,
ça va sortir uniquement les lignes qui vérifie cette condition.

Ça se présente de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=.*[a-z])

Tous les caractères .* doivent contenir au moins un caractère a-z

On fait de même pour chaque cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])

puis on rajoute au moins un caractère spécial :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=.*[!@#\$%\^&\*])

Ensuite on vérifie la longueur minimale de chaque ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=.{8,})

Puis on rajoute ^ pour vérifier toutes les conditions en début de ligne, le résultat donne ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,})

Et pour sélectionner l'ensemble jusqu'à la fin de ligne il suffit de rajouter .*$

ça donne ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,}).*$

Voici une liste à tester, une ligne sur deux est correcte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
MdpS100!
mdpS1000
MDps100!
mdps100!
mdPS100!
MdS100!
!MdS104560!
mdps100!
mdPS100!
1234567!

**Loceka** · 30/07/2018, 15h21

Autant je suis un fervent utilisateur des regex, autant là elle n'a pas lieu d'être.

Les règles sont trop complexes pour être testées en une seule regex. Il faut faire plusieurs tests (plusieurs regex) pour répondre au besoin.

Mais sinon je rejoins jreaux62 : c'est une très mauvaise politique de mot de passe.
Personnellement j'en ai ras la casquette des mdp qui demandent à la fois des majuscules, des minuscules, des chiffres et des caractères spéciaux.

Le mieux pour tout le monde serait plutôt que tu fasses valoir ton devoir de conseil en tant que professionnel de l'informatique et que tu fasses comprendre aux décideurs que ces règles sont débiles.

**Math71** · 30/07/2018, 15h21

Merci pour les explications.

Ca marche si les caractères doivent être présent au moins 1 fois.

Etant donné que pour mon cas, les majuscules doivent être présentes au moins 2 fois. Pour les autres types de caractères c'est pareil, ça peut être variable.

Et seulement une liste de caractères spéciaux sont autorisés. d'ou cette condition :

([a-zA-Z0-9&#@=€$%*?\/:!\-+])

Avez vous une idée de comment faire ?

EDIT : si seulement j'avais un droit de conseil.... La joie de l'alternance.... Qu'il y a 12 entreprises à convaincre, qu'ils ne savent pas ou ils vont....
Après les différentes types de caractères et nombre de caractères sont paramétrables. Donc je pourrais jouer la dessus.

**grunk** · 30/07/2018, 15h31

Essaye de penser lisibilité du code

Perso quand j'ouvre un code dont je suis pas à l'origine et que je tombe sur une regex à coucher dehors je pleur pendant un petit moment.
C'est peut être parce que j'en fait pas souvent , mais je trouve ça pénible à lire et c'est pour moi source d'erreur.

Parfois 2 ou 3 tests imbriqués , compréhensibles par tous et lisible de façon fluide valent mieux qu'une regex imbitable (même si elle fait cool dans le code

)

**Math71** · 30/07/2018, 15h34

Elle est lisible étant donné que je l'a créé en fonction des données récupérées d'un WebService.

Donc chaque condition est dans un test différent.

J'utilise la regex pour faire la validation coté client, avec JQuery validator qui demande une regex.

Donc ça me simplifie le code, surtout que je l'utilise très souvent.

**tsuji** · 30/07/2018, 15h55

mdpS100! passe et c'est la le problème, il y a qu'une seule majuscule.

Et pourquoi pas. Ce groupe
(?=.{2,}[A-Z])
ne dit pas qu'il devrait y avoir deux majuscules; il dit avant une majuscule il faut avoir quelques caractères, deux au moins et c'est tout.

C'est symptomatique de se plaindre "il y a qu'une seule majuscule" pour ce groupe de (?=.{2,}[A-Z]). Si c'est l'intention pour ce groupe et même esprit pour les autres, on doit faire ça.

(?=(.*[a-z])+)
(?=(.*[A-Z]){2,})
(?=(.*[0-9])+)
(?=(.*[&#@=€$%*?\/:!\-+])+)

donc

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$pattern='/^(?=(.*[a-z])+)(?=(.*[A-Z]){2,})(?=(.*[0-9])+)(?=(.*[&#@=€$%*?\/:!\-+])+)([a-zA-Z0-9&#@=€$%*?\/:!\-+]){8,}$/';

**Math71** · 30/07/2018, 16h01

C'est bien ce qu'il me semblait que je n'avais pas tout compris avec la regex..
Merci pour l'info

du coup j'ai ça :

Je précise que n'utilise pas "+" à la place de {1,} car c'est paramétrable.

^(?=.*[a-z]{1,})(?=.*[A-Z]{2,})(?=.*[0-9]{1,})(?=.*[&#@=€$%*?\/:!\-+]{1,})([a-zA-Z0-9&#@=€$%*?\/:!\-+]){8,}$

Le problème est presque résolu. Il a juste ce cas qui pose problème : MdpS100! qui ne passe pas alors qu'il devrait être valide.

Si je comprends bien, la regex autorise seulement 2 majuscules collé, alors que je souhaiterai qu'elle ne le soit pas forcément.

EDIT : mea culpa, j'avais oublié les parenthèses.

voici la bonne regex :

^(?=(.*[a-z]){1,})(?=(.*[A-Z]){2,})(?=(.*[0-9]){1,})(?=(.*[&#@=€$%*?\/:!\-+]){1,})([a-zA-Z0-9&#@=€$%*?\/:!\-+]){8,}$

Invité · 30/07/2018, 16h01

Bien joué, tsuji

Il fallait trouver la bonne syntaxe pour :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=(.*[A-Z]){2,})

Il faut positionner correctement les parenthèses et accolades.

@Math71
Tu as justement oublié les parenthèses, importantes ici.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=(.*[A-Z]){2,})

est différent de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(?=.*[A-Z]{2,})

(?=.*[A-Z]{2,}) : les 2 majuscules doivent se suivre.

**Loceka** · 30/07/2018, 16h05

Envoyé par Math71

Avez vous une idée de comment faire ?

Comme j'ai dit : oui, le faire en plusieurs regex.

Une pour les majuscules : (?:.*?[A-Z]){2,}, une pour les minuscules : (?:.*?[a-z]){2,}, une pour les caractères spéciaux : (?:.*?[...]){2,}.

D'ailleurs de cette façon tu peux aisément activer/désactiver les contraintes en mettant les conditions à tester dans une liste et en disant le nombre de conditions validées :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
List conditions = [majuscules, minuscules, charSpec];
int nbMatch = 0;
for (condition in conditions) {
  if (mdp.matches(condition)) nbMatch++;
}
 
return (nbMatch == 3)

Comme ça tu peux facilement ajouter/retirer des conditions à tester et aussi facilement paramétrer le nombre de conditions qui doivent être respectées (par exemple si on veut que 2 conditions sur 3 soient respectées), le tout en n'utilisant que des regex super simples à relire.

**Math71** · 30/07/2018, 16h08

Il me faut une regex unique.

J'ai trouvé la bonne grace à votre aide a tous.

Ca ne marche pas pour les autres conditions, il me faut encore mieux regarder, surement une histoire de parenthèses.

Invité · 30/07/2018, 16h09

@Loceka

tsuji a donné la solution.
En une seule regex.

@Math71
Il suffit de copier-coller la regex de tsuji, puis de remplacer les + par {1,} :

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^(?=(.*[a-z]){1,})(?=(.*[A-Z]){2,})(?=(.*[0-9]){1,})(?=(.*[&#@=€$%*?\/:!\-+]){1,})([a-zA-Z0-9&#@=€$%*?\/:!\-+]){8,}$

**Loceka** · 30/07/2018, 16h15

Envoyé par jreaux62

@Loceka

Si tu avais suivi, tu aurais vu que tsuji a donné la solution.
En une seule regex.

J'ai suivi mais je trouve la solution que je propose bien plus modulaire et plus facile à lire/maintenir.

**YCL-1** · 30/07/2018, 16h29

Envoyé par grunk

Essaye de penser lisibilité du code

Perso quand j'ouvre un code dont je suis pas à l'origine et que je tombe sur une regex à coucher dehors je pleur pendant un petit moment.
C'est peut être parce que j'en fait pas souvent , mais je trouve ça pénible à lire et c'est pour moi source d'erreur.

Parfois 2 ou 3 tests imbriqués , compréhensibles par tous et lisible de façon fluide valent mieux qu'une regex imbitable (même si elle fait cool dans le code

)

Moi c'est pareil mais on peut tout aussi bien diviser l'expression en plusieurs lignes pour y glisser un commentaire c'est ensuite beaucoup plus simple à comprendre, puis fusionner l'expression comme un simple texte :

Exemple en Python, plutôt que d'écrire : (^#\s*)(\d{4}\/\d{2}\/\d{2})(\s*)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
search_pattern_date = re.compile(
    r"(^#\s*)"             + # group(1): "#   "
    r"(\d{4}/\d{2}/\d{2})" + # group(2): "2016/06/22"
    r"(\s*)"                 # group(3): " "
)

ou encore (du parsing de formule Excel !) :

**CosmoKnacki** · 31/07/2018, 00h38

Pour revenir sur la pattern de tsuji (qui marche), pas la peine de mettre un `+` dans un lookahead, étant donné qu'une seule occurrence suffit à la vérifier! Donc [c](?=(.*[a-z])+)|/c] est strictement équivalent à (?=.*[a-z]) (voire à (?=[^a-z]*[a-z]) si l'on veut éviter tout backtracking et profiter de l'auto-possessification de PCRE). Idem pour (?=(.*[0-9])+) et (?=(.*[&#@=€$%*?\/:!\-+])+).

À propos de cette dernière (?=(.*[&#@=€$%*?\/:!\-+])+): dans la mesure où cette classe de caractère contient un caractère (i.e. €) encodé sur trois octects (soit \xe2 \x82\xac), on ne peut pas écrire cette pattern sans spécifier le modificateur u qui permet de lire la chaîne en UTF-8. Sans quoi, les octets composant le caractère € peuvent être utilisés de manière individuel pour composer un mot de passe valide, exemple: aAB0\xe2ABC. Pis encore, le moteur de regex fonctionnant par défaut par octets, celui ci ne sera pas en mesure d'imposer un longueur précise dés lors que des caractères multibyte sont impliqués. Voir exemple.

Dernière chose, le piège de l'ancre $: celle-ci peut matcher deux positions (par défaut, sans le modificateur m), soit la fin de la chaîne, soit la fin d'une ligne si celle ci est suivie d'une nouvelle ligne (disons \n) et de la fin de la chaîne. Pour s'extraire de ce flou, deux solutions: soit on utilise \z pour signifier la fin de chaîne, soit on utilise le modifieur D qui impose à $ de ne matcher que la fin de la chaîne. (Selon ma théorie, la raison de ce veule comportement est du à des raisons pratiques héritées d'outils qui fonctionnent ligne par ligne, et dont le comportement ne doit pas changer quand bien même ils auraient à traiter la dernière ou une autre ligne).

En résumé, la pattern pourrait s'écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$pattern = '~^(?=.*[a-z])(?=(?:.*[A-Z]){2})(?=.*[0-9])(?=.*[-!-&*+/:=?€])[-a-zA-Z0-9!-&*+/:=?€]{8,}\z~u';

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$pattern = '~^(?=.*[a-z])(?=(?:.*[A-Z]){2})(?=.*[0-9])(?=.*[-!-&*+/:=?€])[-a-zA-Z0-9!-&*+/:=?€]{8,}$~Du';

Pour rejoindre ce qui à été dit précédemment, toutes ces contraintes sur les mots de passe sont d'un intérêt très limité, puisqu'au final, avec un minimum d'originalité, seule la longueur compte (qu'on se le dise), face à une attaque de type brut force. Pour s'en persuader, considérez l'exemple: "J0hn-Doe" qui pourrait très bien figurer dans un dictionnaire de mots de passe..

**Math71** · 31/07/2018, 09h14

Merci pour explication.

Juste un petit question, à quoi correspond "~" ? c'est le délimiteur de la regex ?

Je suis d'accord pour les mots de passe contenant une phrase. Mais ça veut dire qu'il faut aussi "éduquer" les utilisateurs, qui est assez complexe étant donné que ça peut être n'importe qui.

On ne peut pas bloquer les attaques par dictionnaire aussi, étant donné qu'a la création du compte, les données utilisateurs ne sont pas encore lié au compte.

Il y a aucune donnée personnelle, et ce n'est que de l'affichage donc je pense qu'on a pas encore besoin de revoir notre politique de mot de passe.

Après si vous pensez qu'il y a quand même un gros risque, j'essayerai de faire remonter l'information.

EDIT : La regex modifié fonctionne correctement même avec le "€", pas besoin de rajouter l'unicode. Est ce parce qu'en PHP et JS, C'est déja fait correctement ?

Invité · 31/07/2018, 09h46

Bonjour,

si tu dois ne retenir qu'une chose dans l'exposé de CosmoKnacki, c'est ça :

Envoyé par CosmoKnacki

...puisqu'au final, avec un minimum d'originalité, seule la longueur compte (qu'on se le dise), face à une attaque de type brut force....

(il parle de la longueur du mot de passe... évidemment )

Aujourd'hui, compte tenu de la puissance de calculs, 8 caractères sont insuffisants.

Comme le dit notre cher (très cher, trop cher) Président :

"C'est de la poudre de perlimpinpin !"

N.B. sinon, voici un article qui va bien avec ta regex (il date de 2009) : Vérifier la solidité d'un mot de passe en PHP
ATTENTION : Ne pas confondre "solidité" et "sécurité".

[...]– le mot de passe standard doit désormais faire douze caractères et utiliser non plus trois mais quatre types de caractères (majuscules, minuscules, chiffres et caractère spéciaux). [...]

Regex mot de passe bug pour nombre caractère supérieur a 1 [RegEx]

Langage PHP

Discussions similaires

Partager

Partager