See juhend näitab teile, kuidas saate oma seansse turvaliselt mySQL -i andmebaasi salvestada. Samuti krüpteerime kõik andmebaasi sisenevad seansiandmed, mis tähendab, et kui kellelgi õnnestub andmebaasi häkkida, on kõik seansiandmed krüptitud 256-bitise AES-krüpteerimisega.
Sammud
Meetod 1 /3: seadistage mySQL -i andmebaas
Samm 1. Looge MySQL andmebaas
Selles juhendis loome andmebaasi nimega "secure_sessions".
Vaadake, kuidas luua andmebaasi-in-phpMyAdmin.
Või võite kasutada allolevat SQL -koodi, et luua see teile.
Loo andmebaasi kood:
CREATE DATABASE `secure_sessions`;
Märkus. Mõned hostimisteenused ei luba teil phpMyAdmini kaudu andmebaasi luua. Vaadake, kuidas seda cPanelis teha.
Samm 2. Looge kasutaja, kellel on ainult SELECT, INSERT ja DELETE õigused
See tähendab, et kui meie skriptis oleks kunagi turvavöö olnud, ei saanud häkker tabeleid meie andmebaasist välja jätta. Kui olete tõesti paranoiline, looge iga funktsiooni jaoks erinev kasutaja.
-
Kasutaja:
"sec_user"
-
Parool:
"eKcGZr59zAa2BEWU"
Loo kasutajakood:
CREATE USER 'sec_user'@'localhost' TUNNISTAJA 'eKcGZr59zAa2BEWU'; GRANT SELECT, INSERT, UPDATE, DELETE ON "secure_sessions".* TO 'sec_user'@'localhost';
Märkus. Oma serveris töötades on hea mõte muuta ülaltoodud koodi parool. (Muutke kindlasti ka oma PHP -koodi.) Pidage meeles, et see ei pea olema parool, mida mäletate, nii et see oleks võimalikult keeruline. Siin on juhuslik parooligeneraator.
Samm 3. Looge MySQL tabel nimega "seansid"
Allolev kood loob tabeli 4 väljaga (id, set_time, data, session_key).
Looge tabel "Seansid":
CREATE TABLE "seansid" ("id" char (128) NOT NULL, "set_time" char (10) NOT NULL, "andmete" tekst NOT NULL, "session_key" char (128) NOT NULL, PRIMARY KEY ("id")) MOOTOR = InnoDB DEFAULT CHARSET = ladina1;
Me kasutame CHAR andmetüüpi väljade jaoks, mille pikkust me teame, kuna väljad "id" ja "session_key" on alati 128 tähemärki pikad. CHARi kasutamine siin säästab töötlemisvõimsust.
Meetod 2/3: looge fail session.class.php
Samm 1. Looge klass
Uue klassi alustamiseks peate sisestama alloleva koodi:
Uus klass:
klassisessioon {
Samm 2. Looge funktsioon _construct
Seda funktsiooni kutsutakse iga kord, kui loome klassi „session” abil objekti uue eksemplari. Siit saate lugeda funktsiooni PHP _construct kohta.
See funktsioon seab meie kohandatud seansihalduri nii, et see on kasutamiseks saadaval kohe, kui klass on loodud (st tehtud/ehitatud/ehitatud).
_konstrueerimisfunktsioon:
function _construct () {// määrake meie kohandatud seansifunktsioonid. session_set_save_handler (massiiv ($ see, 'avatud'), massiiv ($ see, 'sule'), massiiv ($ see, 'loe'), massiiv ($ see, 'kirjuta'), massiiv ($ see, 'hävita')), massiiv ($ this, 'gc')); // See rida hoiab ära ootamatud efektid objektide kasutamisel salvestamise käitlejana. register_shutdown_function ('seansi_kirjutamise_seade'); }
Samm 3. Looge funktsioon start_session
Seda funktsiooni kutsutakse iga kord, kui soovite uut seanssi alustada, kasutage seda asemel session_start ();. Vaadake koodi kommentaare, et näha, mida iga rida teeb.
funktsioon start_session:
function start_session ($ session_name, $ secure) {// Veenduge, et seansi küpsis ei oleks JavaScripti kaudu juurdepääsetav. $ httponly = tõsi; // Seansi jaoks kasutatav räsialgoritm. (kasutage hash_algos () saadaolevate räside loendi saamiseks.) $ session_hash = 'sha512'; // Kontrollige, kas räsi on saadaval, kui (in_array ($ session_hash, hash_algos ())) {// Määrake funktsioon has. ini_set ('session.hash_function', $ session_hash); } // Mitu bitti räsimärgi kohta. // Võimalikud väärtused on '4' (0-9, a-f), '5' (0-9, a-v) ja '6' (0-9, a-z, A-Z, "-", ","). ini_set ('session.hash_bits_per_character', 5); // Sundida seanssi kasutama ainult küpsiseid, mitte URL -i muutujaid. ini_set ('session.use_only_cookies', 1); // Seansi küpsiseparameetrite hankimine $ cookieParams = session_get_cookie_params (); // Seadistage parameetrid session_set_cookie_params ($ cookieParams ["eluiga"], $ cookieParams ["path"], $ cookieParams ["domain"], $ secure, $ httponly); // Seansi nime muutmine session_name ($ session_name); // Nüüd alustame kassi seanssi session_start (); // See rida taastab seansi ja kustutab vana. // See loob andmebaasi ka uue krüptimisvõtme. session_regenerate_id (tõene); }
Samm 4. Looge avatud funktsioon
Seda funktsiooni kutsuvad PHP seansid, kui alustame uut seanssi, kasutame seda uue andmebaasiühenduse alustamiseks.
avatud funktsioon:
function open () {$ host = 'localhost'; $ user = 'sec_user'; $ pass = 'eKcGZr59zAa2BEWU'; $ name = 'secure_sessions'; $ mysqli = uus mysqli ($ host, $ user, $ pass, $ name); $ see-> db = $ mysqli; tagastama tõene; }
Samm 5. Loo sulgemisfunktsioon
Seda funktsiooni kutsutakse siis, kui seansid soovitakse sulgeda.
sulgemisfunktsioon:
function close () {$ this-> db-> close (); tagastama tõene; }
Samm 6. Loo lugemisfunktsioon
Seda funktsiooni kutsub PHP, kui proovime seansile juurde pääseda, näiteks kui kasutame echo $ _SESSION ['midagi'];. Kuna ühel lehel võib sellele funktsioonile palju kõnesid kasutada, kasutame ettevalmistatud avaldusi mitte ainult turvalisuse, vaid ka jõudluse huvides. Me koostame avalduse ainult üks kord, siis saame seda mitu korda täita.
Samuti dekrüpteerime andmebaasis krüpteeritud seansi andmed. Kasutame oma seanssidel 256-bitist AES-krüptimist.
lugemisfunktsioon:
funktsioon loe ($ id) {if (! isset ($ this-> read_stmt)) {$ this-> read_stmt = $ this-> db-> prep ("SELECT data from FRESSID WHERE id =? LIMIT 1"); } $ this-> read_stmt-> bind_param ('s', $ id); $ this-> read_stmt-> execute (); $ this-> read_stmt-> kaupluse_tulemus (); $ this-> read_stmt-> bind_result ($ andmed); $ this-> read_stmt-> fetch (); $ võti = $ see-> getkey ($ id); $ data = $ this-> dekrüpteerida ($ data, $ key); $ andmete tagastamine; }
Samm 7. Loo kirjutamisfunktsioon
Seda funktsiooni kasutatakse siis, kui määrame seansile väärtuse, näiteks $ _SESSION ['midagi'] = 'midagi muud';. Funktsioon krüpteerib kõik andmed, mis sisestatakse andmebaasi.
kirjutamise funktsioon:
function write ($ id, $ data) {// Hangi unikaalne võti $ key = $ this-> getkey ($ id); // Krüpteerige andmed $ data = $ this-> encrypt ($ data, $ key); $ aeg = aeg (); if (! isset ($ this-> w_stmt)) {$ this-> w_stmt = $ this-> db-> valmistama ("REPLACE INTO seansid (id, set_time, data, session_key) VÄÄRTUSED (?,?,?,?) "); } $ this-> w_stmt-> bind_param ('siss', $ id, $ time, $ data, $ key); $ this-> w_stmt-> execute (); tagastama tõene; }
Samm 8. Loo hävitamise funktsioon
See funktsioon kustutab seansi andmebaasist, seda kasutab php, kui kutsume selliseid funktsioone nagu session_destroy ();.
hävitamise funktsioon:
funktsioon hävitada ($ id) {if (! isset ($ this-> delete_stmt)) {$ this-> delete_stmt = $ this-> db-> prep ("DELETE FROM session WHERE id =?"); } $ this-> delete_stmt-> bind_param ('s', $ id); $ this-> delete_stmt-> execute (); tagastama tõene; }
Samm 9. Looge gc (prügikoguja) funktsioon
See funktsioon on prügikogumisfunktsioon, mida nimetatakse vanade seansside kustutamiseks. Selle funktsiooni kutsumise sageduse määravad kaks konfiguratsioonidirektiivi - session.gc_probability ja session.gc_divisor.
funktsioon gc ():
function gc ($ max) {if (! isset ($ this-> gc_stmt)) {$ this-> gc_stmt = $ this-> db-> valmistama ("DELETE FROM seansid WHERE set_time <?"); } $ old = time () - $ max; $ this-> gc_stmt-> bind_param ('s', $ vana); $ this-> gc_stmt-> käivita (); tagastama tõene; }
Samm 10. Loo getKey funktsioon
Seda funktsiooni kasutatakse unikaalse võtme saamiseks krüptimiseks seansside tabelist. Kui seanssi pole, tagastab see lihtsalt krüpteerimiseks uue juhusliku võtme.
getkey () Funktsioon:
privaatfunktsioon getkey ($ id) {if (! isset ($ this-> key_stmt)) {$ this-> key_stmt = $ this-> db-> prep ("SELECT session_key FROM session WHERE id =? LIMIT 1"); } $ this-> key_stmt-> bind_param ('s', $ id); $ this-> key_stmt-> execute (); $ this-> key_stmt-> kaupluse_tulemus (); if ($ this-> key_stmt-> num_rows == 1) {$ this-> key_stmt-> bind_result ($ võti); $ this-> key_stmt-> tõmmake (); return $ võti; } else {$ random_key = hash ('sha512', uniqid (mt_rand (1, mt_getrandmax ()), true)); tagasta $ random_key; }}
Samm 11. Looge krüptimis- ja dekrüpteerimisfunktsioonid
Need funktsioonid krüpteerivad seansside andmed, nad kasutavad andmebaasi krüptimisvõtit, mis on iga seansi jaoks erinev. Me ei kasuta seda võtit krüptimisel otseselt, kuid kasutame seda võtme räsi muutmiseks veelgi juhuslikumaks.
krüptimise () ja dekrüpteerimise () funktsioonid:
privaatfunktsiooni krüptimine ($ data, $ key) {$ salt = 'cH! swe! retReGu7W6bEDRup7usuDUh9THeD2CHeGE*ewr4n39 = E@rAsp7c-Ph@pH'; $ võti = substr (hash ('sha256', $ salt. $ key. $ salt), 0, 32); $ iv_size = mcrypt_get_iv_size (MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB); $ iv = mcrypt_create_iv ($ iv_size, MCRYPT_RAND); $ encrypted = base64_encode (mcrypt_encrypt (MCRYPT_RIJNDAEL_256, $ võti, $ andmed, MCRYPT_MODE_ECB, $ IV)); return $ krüpteeritud; } privaatfunktsiooni dekrüpteerimine ($ andmed, $ võti) {$ salt = 'cH! swe! retReGu7W6bEDRup7usuDUh9THeD2CHeGE*ewr4n39 = E@rAsp7c-Ph@pH'; $ võti = substr (hash ('sha256', $ salt. $ key. $ salt), 0, 32); $ iv_size = mcrypt_get_iv_size (MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB); $ iv = mcrypt_create_iv ($ iv_size, MCRYPT_RAND); $ decrypted = mcrypt_decrypt (MCRYPT_RIJNDAEL_256, $ võti, base64_decode ($ data), MCRYPT_MODE_ECB, $ IV); $ dekrüpteeritud = rtrim ($ dekrüpteeritud, "\ 0"); return $ dekrüpteeritud; }
Samm 12. Lõpuklass
Siin lõpetame lihtsalt klasside lokkisulud:
Lõppklass:
}
Meetod 3/3: seanssidega lehtede loomine
Samm 1. Seansside kasutamine kohandatud seansihalduriga
Allpool on toodud, kuidas uut seanssi alustada; peate selle lisama igale lehele, millele soovite seanssidele juurde pääseda, kasuta seda session_start () asemel;
Seansi alustamine:
nõuda ('session.class.php'); $ seanss = uus seanss (); // Määra väärtuseks tõene, kui kasutad https $ session-> start_session ('_ s', false); $ _SESSION ['midagi'] = 'Väärtus.'; echo $ _SESSION ['midagi'];
