3 façons de créer un système de gestion de session sécurisé dans PHP et MySQL

Ce guide vous montrera comment vous pouvez stocker vos sessions en toute sécurité dans une base de données MySQL. Nous allons également crypter toutes les données de session qui entre dans la base de données, ce qui signifie que si quelqu`un parvient à pirater la base de données, toutes les données de session sont cryptées par cryptage AES 256 bits.

Pas

Méthode 1 de 3:

Configurer la base de données MySQL

1. Créer une base de données MySQL.
Dans ce guide, nous allons créer une base de données appelée "Secure_Sessions".
Voir comment Créer-a-Base de données-in-phpmyadmin.
Ou vous pouvez utiliser le code SQL ci-dessous en créera un pour vous.

Créer un code de base de données:

Créer une base de données `Secure_Sessions` -

Remarque: certains services d`hébergement ne vous permettent pas de créer une base de données via PhpMyAdmin, apprenez à le faire dans cPanel.

2. Créez un utilisateur avec seulement sélectionner, insérer et supprimer des privilèges.
Cela signifie que s`il y avait déjà une violation de la sécurité dans notre script, le pirate informatique ne pouvait pas laisser tomber des tables de notre base de données.Si vous êtes vraiment paranoïaque, créez un utilisateur différent pour chaque fonction.

Utilisateur: "SEC_USER"

Mot de passe: "ekcgzr59zaa2bewu"

Créer un code d`utilisateur:

Créer l`utilisateur `sec_user` @ `localhost` identifié par `EKCGZR59ZAA2Bewu`-Subvention Select, Insérer, mettre à jour, supprimer sur `Secure_Sessions`.* À `sec_user` @ `localhost`-

Remarque: il est judicieux de modifier le mot de passe dans le code ci-dessus lors de l`exécution de votre propre serveur. (Assurez-vous de changer votre code PHP aussi.) N`oubliez pas qu`il n`a pas besoin d`être un mot de passe que vous pouvez vous rappeler, c`est aussi compliqué que possible que possible. Voici un mot de passe aléatoire Générateur.

3. Créer une table mysql nommée "sessions".
Le code ci-dessous crée une table avec 4 champs (ID, Set_Time, Données, Session_Key).

Créer le "sessions" tableau:

Créer une table `Sessions` (` id` Char (128) Non NULL, `SET_TIME` CHAR (10) NOT NULL,` DATA` Texte non NULL, `Session_Key` Char (128) Not NULL, clé primaire (` id``) ) Engine = InnoDB Par défaut Charset = Latin1-

Nous utilisons le type de DataType Char pour les champs Nous connaissons la longueur de, comme les champs "identifiant" et "session_key" sera toujours 128 caractères de long. L`utilisation de Char ici enregistre la puissance de traitement.

Méthode 2 de 3:

Créer une session.classer.fichier php

1. Créer une classe.
Pour démarrer une nouvelle classe, vous devrez entrer le code ci-dessous:

Nouvelle classe:

Session de classe {

2. Créer une fonction __Construction.
Cette fonction sera appelée à chaque fois que nous créons une nouvelle instance d`un objet utilisant la classe "Session". Vous pouvez lire sur la fonction PHP __Construction ici.
Cette fonction définit notre gestionnaire de session personnalisé afin qu`il soit disponible pour une utilisation dès que la classe est instanciée (i.e., Fabriqué / construit / construit).

__Construction fonction:

Fonction __Construction () {// Définissez nos fonctions de session personnalisées.session_set_save_handler (tableau ($ ceci, `Open`), Array ($ Ceci, `Fermer`), Array ($ Ceci, `Lire`), Array ($ Cadrage `), Array ($ ceci,` Détruire ` ), tableau ($ ceci, `gc`)) - // Cette ligne empêche les effets inattendus lors de l`utilisation d`objets comme des gestionnaires d`enregistrement.register_shutdown_function (`session_write_close`) -}

3. Créer une fonction start_session.
Cette fonction sera appelée à chaque fois que vous souhaitez démarrer une nouvelle session, l`utiliser au lieu de session_start ()-. Voir les commentaires dans le code pour voir ce que chaque ligne fait.

Fonction Start_Session:

Fonction Start_Session ($ session_name, $ sécurisé) {// Assurez-vous que le cookie de session n`est pas accessible via jаvascript.$ httponly = vrai - // algorithme de hachage à utiliser pour la session. (Utilisez hash_algos () pour obtenir une liste de hachages disponibles.) $ session_hash = `SHA512` - // Vérifiez si le hash est disponible (in_array ($ session_hash, hash_algos ())) {// Définir la fonction a la fonction.ini_set (`session.hash_function `, $ session_hash) -} // Combien de bits par caractère du hachage.// Les valeurs possibles sont `4` (0-9, A-F), `5` (0-9, A-V) et `6` (0-9, A-Z, A-Z, "-", ",").ini_set (`session.hash_bits_per_character `, 5) - // forcer la session à utiliser uniquement des cookies, pas les variables d`URL.ini_set (`session.Utilisez_only_cookies `, 1) - // Obtenir la session Paramètres de cookie $ CookieParams = session_get_cookie_params () - // Définir le paramètreSsession_set_cookie_params ($ cookieparams ["durée de vie"], $ cookieparams ["chemin"], $ cookieparams ["domaine"], $ sécurisé, $ httponly) - // modifier le nom de la session session_name ($ session_name) - // Maintenant, nous commençons par CAT Démarrer la sessionsession_start () - // Cette ligne régénère la session et supprimez l`ancien. // Il génère également une nouvelle clé de cryptage dans la base de données. session_regenerèrent_id (vrai) -}

4. Créer une fonction ouverte.
Cette fonction sera appelée par les sessions PHP lorsque nous ouvrons une nouvelle session, nous l`utilisons pour démarrer une nouvelle connexion de base de données.

Fonction ouverte:

Fonction Open () {$ host = `localhost` - $ utilisateur = `sec_user` - $ passe = `ekcgzr59zaa2bewu` - $ nom_sqli = $ mysqli ($ hôte, $ US User, $ NOM ) - $ ceci->dB = $ mysqli-retour true-}

5. Créer une fonction proche.
Cette fonction sera appelée lorsque les sessions veulent être fermées.

Fonction proche:

Fonction Fermer () {$ Ceci->dB->fermer () - retour true-}

6. Créer une fonction de lecture.
Cette fonction sera appelée par PHP lorsque nous essayons d`accéder à une session par exemple lorsque nous utilisons ECHO $ _Session ["quelque chose"]-. Parce qu`il pourrait y avoir de nombreux appels à cette fonction sur une seule page, nous tirons parti des déclarations préparées, non seulement pour la sécurité, mais également pour la performance. Nous ne préparons que la déclaration une fois que nous pouvons l`exécuter plusieurs fois.
Nous décrypterons également les données de session cryptées dans la base de données. Nous utilisons un cryptage AES 256 bits dans nos sessions.

Fonction de lecture:

Fonction Lecture ($ ID) {si (!Isset ($ this->read_stmt)) {$ Ceci->read_stmt = $ ceci->dB->préparer("Sélectionnez Données des sessions où ID = ? Limite 1") -} $ ceci->read_stmt->bind_param (`s`, $ id) - $ ceci->read_stmt->exécuter () - $ ceci->read_stmt->store_result () - $ ceci->read_stmt->BIND_RESULT ($ données) - $ ceci->read_stmt->fetch () - $ clé = $ ceci->getkey ($ id) - $ données = ceci->déchiffrer ($ données, $ clé) -return $ data-}

7. Créer une fonction d`écriture.
Cette fonction est utilisée lorsque nous affectons une valeur à une session, par exemple $ _Session ["quelque chose"] = "quelque chose d`autre"-. La fonction crypte toutes les données qui sont insérées dans la base de données.

Fonction d`écriture:

Fonction Ecrire ($ ID, $ données) {// Obtenez une clé unique $ Key = $ ceci->getkey ($ id) - // chiffrer les données $ $ data = Ceci->chiffrer ($ données, $ clé) - $ TIME = TIME () - Si (!Isset ($ this->w_stmt)) {$ this->w_stmt = $ ceci->dB->préparer("Remplacer en sessions (ID, Set_Time, Data, Session_Key) Valeurs (?, ?, ?, ?)") -} $ ceci->w_stmt->bind_param ("Siss `, $ Identifiant, $ TIME, $ données, $ clé) - $ ceci->w_stmt->Exécuter () - retour true-}

8. Créer une fonction de détruire.
Cette fonction supprime la session de la base de données, elle est utilisée par PHP lorsque nous appelons des fonctions telles que Session__Destroy ()-.

Détruire la fonction:

Fonction Détruire ($ ID) {si (!Isset ($ this->Supprimer_stmt)) {$ Ceci->delete_stmt = $ ceci->dB->préparer("Supprimer des sessions où id = ?") -} $ ceci->Supprimer_stmt->bind_param (`s`, $ id) - $ ceci->Supprimer_stmt->Exécuter () - retour true-}

9. Créer une fonction GC (collectionneur de déchets).
Cette fonction est la fonction de collecteur des ordures qu`elle est appelée à supprimer de vieilles sessions. La fréquence dans laquelle cette fonction est appelée est déterminée par deux directives de configuration, session.gc_probabilité et session.gc_divisor.

GC () Fonction:

Fonction GC ($ max) {si (!Isset ($ this->gc_stmt)) {$ this->gc_stmt = $ ceci->dB->préparer("Supprimer des sessions où set_time < ?") -} $ old = temps () - $ max- $ ceci->gc_stmt->bind_param (`s`, $ vieux) - $ ceci->gc_stmt->Exécuter () - retour true-}

dix. Créer une fonction getkey.
Cette fonction est utilisée pour obtenir la clé unique du cryptage à partir du tableau des sessions. S`il n`y a pas de session, il ne renvoie simplement qu`une nouvelle clé aléatoire pour le cryptage.

Fonction Getkey ():

Fonction privée getkey ($ id) {si (!Isset ($ this->key_stmt)) {$ this->key_stmt = $ ceci->dB->préparer("Sélectionnez Session_Key des sessions où ID = ? Limite 1") -} $ ceci->key_stmt->bind_param (`s`, $ id) - $ ceci->key_stmt->exécuter () - $ ceci->key_stmt->store_result () - si ($ ceci->key_stmt->num_rows == 1) {$ Ceci->key_stmt->BIND_RESULT ($ clé) - $ ceci->key_stmt->fetch () - retour $ key-} else {$ Random_key = hachage (`SHA512`, UNIQID (MT_RAND (1, MT_GETRANDMAX ()), True)) - Retour $ Random_Key-}}

11. Créer des fonctions de chiffrement et de déchiffrement.
Ces fonctions cryptées les données des sessions, elles utilisent une clé de cryptage de la base de données différente pour chaque session. Nous n`utilisons pas directement cette clé dans le cryptage, mais nous l`utilisons pour rendre le hachage de clé encore plus aléatoire.

chiffrer () et déchiffrer () fonctions:

Fonction privée chiffrer ($ données, $ clé) {$ sel = `ch!swe!réregu7w6bedup7usuduh9thed2chege * ewr4n39 = e @ rasp7c-ph @ pH `- $ clé = substr (hachage (` SHA256 `, $ sel.$ clé.$ sel), 0, 32) - $ IV_SIZE = mcrypt_get_iv_size (mrypt_rijndael_256, mcrypt_mode_ecb) - $ IV = mcrypt_create_iv ($ iv_size, mcrypt_rand) - $ crypted = base64_encode (mecrypt_rijndael_256, clé de clé, $ clé, $ iv) ) -return $ crypté-} Fonction privée décrypte ($ données, $ clé) {$ sel = `ch!swe!réregu7w6bedup7usuduh9thed2chege * ewr4n39 = e @ rasp7c-ph @ pH `- $ clé = substr (hachage (` SHA256 `, $ sel.$ clé.$ sel), 0, 32) - $ IV_SIZE = mcrypt_get_iv_size (mcrypt_rijndael_256, mcrypt_mode_ecb) - $ iv = mcrypt_create_iv ($ iv_size, mcrypt_rand) - $ déchiffré = mcrypt_decrypt (mcrypt_rijndael_256, $ clé, base64_decode ($ données), $ IV ) - $ déchiffré = rtrim ($ déchiffré, " 0") -return $ $ déchiffré-}

12. Classe de fin.
Ici, nous mettons simplement la fin des classes Supports bouclés:

Classe de fin:

Méthode 3 sur 3:

Créer des pages avec des sessions

1. Utiliser des sessions avec le gestionnaire de session personnalisé.
Vous trouverez ci-dessous comment vous commencerez une nouvelle session- vous devrez inclure cela sur chaque page que vous souhaitez accéder aux sessions, Utilisez-le au lieu de session_start ()-

Démarrer une session:

exiger (`session.classer.php `) - $ session = nouvelle session () - // définie sur true si vous utilisez https $ session->start_session (`_ s`, faux) - $ _ session ["quelque chose"] = `une valeur.`-Eho $ _Session ["quelque chose"]-

Comment créer un système de gestion de session sécurisé dans php et mysql

Pas

Conseils