1. Verificare un singolo utente (ad es. Accedi):
Questo è lo scenario più comune. Verificheremo se un nome utente e una password corrispondono a un record nel database. Fondamentalmente, hash la password prima di confrontarla. Non memorizzare mai le password in testo normale!
`` `php
// credenziali del database (sostituiscile con le tue credenziali effettive!)
$ serverName ="your_servername";
$ username ="your_username";
$ password ="your_password";
$ dbname ="your_dbname";
// Input dell'utente (igienizza questo!)
$ usernameInput =$ _post ["nome utente"];
$ passwordInput =$ _post ["password"];
// sanitalizza gli input dell'utente per prevenire l'iniezione di SQL
$ usernameInput =mysqli_real_escape_string ($ conn, $ usernameInput);
$ passwordInput =mysqli_real_escape_string ($ conn, $ passwordInput);
// Crea connessione
$ Conn =new Mysqli ($ serverName, $ username, $ password, $ dbname);
// Controlla la connessione
if ($ conn-> connect_error) {
die ("connessione non riuscita:". $ Conn-> connect_error);
}
// Prepara e lega
$ stmt =$ conn-> prepara ("Seleziona password_hash dagli utenti dove username =?");
$ stmt-> bind_param ("s", $ usernameInput);
$ stmt-> esecute ();
$ result =$ stmt-> get_result ();
if ($ result-> num_rows> 0) {
$ row =$ risultato-> fetch_assoc ();
$ hashedpassword =$ row ["password_hash"];
// Verifica la password utilizzando password_verify (funzione di hashing password integrata di PHP)
if (password_verify ($ passwordInput, $ hashedPassword)) {
// Accedi di successo
Echo "Accedi di successo!";
} altro {
// password errata
echo "password errata.";
}
} altro {
// Nome utente non trovato
echo "nome utente non trovato";
}
$ stmt-> chiust ();
$ Conn-> chiust ();
?>
`` `
Spiegazione:
* Credenziali del database: Sostituisci le credenziali segnaposto con i dettagli del database MySQL effettivi.
* Input utente: Questo codice presuppone che il nome utente e la password siano inviati tramite una richiesta post. Sanitare sempre l'input dell'utente per prevenire le vulnerabilità di iniezione di SQL. `mysqli_real_escape_string ()` è un passaggio di base, ma le dichiarazioni preparate (usate qui) sono molto più robuste.
* Dichiarazione preparata: Un'istruzione preparata impedisce l'iniezione SQL separando la query SQL dai dati forniti dall'utente. È fondamentale per la sicurezza.
* Hashing password: Il database dovrebbe archiviare la password *hash *, non le password di testo semplice. `password_hash ()` crea un hash sicuro e `password_verify ()` confronta l'input dell'utente rispetto all'hash memorizzato.
* Gestione degli errori: Il codice include la gestione degli errori di base per la connessione del database e gli errori di query.
2. Verifica di più corrispondenze (ad es. Ricerca una tabella):
Se è necessario trovare più corrispondenze in base all'input dell'utente (come la ricerca di prodotti con un nome specifico), dovrai adattare la query:
`` `php
// ... (connessione al database come sopra) ...
$ SearchTerm =$ _post ["SearchTerm"];
$ searchTerm =mysqli_real_escape_string ($ conn, $ searchterm); // sanitizza!
$ sql ="seleziona * da prodotti in cui nome come '%$ searchterm%'"; // Esempio semplice:usa la dichiarazione preparata per una migliore sicurezza!
$ result =$ Conn-> query ($ sql);
if ($ result-> num_rows> 0) {
while ($ row =$ result-> fetch_assoc ()) {
// Elabora ogni riga di corrispondenza
Echo "Prodotto:". $ row ["nome"]. "
";
}
} altro {
echo "Nessun prodotto trovato";
}
// ... (connessione chiusa) ...
?>
`` `
Nota importante: L'esempio di ricerca sopra utilizza la concatenazione stringa, che è vulnerabile all'iniezione SQL se `$ SearchTerm` non è igienizzato . Per una soluzione sicura, riscrivilo utilizzando istruzioni preparate. Esempio:
`` `php
$ stmt =$ conn-> prepara ("seleziona * dai prodotti dove il nome mi piace?");
$ SearchTerm ="%". $ SearchTerm. "%"; // Aggiungi caratteri jolly per like
$ stmt-> bind_param ("s", $ searchterm);
$ stmt-> esecute ();
// ... resto del codice per gestire i risultati ...
`` `
Ricorda di sostituire la tabella di segnaposto e i nomi delle colonne con lo schema di database effettivo. Dai la priorità alla sicurezza utilizzando dichiarazioni preparate e una corretta sanificazione input per prevenire gli attacchi di iniezione di SQL. Prendi in considerazione l'utilizzo di query parametrizzate per qualsiasi interazione con l'input dell'utente e il database. Per scenari più complessi o set di dati di grandi dimensioni, potresti voler esplorare tecniche più avanzate come le procedure memorizzate.
Programmazione © www.354353.com