|
```expression régulière
^(?=.*[a-zA-Z])(?=.*\d)(?=.*[!@#$%^&*(),.?":{}|<>\-_+=\\`~;']).{8,}$
```
Explication :
* `^` :correspond au début de la chaîne.
* `(?=.*[a-zA-Z])` :assertion d'anticipation positive qui nécessite au moins une lettre (a-z ou A-Z).
* `(?=.*\d)` :assertion d'anticipation positive qui nécessite au moins un chiffre (0-9).
* `(?=.*[!@#$%^&*(),.?":{}|<>\-_+=\\`~;'])` :assertion anticipée positive qui nécessite au moins un caractère spécial. C'est la partie critique, et vous devez ajuster les caractères entre crochets `[...]` pour qu'ils correspondent à l'ensemble exact de caractères spéciaux que vous souhaitez autoriser. Les barres obliques inverses `\` sont utilisées pour échapper aux caractères spéciaux dans la classe de caractères (par exemple, `\` et `-`). Assurez-vous d'échapper à tous les caractères ayant une signification particulière dans l'expression régulière. Si vous souhaitez autoriser un caractère spécial, cela devient plus difficile car de nombreux caractères ont une signification particulière dans l'expression régulière et vous devez y échapper.
* `.{8,}` :correspond à n'importe quel caractère (sauf la nouvelle ligne) au moins 8 fois. Cela garantit la longueur minimale.
* `$` :correspond à la fin de la chaîne.
Comment l'utiliser dans différents contextes :
* JavaScript :
```javascript
const passwordRegex =/^(?=.*[a-zA-Z])(?=.*\d)(?=.*[!@#$%^&*(),.?":{}|<>\-_+=\\`~;']).{8,}$/;
const mot de passe ="MonP@sswOrd123" ;
const isValid =passwordRegex.test(mot de passe);
console.log(isValid); // Sortie :vrai
const invalidPassword ="Short1!";
const isInvalid =passwordRegex.test(invalidPassword);
console.log(isInvalid); // Sortie :faux
```
* Python :
```python
importer re
password_regex =r"^(?=.*[a-zA-Z])(?=.*\d)(?=.*[!@#$%^&*(),.?\":{}|<>\-_+=\\`~;']).{8,}$"
mot de passe ="MonP@sswOrd123"
is_valid =re.match (password_regex, mot de passe)
print(bool(is_valid)) # Sortie :True
invalid_password ="Court1!"
is_invalid =re.match (password_regex, invalid_password)
print(bool(is_invalid)) # Sortie :False
```
* Java :
```java
importer java.util.regex.Matcher ;
importer java.util.regex.Pattern ;
classe publique Mot de passeValidator {
public static void main (String[] arguments) {
String passwordRegex ="^(?=.*[a-zA-Z])(?=.*\\d)(?=.*[!@#$%^&*(),.?\":{}|<>-_+=\\`~;']).{8,}$";
Mot de passe de chaîne ="MyP@sswOrd123" ;
Modèle de modèle =Pattern.compile (passwordRegex);
Matcher matcher =pattern.matcher(mot de passe);
System.out.println(matcher.matches()); // Sortie :vrai
Chaîne invalidPassword ="Short1!";
matcher =pattern.matcher(invalidPassword);
System.out.println(matcher.matches()); // Sortie :faux
}
}
```
Considérations importantes et personnalisation :
* Caractères spéciaux : La partie la plus critique consiste à définir les caractères spéciaux autorisés. La partie `[!@#$%^&*(),.?":{}|<>\-_+=\\`~;']` de l'expression régulière définit quels caractères sont considérés comme "spéciaux". Examinez attentivement et modifiez-la pour qu'elle corresponde à vos besoins spécifiques. N'oubliez pas d'échapper aux caractères regex spéciaux.
* Jeux de caractères :
* `[a-zA-Z]` :correspond à n'importe quelle lettre majuscule ou minuscule. Vous souhaiterez peut-être limiter cela aux lettres minuscules ou majuscules uniquement si nécessaire.
* `\d` :correspond à n'importe quel chiffre (0-9).
* Longueur minimale : La partie `{8,}` spécifie une longueur minimale de 8 caractères. Modifiez le « 8 » pour ajuster la longueur minimale. Si vous souhaitez également une longueur maximale, vous pouvez la spécifier comme ceci :`{8,16}` pour un minimum de 8 et un maximum de 16 caractères.
* Exigences de complexité : Vous pouvez ajouter des exigences plus complexes en ajoutant davantage d'assertions anticipées. Par exemple, vous pouvez exiger au moins deux chiffres avec `(?=.*\d.*?\d)`.
* Bonnes pratiques de sécurité : Bien que cette expression régulière impose un niveau de complexité de base, il est crucial de comprendre que l’expression régulière ne constitue pas à elle seule une solution de sécurité complète. Considérez ces bonnes pratiques :
* Sel et hachis : Ne stockez jamais les mots de passe en texte brut. Utilisez toujours un algorithme de hachage puissant (comme Argon2, bcrypt ou scrypt) avec un sel unique pour chaque mot de passe.
* Compteurs de force de mot de passe : Utilisez un outil de mesure de la force des mots de passe pour fournir des informations en temps réel aux utilisateurs lorsqu'ils saisissent leur mot de passe.
* Audits de sécurité réguliers : Examinez régulièrement vos politiques de mot de passe et vos pratiques de sécurité.
* Limitation du débit : Implémentez une limitation du débit sur les tentatives de connexion pour empêcher les attaques par force brute.
Exemple :Autoriser uniquement les caractères spéciaux suivants :`!@#$%^&*`
L'expression régulière deviendrait :
```expression régulière
^(?=.*[a-zA-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$
```
Exemple :Nécessite au moins deux chiffres :
```expression régulière
^(?=.*[a-zA-Z])(?=.*\d.*?\d)(?=.*[!@#$%^&*(),.?":{}|<>\-_+=\\`~;']).{8,}$
```
Cette version ajoute `(?=.*\d.*?\d)`, qui nécessite au moins deux chiffres, avec tous les caractères intermédiaires autorisés par `.*?`.
Choisissez l'expression régulière qui correspond le mieux à *votre* politique de mot de passe spécifique et n'oubliez pas de donner la priorité aux meilleures pratiques de sécurité. Testez toujours minutieusement l’expression régulière avec une variété de mots de passe valides et invalides.
|
