^(? =.*[a-za-z]) (? =.*\ d) (? =.*[!@#$%^&*() ,.? ":{} | <> \ -_+=\\` ~; ']). {8,} $
`` `
Spiegazione:
* `^`:Corrisponde all'inizio della stringa.
* `(? =.* [A-Za-Z])`:asserzione positiva del lookahead che richiede almeno una lettera (A-Z o A-Z).
* `(? =.* \ d)`:asserzione di lookahead positiva che richiede almeno una cifra (0-9).
*`(? =.*[!@#$%^&*(),.?":{} | <> \ -_+=\\ `~; '])`:asserzione positiva del lookahead che richiede almeno un personaggio speciale. Questa è la parte critica e si dovrebbe regolare i personaggi di Escapes Used to Escapes Used to Escapes Toovy Toors da parte di ECAPIONS ECCATTURE ECCATTI ECCATI SECIALI ECCATI SECIALI ECCATI SECIALI ECCATI SECIALI ECCATI SECIALI ECCATTI SECIALI ECCATI SECIALI ECCATI SECIALI La classe di personaggi (ad esempio, `\` e `-`).
* `. {8,}`:corrisponde a qualsiasi carattere (tranne Newline) almeno 8 volte. Questo garantisce la lunghezza minima.
* `$`:Corrisponde alla fine della stringa.
Come usarlo in contesti diversi:
* JavaScript:
`` `JavaScript
const passwordRegex =/^(?=.* !!a-Za-Zing)(??=.*\d)(?=.* !!!@#$%^&*()
const password ="myp@ssword123";
const isValid =passwordRegex.test (password);
console.log (isvalid); // output:vero
const nonlidpassword ="short1!";
const isInValid =passwordRegex.test (nonlidPassword);
console.log (isInvalid); // output:false
`` `
* Python:
`` `Python
importazione re
password_regex =r "^(? =.*[a-za-z]) (? =.*\ d) (? =.*[!@#$%^&*() ,.? \":{} | <> \ -_+=\\ `~; ']). {8,} $"
password ="myp@ssword123"
is_valid =re.match (password_regex, password)
print (bool (is_valid)) # output:true
Invalid_password ="short1!"
is_invalid =re.match (password_regex, nonlid_password)
print (bool (is_invalid)) # output:false
`` `
* Java:
`` `Java
import java.util.regex.matcher;
import java.util.regex.Pattern;
classe pubblica passwordValidator {
public static void main (string [] args) {
Stringa passwordRegex ="^(? =.*[A-za-z]) (? =.*\\ d) (? =.*[!@#$%^&*() ,.? \":{} | <> -_+=\\ `~; ']). {8,} $";
String password ="myp@ssword123";
Pattern pattern =pattern.compile (passwordRegex);
Matcher matcher =pattern.matcher (password);
System.out.println (matcher.matches ()); // output:vero
String invalidpassword ="short1!";
matcher =pattern.matcher (non validpassword);
System.out.println (matcher.matches ()); // output:false
}
}
`` `
Considerazioni e personalizzazione importanti:
* Personaggi speciali: La parte più critica è definire i caratteri speciali consentiti. Il `[!@#$%^&*() ,.?":{} | <> \ -_+=\\ `~; ']` Parte del regex definisce quali personaggi sono considerati "speciali". Esamina attentamente e modificano questo per abbinare i tuoi requisiti specifici. Ricorda di sfuggire ai personaggi di Regex speciali.
* Set di caratteri:
* `[A-za-z]`:corrisponde a qualsiasi lettera maiuscola o minuscola. Potresti voler limitare questo a lettere minuscole o solo maiuscole se necessario.
* `\ d`:corrisponde a qualsiasi cifra (0-9).
* Lunghezza minima: La parte `{8,}` specifica una lunghezza minima di 8 caratteri. Modificare `8` per regolare la lunghezza minima. Se vuoi anche una lunghezza massima, puoi specificarlo in questo modo:`{8,16}` per un minimo di 8 e un massimo di 16 caratteri.
* Requisiti di complessità: Puoi aggiungere più requisiti di complessità aggiungendo più asserzioni di lookahead. Ad esempio, potresti richiedere almeno due cifre con `(? =.*\ D.*? \ D)`.
* Best practice di sicurezza: Mentre questo Regex applica un livello base di complessità, è fondamentale capire che il solo Regex non è una soluzione di sicurezza completa. Considera queste migliori pratiche:
* sale e hash: Non memorizzare mai le password in testo normale. Usa sempre un forte algoritmo di hashing (come Argon2, BCrypt o Scrypt) con un sale unico per ogni password.
* Contatori di resistenza password: Utilizzare un misuratore di forza della password per fornire un feedback in tempo reale agli utenti mentre digitano la password.
* Audit di sicurezza regolari: Rivedi regolarmente le politiche della password e le pratiche di sicurezza.
* Limitazione della velocità: Implementare la velocità di limitazione dei tentativi di accesso per prevenire gli attacchi di forza bruta.
Esempio:consentire solo i seguenti caratteri speciali:`!@#$%^&*`
Il regex sarebbe diventato:
`` `regex
^(? =.*[a-za-z]) (? =.*\ d) (? =.*[!@#$%^&*]). {8,} $
`` `
Esempio:richiedere almeno due cifre:
`` `regex
^(? =.*[a-za-z]) (? =.*\ d.*? \ d) (? =.*[!@#$%^&*() ,.? ":{} | <> \ -_+=\\` ~; ']. {8,} $
`` `
Questa versione aggiunge `(? =.*\ D.*? \ D)`, che richiede almeno due cifre, con qualche personaggio tra i consentiti da `.*?`.
Scegli il regex che si adatta meglio a * la tua * politica di password specifica e ricorda di dare la priorità alle migliori pratiche di sicurezza. Prova sempre a fondo il regex con una varietà di password valide e non valide.
Domanda © www.354353.com