Acest ghid vă va arăta cum puteți stoca sesiunile în siguranță într-o bază de date mySQL. De asemenea, vom cripta toate datele de sesiune care intră în baza de date, ceea ce înseamnă că dacă cineva reușește să pirateze în baza de date, toate datele de sesiune sunt criptate prin criptare AES pe 256 de biți.
Pași
Metoda 1 din 3: Configurați baza de date mySQL
Pasul 1. Creați o bază de date MySQL
În acest ghid vom crea o bază de date numită "secure_sessions".
Vedeți cum să creați o bază de date în phpMyAdmin.
Sau puteți utiliza codul SQL de mai jos, va crea unul pentru dvs.
Creați codul bazei de date:
CREAȚI BAZA DE BAZĂ DE DATE `secure_sessions`;
Notă: Unele servicii de găzduire nu vă permit să creați o bază de date prin phpMyAdmin. Aflați cum să o faceți în cPanel.
Pasul 2. Creați un utilizator cu numai privilegii SELECT, INSERT și DELETE
Aceasta înseamnă că, dacă a existat vreodată o încălcare a securității în scriptul nostru, hackerul nu ar putea să renunțe la tabele din baza noastră de date. Dacă sunteți cu adevărat paranoic, creați un utilizator diferit pentru fiecare funcție.
-
Utilizator:
„sec_user”
-
Parola:
„eKcGZr59zAa2BEWU”
Creați cod de utilizator:
CREAȚI UTILIZATOR 'sec_user' @ 'localhost' IDENTIFICAT DE 'eKcGZr59zAa2BEWU'; GRANT SELECT, INSERT, UPDATE, DELETE ON `secure_sessions`. * TO 'sec_user' @ 'localhost';
Notă: Este o idee bună să schimbați parola din codul de mai sus atunci când rulați pe propriul dvs. server. (Asigurați-vă că modificați și codul PHP.) Amintiți-vă că nu trebuie să fie o parolă pe care să o puteți aminti, astfel încât să creați este cât mai complicat posibil. Iată un generator de parole aleatoriu.
Pasul 3. Creați un tabel MySQL numit „sesiuni”
Codul de mai jos creează un tabel cu 4 câmpuri (id, set_time, data, session_key).
Creați tabelul „sesiuni”:
CREATE TABLE `sessions` (` id` char (128) NOT NULL, `set_time` char (10) NOT NULL,„ data` text NOT NULL, `session_key` char (128) NOT NULL, CHEIE PRIMARĂ (` id`)) MOTOR = InnoDB DEFAULT CHARSET = latin1;
Folosim tipul de date CHAR pentru câmpurile despre care știm lungimea, deoarece câmpurile „id” și „session_key” vor avea întotdeauna 128 de caractere. Utilizarea CHAR aici economisește puterea de procesare.
Metoda 2 din 3: Creați fișierul session.class.php
Pasul 1. Creați clasa
Pentru a începe o nouă clasă, va trebui să introduceți codul de mai jos:
Clasa nouă:
sesiune de curs {
Pasul 2. Creați funcția _construct
Această funcție va fi apelată de fiecare dată când creăm o nouă instanță a unui obiect folosind clasa „sesiune”. Puteți citi aici despre funcția PHP _construct.
Această funcție setează handler-ul de sesiune personalizat, astfel încât este disponibil pentru utilizare de îndată ce este instanțiată clasa (adică realizată / construită / construită).
_funcția de construcție:
function _construct () {// setează funcțiile de sesiune personalizate. session_set_save_handler (array ($ this, 'open'), array ($ this, 'close'), array ($ this, 'read'), array ($ this, 'write'), array ($ this, 'destroy'), matrice ($ this, 'gc')); // Această linie previne efectele neașteptate atunci când se utilizează obiecte ca handlere de salvare. register_shutdown_function ('session_write_close'); }
Pasul 3. Creați funcția start_session
Această funcție va fi apelată de fiecare dată când doriți să începeți o nouă sesiune, utilizați-o în loc de session_start ();. Vedeți comentariile din cod pentru a vedea ce face fiecare linie.
funcția start_session:
function start_session ($ session_name, $ secure) {// Asigurați-vă că cookie-ul de sesiune nu este accesibil prin javascript. $ httponly = adevărat; // Algoritmul hash de utilizat pentru sesiune. (utilizați hash_algos () pentru a obține o listă de hashuri disponibile.) $ session_hash = 'sha512'; // Verificați dacă hash este disponibil dacă (in_array ($ session_hash, hash_algos ())) {// Setați funcția has. ini_set ('session.hash_function', $ session_hash); } // Câți biți pe caracter al hashului. // Valorile posibile sunt „4” (0-9, a-f), „5” (0-9, a-v) și „6” (0-9, a-z, A-Z, "-", ","). ini_set ('session.hash_bits_per_character', 5); // Forțați sesiunea să utilizeze numai cookie-uri, nu variabile URL. ini_set ('session.use_only_cookies', 1); // Obțineți parametrii cookie-ului de sesiune $ cookieParams = session_get_cookie_params (); // Setați parametrii session_set_cookie_params ($ cookieParams ["durata de viață"], $ cookieParams ["cale"], $ cookieParams ["domeniu"], $ securizat, $ httponly); // Schimbați numele sesiunii nume_sesiune ($ nume_sesiune); // Acum vom începe sesiunea session_start (); // Această linie regenerează sesiunea și șterge cea veche. // De asemenea, generează o nouă cheie de criptare în baza de date. session_regenerate_id (adevărat); }
Pasul 4. Creați funcția deschisă
Această funcție va fi apelată de sesiunile PHP atunci când începem o nouă sesiune, o folosim pentru a începe o nouă conexiune la baza de date.
funcție deschisă:
function open () {$ host = 'localhost'; $ user = 'sec_user'; $ pass = 'eKcGZr59zAa2BEWU'; $ name = 'securitate_sesiuni'; $ mysqli = mysqli nou ($ gazdă, $ utilizator, $ trecere, $ nume); $ this-> db = $ mysqli; întoarcere adevărată; }
Pasul 5. Creați funcția de închidere
Această funcție va fi apelată când sesiunile vor fi închise.
funcție de închidere:
function close () {$ this-> db-> close (); întoarcere adevărată; }
Pasul 6. Creați funcția de citire
Această funcție va fi apelată de PHP atunci când încercăm să accesăm o sesiune, de exemplu atunci când folosim echo $ _SESSION ['ceva'];. Deoarece ar putea exista multe apeluri către această funcție pe o singură pagină, profităm de declarațiile pregătite, nu numai pentru securitate, ci și pentru performanță. Pregătim declarația doar o singură dată, apoi o putem executa de multe ori.
De asemenea, decriptăm datele sesiunii care sunt criptate în baza de date. Folosim criptarea AES pe 256 de biți în sesiunile noastre.
funcția de citire:
funcție read ($ id) {if (! isset ($ this-> read_stmt)) {$ this-> read_stmt = $ this-> db-> prepare ("SELECTAȚI datele din sesiuni WHERE id =? LIMIT 1"); } $ this-> read_stmt-> bind_param ('s', $ id); $ this-> read_stmt-> execute (); $ this-> read_stmt-> store_result (); $ this-> read_stmt-> bind_result ($ data); $ this-> read_stmt-> fetch (); $ cheie = $ this-> getkey ($ id); $ date = $ this-> decrypt ($ data, $ cheie); returnează $ date; }
Pasul 7. Creați funcția de scriere
Această funcție este utilizată atunci când atribuim o valoare unei sesiuni, de exemplu $ _SESSION ['something'] = 'something else';. Funcția criptează toate datele care sunt introduse în baza de date.
funcția de scriere:
function write ($ id, $ data) {// Obține cheia unică $ key = $ this-> getkey ($ id); // Criptați datele $ data = $ this-> encrypt ($ data, $ cheie); $ timp = timp (); if (! isset ($ this-> w_stmt)) {$ this-> w_stmt = $ this-> db-> pregătiți ("REPLACE INTO sessions (id, set_time, data, session_key) VALORI (?,?,?,?) "); } $ this-> w_stmt-> bind_param ('siss', $ id, $ time, $ data, $ key); $ this-> w_stmt-> execute (); întoarcere adevărată; }
Pasul 8. Creați funcția de distrugere
Această funcție șterge sesiunea din baza de date, este utilizată de php când apelăm funcții precum session_destroy ();.
funcția de distrugere:
function destroy ($ id) {if (! isset ($ this-> delete_stmt)) {$ this-> delete_stmt = $ this-> db-> prepare ("ȘTERGERE DIN sesiuni WHERE id =?"); } $ this-> delete_stmt-> bind_param ('s', $ id); $ this-> delete_stmt-> execute (); întoarcere adevărată; }
Pasul 9. Creați funcția gc (colector de gunoi)
Această funcție este funcția de colectare a gunoiului pe care este apelată pentru a șterge sesiunile vechi. Frecvența în care este apelată această funcție este determinată de două directive de configurare, session.gc_probability și session.gc_divisor.
funcția gc ():
funcția gc ($ max) {if (! isset ($ this-> gc_stmt)) {$ this-> gc_stmt = $ this-> db-> pregătiți ("ȘTERGEȚI DIN sesiuni WHERE set_time <?"); } $ vechi = time () - $ max; $ this-> gc_stmt-> bind_param ('s', $ old); $ this-> gc_stmt-> execute (); întoarcere adevărată; }
Pasul 10. Creați funcția getKey
Această funcție este utilizată pentru a obține cheia unică pentru criptare din tabelul de sesiuni. Dacă nu există nicio sesiune, returnează doar o nouă cheie aleatorie pentru criptare.
Funcția getkey ():
funcție privată getkey ($ id) {if (! isset ($ this-> key_stmt)) {$ this-> key_stmt = $ this-> db-> pregătiți ("SELECT session_key FROM sessions WHERE id =? LIMIT 1"); } $ this-> key_stmt-> bind_param ('s', $ id); $ this-> key_stmt-> execute (); $ this-> key_stmt-> store_result (); if ($ this-> key_stmt-> num_rows == 1) {$ this-> key_stmt-> bind_result ($ key); $ this-> key_stmt-> fetch (); returnează cheia $; } else {$ random_key = hash ('sha512', uniqid (mt_rand (1, mt_getrandmax ()), true)); returnează $ random_key; }}
Pasul 11. Creați funcții de criptare și decriptare
Aceste funcții criptează datele sesiunilor, folosesc o cheie de criptare din baza de date care este diferită pentru fiecare sesiune. Nu folosim direct acea cheie în criptare, dar o folosim pentru a face cheia hash-ului să fie și mai aleatorie.
funcțiile encrypt () și decrypt ():
criptare funcție privată ($ date, $ cheie) {$ salt = 'cH! swe! retReGu7W6bEDRup7usuDUh9THeD2CHeGE * ewr4n39 = E @ rAsp7c-Ph @ pH'; $ cheie = substr (hash ('sha256', $ sare. $ cheie. $ sare), 0, 32); $ iv_size = mcrypt_get_iv_size (MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB); $ iv = mcrypt_create_iv ($ iv_size, MCRYPT_RAND); $ criptat = base64_encode (mcrypt_encrypt (MCRYPT_RIJNDAEL_256, $ cheie, $ date, MCRYPT_MODE_ECB, $ iv)); returnează $ criptat; } decriptare funcție privată ($ date, $ cheie) {$ salt = 'cH! swe! retReGu7W6bEDRup7usuDUh9THeD2CHeGE * ewr4n39 = E @ rAsp7c-Ph @ pH'; $ cheie = substr (hash ('sha256', $ sare. $ cheie. $ sare), 0, 32); $ iv_size = mcrypt_get_iv_size (MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB); $ iv = mcrypt_create_iv ($ iv_size, MCRYPT_RAND); $ decriptat = mcrypt_decrypt (MCRYPT_RIJNDAEL_256, $ cheie, base64_decode ($ date), MCRYPT_MODE_ECB, $ iv); $ decriptat = rtrim ($ decriptat, "\ 0"); returnează $ decriptat; }
Pasul 12. Sfârșitul clasei
Aici terminăm clasele paranteze:
Sfârșitul clasei:
}
Metoda 3 din 3: Crearea paginilor cu sesiuni
Pasul 1. Utilizarea sesiunilor cu managerul de sesiuni personalizat
Mai jos este modul în care ați începe o nouă sesiune; ar trebui să includeți acest lucru în fiecare pagină pe care doriți să accesați sesiunile, folosiți-l în loc de session_start ();
Începerea unei sesiuni:
require ('session.class.php'); $ sesiune = sesiune nouă (); // Setați la adevărat dacă utilizați https $ session-> start_session ('_ s', false); $ _SESSION ['something'] = 'O valoare.'; ecou $ _SESSION ['ceva'];
