Discussion :

[steph68b]

Hello,

J'ai énormément de mal avec les regex, ça ne rentre pas dans ma logique (ou vice versa!), je n'y arrive pas, je n'arrive à rien en fait!

Quelqu'un pourrait-il me monter une regex permettant de tester le format d'un mot de passe correspondant aux critères suivant:
-> 6 caractères minimum (max = 10, pense suffisant non? d'autant plus que je vais aussi rajouter un salt, avant cryptage SHA512)
-> au moins 1 chiffre
-> au moins 1 majuscule
-> au moins un caractère spécial
(avec les annotations pour comprendre)

Expression que je pourrais ensuite coller dans une fonction renvoyant true/false.

Question subsidiaire: mes critères de password sont-ils assez bons pour vous, ou comment feriez-vous, vous?

Merci.

[SpaceFrog]

pour moi ce n'est pas possible en une seule reg ...

[steph68b]

pas de solution alors?

[steph68b]

cela dit, s'il faut faire 4 tests imbriqués dans des if(...) else if(...) moi ça me va aussi, pas de souci.

Le tout étant de trouver les 4 règles des 4 test:

1.) pour les chiffres on aurait un truc du genre

Code :

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

1
2
reg = /[0-9]/; 
reg.exec(document.inscription.Passwd.value)

-> tu confirmes?


2.) pour les lettres maj/min on aurait un truc du genre

Code :

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

1
2
reg = /[a-zA-Z]/; 
reg.exec(document.inscription.Passwd.value)

-> tu confirmes?


3.) nb car min(6)/max(10)?
4.) la présence de caractères spéciaux?
-> formule générique possible?
OU
-> indique 1 par 1 ceux que l'on souhaite voir utilisé?

[Gnuum]

Mais si, mais si voyons! Tout est possible en RegExp!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
function isValidPassword(password) {
    var charactersTypes = [
            '[A-Z]', // lettre majuscule
            '[0-9]', // chiffre
            '[^\\w]' // caractère non alphanumérique
        ]
    ;
 
    // On fabrique les différences séquences possible: chiffre-majuscule-caractère spécial, majuscule-caractère spécial-chiffre, ... (il y en a 6).
    var possibleSequences = [];
 
    for (var i = 0; i < charactersTypes.length; i++) {
        var possibleSequence = [charactersTypes[i]];
 
        for (var j = 0; j < charactersTypes.length; j++) {
            if (i === j) {
                continue;
            }
 
            possibleSequence.push(charactersTypes[j]);
        }
 
        possibleSequences.push(possibleSequence);
 
        var possibleSequence = [charactersTypes[i]];
 
        for (var j = charactersTypes.length - 1; j >= 0 ; j--) {
            if (i === j) {
                continue;
            }
 
            possibleSequence.push(charactersTypes[j]);
        }
 
        possibleSequences.push(possibleSequence);
    }
 
    // On crée une liste de pattern d'expression régulière vérifiant les différentes séquences.
    var patterns = [];
 
    for (var i = 0; i < possibleSequences.length; i++) {
        var possibleSequence = possibleSequences[i];
 
        // En ES6 (avec les "Littéraux de gabarits" cela donne:
        // + veut dire au moins 1
        // .* entre les différents caractères veut dire n'importe quel caractère 0 ou n fois.
        patterns.push(
            `${possibleSequence[0]}+.*${possibleSequence[1]}+.*${possibleSequence[2]}+`
        );
    }
 
    // On concatène les différentes séquence dans une seule et même expression régulière.
    // | veut dire "ou", ce qui veut dire qu'on va vérifier que le mot de passe vérifie une des séquences.
    var passwordCheck = new RegExp(patterns.join('|'));
 
    // Teste le mot de passe et renvoie true si il match, false sinon.
    return passwordCheck.test(password)
}
 
 
console.log(isValidPassword('abcde'));       // false
console.log(isValidPassword('abCde0'));      // false
console.log(isValidPassword('abCd@e'));      // false
console.log(isValidPassword('ab5de#0'));     // false
console.log(isValidPassword('abC@de0'));     // true
console.log(isValidPassword('a@bezC0ceaz')); // true

La manière programmatique, c'est pour comprendre ce qu'il se passe (l'algorithme peut certainement être bien amélioré!). En abrégé, ça donne:

Code :

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

1
2
3
function isValidPassword(password) {
    return /[A-Z]+.*[0-9]+.*[^\w]+|[A-Z]+.*[^\w]+.*[0-9]+|[0-9]+.*[A-Z]+.*[^\w]+|[0-9]+.*[^\w]+.*[A-Z]+|[^\w]+.*[A-Z]+.*[0-9]+|[^\w]+.*[0-9]+.*[A-Z]+/.test(password);
}

Après c'est surtout pour la beauté du geste. Pour un soucis de compréhension (et certainement de performance), je le ferais en plusieurs expressions régulières.

PS: je ne limiterais pas la taille maximale (en tout cas pas à 10).
PS2: j'ai triché, je n'ai pas vérifié la taille globale du password dans ma regexp (password.length >= 6).

[steph68b]

J'allais poster que j'avais trouvé un début de piste avec mon

Code :

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

var reg = /[a-z]+[A-Z]+[0-9]+/g;

.......... sauf qu'évidement, de cette manière là un mot débutant avec 1 maj/chiffre renverra false, même si tous les critères sont là......... mais pas dans le bon ordre!!

Je cherchais donc comment caser un 'ou' dans ma regexp............

MAIS à voir ta réponse, j'étais encore TRES loin du compte!!
Et j'en étais donc arrivé à vouloir faire une analyse syntaxique manuelle à la place!

Je vais jeter un oeil sur ton code, pour essayer de comprendre, merci.