Comprensione dei requisiti
* 6 e 10 caratteri: Ciò significa che la lunghezza della password dovrebbe essere * compresa tra * 6 e 10 caratteri, compresa. Quindi, 6, 7, 8, 9 o 10 caratteri sono lunghezze valide.
* alfanumerico: Ciò significa che la password può contenere solo lettere (A-Z, A-Z) e numeri (0-9). Non sono ammessi personaggi speciali (come!, @, #, $, %, Ecc.).
espressione regolare (regex) per convalida
Un'espressione regolare è un modo potente per definire uno schema per il testo. Ecco un regex che corrisponde alle tue esigenze:
`` `regex
^[A-za-z0-9] {6,10} $
`` `
Spiegazione del regex:
* `^`:Corrisponde all'inizio della stringa.
* `[A-za-z0-9]`:corrisponde a qualsiasi lettera maiuscola (A-Z), lettera minuscola (A-Z) o cifra (0-9).
* `{6,10}`:corrisponde al carattere precedente (il carattere alfanumerico) tra 6 e 10 volte (inclusivo).
* `$`:Corrisponde alla fine della stringa.
Codice di esempio (JavaScript)
`` `JavaScript
funzione iSValIdPassword (password) {
const regex =/^[a-za-z0-9] {6,10} $ /;
restituire regex.test (password);
}
// Esempi
console.log (isValidPassword ("p@ssword")); // FALSE (carattere speciale)
console.log (isValIdPassword ("pass1")); // false (troppo corto)
console.log (isValidPassword ("password12345")); // false (troppo lungo)
console.log (isValidPassword ("pass12")); // VERO
console.log (isValIdPassword ("password12")); // VERO
console.log (isValidPassword ("p12345678")); // VERO
console.log (isValidPassword ("password")); // VERO
`` `
Spiegazione del codice JavaScript:
1. `IsvalidPassword (password)` Funzione: Questa funzione prende la stringa password come input.
2. `const regex =/^[a-za-z0-9] {6,10} $/;`: Questa linea definisce l'espressione regolare (come spiegato sopra).
3. `return regex.test (password);`: Questa è la linea chiave. Il metodo `regex.test (password)` controlla se la stringa `password` corrisponde al modello` regex`. Restituisce `vero` se corrisponde, e" false` altrimenti.
Altre considerazioni e migliori pratiche
* Sicurezza: Sebbene ciò imponga i requisiti di base, si consiglia spesso di aggiungere più complessità alle password per una migliore sicurezza. Considera di richiedere almeno una lettera maiuscola, una lettera minuscola e un numero.
* Messaggi di errore: Fornire messaggi di errore chiari e utili all'utente se la loro password non soddisfa i requisiti. Per esempio:
* "La password deve essere compresa tra 6 e 10 caratteri."
* "La password deve contenere solo lettere e numeri."
* Hashing: * Non* memorizzare le password in testo normale. Li ha sempre aspirati usando un forte algoritmo di hashing (come BCrypt, Argon2 o Scrypt) prima di archiviarli nel tuo database. Questo protegge le password anche se il database è compromesso.
* Salting: Usa sempre un sale unico generato casualmente per ogni password prima dell'hashing. Ciò rende molto più difficile per gli aggressori utilizzare tabelle pre-computate di hash di password comuni (tabelle arcobaleno).
* Contatori di resistenza password: Prendi in considerazione l'utilizzo di un misuratore di resistenza della password per fornire agli utenti feedback su quanto sia sicura la password prescelta. Le biblioteche sono disponibili per molti linguaggi di programmazione.
JavaScript modificato con raccomandazioni più forti (più sicure)
Questo esempio include un regex più complesso e gli inizi di un migliore processo di creazione e archiviazione della password. Si noti che per un sistema reale, si utilizzerebbe una lingua * sul lato server * per hashing e salting, non JavaScript sul lato client. Questo è solo per illustrazione.
`` `JavaScript
funzione iSValIdStrongPassword (password) {
// richiede 6-10 caratteri, almeno una maiuscola, un minuscolo, un numero
const regex =/^(??=.*__a-z Lasting)(??=.* !!
restituire regex.test (password);
}
// Dimostrare hashing della password (non fare mai questo client nel codice reale!)
funzione hashpassword (password, sale) {
// In APP reale, usa una lingua laterale del server (node.js, python, php ecc.)
// con una libreria BCRYPT/ARGON2/SCRYPT per eseguire hashing e sale adeguate
// ATTENZIONE:BTOA e TEXTENCODER di JavaScript non sono destinati a Hashing di password sicura!
// Questo è solo per esempio illustrativo.
const saltedpassword =sale + password; // Salt la password
const encodedPassword =new textCoder (). ENCODE (SaltedPassword);
const hashbuffer =array.from (codedpassword)
.map (byte => byte.toString (16) .PadStart (2, '0')) // Converti in stringa esadecimale
.giuntura('');
restituire hashbuffer;
}
funzione generateSalt () {
// In Real App, usa un CSPRNG per creare una lunga stringa casuale.
return math.random (). toString (36) .Substring (2, 15) + Math.random (). ToString (36) .Substring (2, 15);
}
// Esempi di password più forti
console.log (isvalidstrongpassword ("p@ssword")); // FALSE (carattere speciale)
console.log (isvalidstrongpassword ("pass1")); // false (troppo corto)
console.log (isvalidstrongpassword ("password12345")); // false (troppo lungo)
console.log (isvalidstrongpassword ("pass12")); // FALSE (MISS HIGHLASCHE)
console.log (isvalidstrongpassword ("password12")); // VERO
console.log (isvalidstrongpassword ("p12345678")); // false (mancante minuscolo)
console.log (isvalidstrongpassword ("password")); // FALSE (MISS HIGHTCA e Number)
console.log (isvalidstrongpassword ("p@ssword12")); // FALSE (carattere speciale)
// dimostrando "hashing" (solo esempio molto insicuro)
const password ="MySecretPassword123";
const sale =generatesAlt ();
const hashedpassword =hashpassword (password, sale);
Console.log ("Password in chiaro:", password);
console.log ("sale:", sale);
console.log ("insicure \" hashed \ "password:", hashedpassword);
`` `
Miglioramenti chiave nell'esempio "più forte":
* Regex più forte:
* `(? =.* [A-Z])`:asserzione di lookahead positiva che richiede almeno una lettera minuscola.
* `(? =.* [A-Z])`:asserzione positiva del lookahead che richiede almeno una lettera maiuscola.
* `(? =.* \ d)`:asserzione di lookahead positiva che richiede almeno una cifra.
* Avviso di hashing lato client: Il codice JavaScript include un enorme avvertimento. * MAI* Eseguire la password di hash in JavaScript sul lato client in un'applicazione reale! È intrinsecamente insicuro perché il codice è visibile all'utente e non può proteggere da vari attacchi. La funzione di "hashing" è solo per dimostrare la * idea * di saltare e hashing; Non è un'implementazione sicura.
* Generazione di sale: L'esempio crea un sale di base. In un sistema reale, useresti un generatore di numeri pseudo-casualmente crittograficamente sicuro (CSPRNG) per generare un sale forte e imprevedibile.
In sintesi, usa il regex più semplice per convalidare la lunghezza e il carattere alfanumerico, ma ricorda sempre di hash e sale la password sul lato server con un metodo crittograficamente sicuro.
Domanda © www.354353.com