`` `Regex
^(? =.*[A-Za-Z]) (? =.*\ D) (? =.*[!@#$%^&*(),.? ":{} | <> \ -_+=\\` ~; ']). {8,} $
`` `
Förklaring:
* `^`:Matchar strängens början.
* `(? =.* [A-ZA-Z])`:Positiv lookahead-påstående som kräver minst en bokstav (A-Z eller A-Z).
* `(? =.* \ D)`:Positiv lookahead-påstående som kräver minst en siffra (0-9).
*`(? =.*[!@#$%^&*(),.?":{} | <> \ -_+=\\ `~; '])':Positiv lookahead-påstående som kräver åtminstone en specialkaraktär. Detta är den kritiska delen, och du bör anpassa karaktärerna inom torget som` [...] `till att matcha det exakta uppsättningen. Escape Special Characters inom karaktärsklassen (t.ex. `\` och `-') Se till att undkomma alla karaktärer som har speciella betydelser inom Regex.
* `. {8,}`:matchar alla tecken (utom NewLine) minst 8 gånger. Detta säkerställer minsta längd.
* `$`:Matchar slutet på strängen.
Hur man använder det i olika sammanhang:
* javascript:
`` `JavaScript
const-lösenordRegex =/^(?=.*HITAA-ZA-Z Vrejs)(?=.* \D)(?=.* ChapT!@#$%^&*(), .?":ausimering
const -lösenord ="MYP@ssword123";
const isValId =PasswordRegex.Test (lösenord);
console.log (isValid); // utgång:sant
const InvalidPassword ="Short1!";
const isInValId =PasswordRegEx.Test (InvalidPassword);
console.log (isinValid); // output:falsk
`` `
* python:
`` `python
importera
Password_Regex =r "^(? =.*[A-Za-Z]) (? =.*\ D) (? =.*[!@#$%^&*(),.? \":{} | <> \ -_+=\\ `~; ']). {8,} $" "
lösenord ="MYP@ssword123"
is_valid =re.match (lösenord_regex, lösenord)
tryck (bool (is_valid)) # utgång:true
Invalid_password ="Short1!"
is_invalid =re.match (lösenord_regex, ogiltig_password)
tryck (bool (is_invalid)) # utgång:falsk
`` `
* java:
`` `Java
import java.util.regex.matcher;
import java.util.regex.pattern;
public class PasswordValidator {
public static void main (String [] args) {
String PasswordRegex ="^(? =.*[A-Za-Z]) (? =.*\\ D) (? =.*[!@#$%^&*(),.? \":{} | <> -_+=\\ `~; ']). {8,} $";
String Password ="MYP@SSWORD123";
Mönstermönster =mönster.Compile (lösenordRegex);
Matcher matcher =mönster.matcher (lösenord);
System.out.println (matcher.Matches ()); // utgång:sant
String InvalidPassword ="Short1!";
matcher =mönster.Matcher (InvalidPassword);
System.out.println (matcher.Matches ()); // output:falsk
}
}
`` `
Viktiga överväganden och anpassning:
* Specialtecken: Den mest kritiska delen är att definiera de tillåtna specialtecken. `[!@#$%^&*() ,.?":{} | <> \ -_+=\\ `~; ']" En del av regexen definierar vilka karaktärer som anses "speciella". Undersök noggrant och ändra detta för att matcha dina specifika krav. Kom ihåg att undkomma specialregexkaraktärer.
* Teckenuppsättningar:
* `[A-ZA-Z]`:matchar alla versaler eller små bokstäver. Du kanske vill begränsa detta till endast små bokstäver eller endast stora bokstäver om det behövs.
* `\ D`:Matchar alla siffror (0-9).
* Minsta längd: Delen `{8,}` anger en lägsta längd på 8 tecken. Ändra "8" för att justera minsta längd. Om du också vill ha en maximal längd kan du ange den så här:`{8,16}` för minst 8 och högst 16 tecken.
* Komplexitetskrav: Du kan lägga till mer komplexitetskrav genom att lägga till fler lookahead -påståenden. Till exempel kan du kräva minst två siffror med `(? =.*\ D.*? \ D)`.
* Säkerhet bästa metoder: Även om denna regex verkställer en grundläggande komplexitetsnivå, är det avgörande att förstå att regex ensam inte är en komplett säkerhetslösning. Tänk på dessa bästa metoder:
* Salt och hash: Förvara aldrig lösenord i vanlig text. Använd alltid en stark hashingalgoritm (som Argon2, Bcrypt eller Scrypt) med ett unikt salt för varje lösenord.
* Mätare av lösenordsstyrka: Använd en lösenordsstyrka mätare för att ge feedback i realtid till användare när de skriver lösenordet.
* Regelbundna säkerhetsrevisioner: Granska regelbundet dina lösenordspolicyer och säkerhetsmetoder.
* Ratsbegränsning: Implementera hastighetsbegränsning på inloggningsförsök att förhindra brute-force-attacker.
Exempel:Tillåter endast följande specialtecken:`!@#$%^&*`
Regex skulle bli:
`` `Regex
^(? =.*[A-ZA-Z]) (? =.*\ D) (? =.*[!@#$%^&*]). {8,} $
`` `
Exempel:kräver minst två siffror:
`` `Regex
^(? =.*[A-Za-Z]) (? =.*\ D.*? \ D) (? =.*[!@#$%^&*(),.? ":{} | <> \ -_+=\\` ~; ']). {8,} $
`` `
Denna version lägger till `(? =.*\ D.*? \ D)`, som kräver minst två siffror, med några tecken mellan tillåtet av '.*?'.
Välj den regex som bäst passar * din * specifika lösenordspolicy och kom ihåg att prioritera bästa praxis för säkerhet. Testa alltid regex noggrant med en mängd giltiga och ogiltiga lösenord.
