Discussion :

[ppzmr]

bonjour,
j'ecris en C# un programme qui doit vérifier le respect de certaines règles sur la "syntaxe" de mot de passe

je voudrais savoir s'il peut y avoir une expression régulière pour vérifier si un mot de passe est composé de 2 majuscules, 2 minuscules, 2 chiffres et 2 caractères spéciaux et cela dans n'importe quel sens ex :"RtTv19%ù". Ce mot de passe étant sur 8 caractères exactement.

Merci d'avance

[Matthieu MEZIL]

A part faire une expression régulière avec toutes les combinaisons () je ne vois pas.

[ppzmr]

tu pourrais me donner un exemple ?

[scifire]

Voila une fonction qui fais ce que tu veux mais je sais pas ce que tu entends par caracteres speciaux. Le regexp pour ces caracteres reste pour toi

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
        public static bool IsPasswordValid(string password)
        {
            if (password.Length == 8)
            {
                Regex majuscules = new Regex("([A-Z])");
                Regex miniscules = new Regex("([a-z])");
                Regex chiffres = new Regex("([0-9])");
                Regex specials = new Regex("([#~%*])");
 
                return majuscules.Matches(password).Count == 2 &&
                    miniscules.Matches(password).Count == 2 &&
                    chiffres.Matches(password).Count == 2 &&
                    specials.Matches(password).Count == 2;
 
            }
            return false;
        }

A+

[scifire]

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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
using System;
using System.Collections.Generic;
using System.Text;
 
namespace Utils
{
    class PasswordValidator
    {
        /// <summary>
        /// The specials array must be declared in sorted order
        /// </summary>
        internal static readonly char[] specials = { '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`', '|', '~' };
 
        /// <summary>
        /// Every character type must be in the password exactly 2 times.
        /// </summary>
        /// <param name="password"></param>
        /// <param name="requiredLenght"></param>
        /// <returns></returns>
        public static bool IsPasswordValid(string password, int requiredLenght)
        {
            return IsPasswordValid(password, requiredLenght, 2, 2, 2, 2);
        }
 
        public static bool IsPasswordValid(string password, int requiredLenght, int lower, int upper, int digits, int specials)
        {
            if (password.Length == requiredLenght)
            {
                return CheckLower(password, lower) &&
                        CheckUpper(password, upper) &&
                        CheckDigits(password, digits) &&
                        CheckSpecials(password, specials);
            }
            return false;
        }
 
        /// <summary>
        /// Check for requiredLenght special characters
        /// </summary>
        /// <param name="password"></param>
        /// <param name="requiredLenght"></param>
        /// <returns></returns>
        public static bool CheckSpecials(string password, int requiredLenght)
        {
            int count = 0;
            foreach (char c in specials)
            {
                if (Array.BinarySearch(specials, c) >= 0)
                {
                    count++;
                }
                if (count == requiredLenght)
                {
                    return true;
                }
            }
            return false;
        }
 
        /// <summary>
        /// Check for requiredLenght letters in upper case
        /// </summary>
        /// <param name="password"></param>
        /// <param name="requiredLenght"></param>
        /// <returns></returns>
        public static bool CheckUpper(string password, int requiredLenght)
        {
            int count = 0;
            foreach (char c in password)
            {
                if (c >= 'A' && c <= 'Z')
                {
                    count++;
                }
                if (count == requiredLenght)
                {
                    return true;
                }
            }
            return false;
        }
 
        /// <summary>
        /// Check for requiredLenght letters in lower case
        /// </summary>
        /// <param name="password"></param>
        /// <param name="requiredLenght"></param>
        /// <returns></returns>
        public static bool CheckLower(string password, int requiredLenght)
        {
            int count = 0;
            foreach (char c in password)
            {
                if (c >= 'a' && c <= 'z')
                {
                    count++;
                }
                if (count == requiredLenght)
                {
                    return true;
                }
            }
            return false;
        }
 
        /// <summary>
        /// Check for requiredLenght digits
        /// </summary>
        /// <param name="password"></param>
        /// <param name="requiredLenght"></param>
        /// <returns></returns>
        public static bool CheckDigits(string password, int requiredLenght)
        {
            int count = 0;
            foreach (char c in password)
            {
                if (c >= '0' && c <= '9')
                {
                    count++;
                }
                if (count == requiredLenght)
                {
                    return true;
                }
            }
            return false;
        }
    }
}

[scifire]

Je te propose cette classe car j'aime bien les solutions plus performantes. Cette methode est 20 plus rapide que la methode qui utilise des expressions reguilieres. De plus elle est plus souple - on peut specifier le nombre de chaque type de caracteres et la longeur du mot de passe

A+