www/ecrire/inc/session.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 /*
  16  * Gestion de l'authentification par sessions
  17  * a utiliser pour valider l'acces (bloquant)
  18  * ou pour reconnaitre un utilisateur (non bloquant)
  19  *
  20  */
  21
  22 $GLOBALS['visiteur_session'] = ''; # globale decrivant l'auteur
  23
  24 /**
  25  * 3 actions sur les sessions, selon le type de l'argument:
  26  * - numerique: efface toutes les sessions de l'auteur (retour quelconque)
  27  * - tableau: cree une session pour l'auteur decrit et retourne l'identifiant
  28  * - bool: predicat de validite de la session indiquee par le cookie
  29  *
  30  * http://doc.spip.org/@inc_session_dist
  31  *
  32  * @param int|array|bool $auteur
  33  * @return bool|null|void
  34  */
  35 function inc_session_dist($auteur=false)
  36 {
  37         if (is_numeric($auteur))
  38                 return supprimer_sessions($auteur, $auteur > 0);
  39         else if (is_array($auteur))
  40                 return ajouter_session($auteur);
  41         else
  42                 return verifier_session($auteur);
  43 }
  44
  45
  46 /**
  47  * Supprimer toutes les vieilles sessions d'un auteur
  48  *
  49  * Cette fonction efface toutes les sessions appartenant a l'auteur
  50  * On en profite pour effacer toutes les sessions
  51  * creees il y a plus de 4*_RENOUVELLE_ALEA
  52  * Tenir compte de l'ancien format ou les noms commencaient par "session_"
  53  * et du meme coup des repertoires plats
  54  * Attention : id_auteur peut etre negatif (cas des auteurs temporaires pendant le dump)
  55  *
  56  * http://doc.spip.org/@supprimer_sessions
  57  *
  58  * @param int $id_auteur
  59  *              Identifiant d'auteur dont on veut supprimer les sessions
  60  * @param bool $toutes
  61  *              Supprimer aussi les vieilles sessions des autres auteurs ?
  62  * @param bool $actives
  63  *              false pour ne pas supprimer les sessions valides de $id_auteur.
  64  *              false revient donc a uniquement supprimer les vieilles sessions !
  65  */
  66 function supprimer_sessions($id_auteur, $toutes=true, $actives=true) {
  67
  68         spip_log("supprimer sessions auteur $id_auteur");
  69         if ($toutes OR $id_auteur!==$GLOBALS['visiteur_session']['id_auteur']) {
  70                 if ($dir = opendir(_DIR_SESSIONS)){
  71                         $t = time()  - (4*_RENOUVELLE_ALEA);
  72                         while(($f = readdir($dir)) !== false) {
  73                                 if (preg_match(",^[^\d-]*(-?\d+)_\w{32}\.php[3]?$,", $f, $regs)){
  74                                         $f = _DIR_SESSIONS . $f;
  75                                         if (($actives AND $regs[1] == $id_auteur) OR ($t > filemtime($f)))
  76                                                 spip_unlink($f);
  77                                 }
  78                         }
  79                 }
  80         }
  81         else {
  82                 verifier_session();
  83                 spip_unlink(fichier_session('alea_ephemere', true));
  84         }
  85
  86         // forcer le recalcul de la session courante
  87         spip_session(true);
  88 }
  89
  90 /**
  91  * Ajoute une session pour l'auteur decrit par un tableau issu d'un SELECT-SQL
  92  *
  93  * http://doc.spip.org/@ajouter_session
  94  *
  95  * @param array $auteur
  96  * @return bool|string
  97  */
  98 function ajouter_session($auteur) {
  99         // Si le client a deja une session valide pour son id_auteur
 100         // on conserve le meme fichier
 101
 102         // Attention un visiteur peut avoir une session et un id=0,
 103         // => ne pas melanger les sessions des differents visiteurs
 104         $id_auteur = intval($auteur['id_auteur']);
 105         if (!isset($_COOKIE['spip_session'])
 106         OR !preg_match(',^'.$id_auteur.'_,', $_COOKIE['spip_session']))
 107                 $_COOKIE['spip_session'] = $id_auteur.'_'.md5(uniqid(rand(),true));
 108
 109         $fichier_session = fichier_session('alea_ephemere');
 110
 111         // Si ce n'est pas un inscrit (les inscrits ont toujours des choses en session)
 112         // on va vérifier s'il y a vraiment des choses à écrire
 113         if (!$id_auteur){
 114                 // On supprime les données de base pour voir le contenu réel de la session
 115                 $auteur_verif = $auteur;
 116                 if (isset($auteur_verif['id_auteur'])) unset($auteur_verif['id_auteur']);
 117                 if (isset($auteur_verif['hash_env'])) unset($auteur_verif['hash_env']);
 118                 if (isset($auteur_verif['ip_change'])) unset($auteur_verif['ip_change']);
 119                 if (isset($auteur_verif['date_session'])) unset($auteur_verif['date_session']);
 120
 121                 // Les variables vraiment nulle ne sont pas à prendre en compte non plus
 122                 foreach($auteur_verif as $variable=>$valeur){
 123                         if ($valeur === null){
 124                                 unset($auteur_verif[$variable]);
 125                         }
 126                 }
 127
 128                 // Si après ça la session est vide alors on supprime l'éventuel fichier et on arrête là
 129                 if (!$auteur_verif){
 130                         if (@file_exists($fichier_session)) spip_unlink($fichier_session);
 131                         return false;
 132                 }
 133         }
 134
 135         // Maintenant on sait qu'on a des choses à écrire
 136         // On s'assure d'avoir au moins ces valeurs
 137         $auteur['id_auteur'] = $id_auteur;
 138         if (!isset($auteur['hash_env'])) $auteur['hash_env'] = hash_env();
 139         if (!isset($auteur['ip_change'])) $auteur['ip_change'] = false;
 140
 141         if (!isset($auteur['date_session'])) $auteur['date_session'] = time();
 142         if (is_string($auteur['prefs']))
 143                 $auteur['prefs'] = unserialize($auteur['prefs']);
 144
 145         if (!ecrire_fichier_session($fichier_session, $auteur)) {
 146                 spip_log('Echec ecriture fichier session '.$fichier_session,_LOG_HS);
 147                 include_spip('inc/minipres');
 148                 echo minipres();
 149                 exit;
 150         } else {
 151                 include_spip('inc/cookie');
 152                 $duree = _RENOUVELLE_ALEA *
 153                   (!isset($auteur['cookie'])
 154                         ? 2 : (is_numeric($auteur['cookie'])
 155                                 ? $auteur['cookie'] : 20));
 156                 spip_setcookie(
 157                         'spip_session',
 158                         $_COOKIE['spip_session'],
 159                         time() + $duree
 160                         );
 161                 spip_log("ajoute session $fichier_session cookie $duree");
 162
 163                 # on en profite pour purger les vieilles sessions abandonnees
 164                 supprimer_sessions(0, true, false);
 165
 166                 return $_COOKIE['spip_session'];
 167         }
 168 }
 169
 170
 171 /**
 172  * Verifie si le cookie spip_session indique une session valide.
 173  * Si oui, la decrit dans le tableau $visiteur_session et retourne id_auteur
 174  * La rejoue si IP change puis accepte le changement si $change=true
 175  *
 176  * Retourne false en cas d'echec, l'id_auteur de la session si defini, null sinon
 177  *
 178  * http://doc.spip.org/@verifier_session
 179  *
 180  * @param bool $change
 181  * @return bool|int|null
 182  */
 183 function verifier_session($change=false) {
 184         // si pas de cookie, c'est fichu
 185
 186         if (!isset($_COOKIE['spip_session']))
 187                 return false;
 188
 189         // Tester avec alea courant
 190         $fichier_session = fichier_session('alea_ephemere', true);
 191
 192         if ($fichier_session AND @file_exists($fichier_session)) {
 193                 include($fichier_session);
 194         } else {
 195                 // Sinon, tester avec alea precedent
 196                 $fichier_session = fichier_session('alea_ephemere_ancien', true);
 197                 if (!$fichier_session OR !@file_exists($fichier_session)) return false;
 198
 199                 // Renouveler la session avec l'alea courant
 200                 include($fichier_session);
 201                 spip_log('renouvelle session '.$GLOBALS['visiteur_session']['id_auteur']);
 202                 spip_unlink($fichier_session);
 203                 ajouter_session($GLOBALS['visiteur_session']);
 204         }
 205
 206         // Compatibilite ascendante : auteur_session est visiteur_session si
 207         // c'est un auteur SPIP authentifie (tandis qu'un visiteur_session peut
 208         // n'etre qu'identifie, sans aucune authentification).
 209
 210         if ($GLOBALS['visiteur_session']['id_auteur'])
 211                 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
 212
 213
 214         // Si l'adresse IP change, inc/presentation mettra une balise image
 215         // avec un URL de rappel demandant a changer le nom de la session.
 216         // Seul celui qui a l'IP d'origine est rejoue
 217         // ainsi un eventuel voleur de cookie ne pourrait pas deconnecter
 218         // sa victime, mais se ferait deconnecter par elle.
 219         if (hash_env() != $GLOBALS['visiteur_session']['hash_env']) {
 220                 if (!$GLOBALS['visiteur_session']['ip_change']) {
 221                         define('_SESSION_REJOUER',rejouer_session());
 222                         $GLOBALS['visiteur_session']['ip_change'] = true;
 223                         ajouter_session($GLOBALS['visiteur_session']);
 224                 } else if ($change) {
 225                         spip_log("session non rejouee, vol de cookie ?");
 226                 }
 227         } else if ($change) {
 228                 spip_log("rejoue session $fichier_session ".$_COOKIE['spip_session']);
 229                 spip_unlink($fichier_session);
 230                 $GLOBALS['visiteur_session']['ip_change'] = false;
 231                 unset($_COOKIE['spip_session']);
 232                 ajouter_session($GLOBALS['visiteur_session']);
 233         }
 234
 235         // Si la session a ete initiee il y a trop longtemps, elle est annulee
 236         if (isset($GLOBALS['visiteur_session'])
 237         AND defined('_AGE_SESSION_MAX')
 238         AND _AGE_SESSION_MAX > 0
 239         AND time() - @$GLOBALS['visiteur_session']['date_session'] > _AGE_SESSION_MAX) {
 240                 unset($GLOBALS['visiteur_session']);
 241                 return false;
 242         }
 243
 244         return is_numeric($GLOBALS['visiteur_session']['id_auteur'])
 245                 ? $GLOBALS['visiteur_session']['id_auteur']
 246                 : null;
 247 }
 248
 249 /**
 250  * Lire une valeur dans la session SPIP
 251  *
 252  * http://doc.spip.org/@session_get
 253  *
 254  * @param string $nom
 255  * @return mixed
 256  */
 257 function session_get($nom) {
 258         return isset($GLOBALS['visiteur_session'][$nom]) ? $GLOBALS['visiteur_session'][$nom] : null;
 259 }
 260
 261
 262 /**
 263  * Ajouter une donnee dans la session SPIP
 264  * http://doc.spip.org/@session_set
 265  *
 266  * @param string $nom
 267  * @param null $val
 268  * @return void
 269  */
 270 function session_set($nom, $val=null) {
 271         // On ajoute la valeur dans la globale
 272         $GLOBALS['visiteur_session'][$nom] = $val;
 273
 274         ajouter_session($GLOBALS['visiteur_session']);
 275         actualiser_sessions($GLOBALS['visiteur_session']);
 276 }
 277
 278 /**
 279  * Mettre a jour les sessions existantes pour un auteur
 280  * Quand on modifie une fiche auteur on appelle cette fonction qui va
 281  * mettre a jour les fichiers de session de l'auteur en question.
 282  * (auteurs identifies seulement)
 283  *
 284  * http://doc.spip.org/@actualiser_sessions
 285  *
 286  * @param array $auteur
 287  */
 288 function actualiser_sessions($auteur) {
 289         if (!$id_auteur = intval($auteur['id_auteur']))
 290                 return;
 291
 292         // memoriser l'auteur courant (celui qui modifie la fiche)
 293         $sauve = $GLOBALS['visiteur_session'];
 294
 295         // .. mettre a jour les sessions de l'auteur cible
 296         // attention au $ final pour ne pas risquer d'embarquer un .php.jeton temporaire
 297         // cree par une ecriture concurente d'une session (fichier atomique temporaire)
 298         $sessions = preg_files(_DIR_SESSIONS, '/'.$id_auteur.'_.*\.php$');
 299         foreach($sessions as $session) {
 300                 $GLOBALS['visiteur_session'] = array();
 301                 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
 302                 if (@file_exists($session)){
 303                         include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
 304
 305                         $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
 306                         ecrire_fichier_session($session, $auteur);
 307                 }
 308         }
 309
 310         // restaurer l'auteur courant
 311         $GLOBALS['visiteur_session'] = $sauve;
 312
 313         // si c'est le meme, rafraichir les valeurs
 314         if (isset($sauve['id_auteur']) and $auteur['id_auteur'] == $sauve['id_auteur'])
 315                 verifier_session();
 316 }
 317
 318 /**
 319  * Ecrire le fichier d'une session
 320  *
 321  * http://doc.spip.org/@ecrire_fichier_session
 322  *
 323  * @param string $fichier
 324  * @param array $auteur
 325  * @return bool
 326  */
 327 function ecrire_fichier_session($fichier, $auteur) {
 328
 329         $row = $auteur;
 330
 331         // ne pas enregistrer ces elements de securite
 332         // dans le fichier de session
 333         unset($auteur['pass']);
 334         unset($auteur['htpass']);
 335         unset($auteur['low_sec']);
 336         unset($auteur['alea_actuel']);
 337         unset($auteur['alea_futur']);
 338
 339         $auteur = pipeline('preparer_fichier_session',array('args'=>array('row'=>$row),'data'=>$auteur));
 340
 341         // ne pas enregistrer les valeurs vraiment nulle dans le fichier
 342         foreach($auteur as $variable=>$valeur){
 343                 if ($valeur === null){
 344                         unset($auteur[$variable]);
 345                 }
 346         }
 347
 348         // enregistrer les autres donnees du visiteur
 349         $texte = "<"."?php\n";
 350         foreach ($auteur as $var => $val)
 351                 $texte .= '$GLOBALS[\'visiteur_session\'][\''.$var.'\'] = '
 352                         . var_export($val,true).";\n";
 353         $texte .= "?".">\n";
 354
 355         return ecrire_fichier($fichier, $texte);
 356 }
 357
 358
 359 /**
 360  * Calculer le nom du fichier session
 361  *
 362  * http://doc.spip.org/@fichier_session
 363  *
 364  * @param string $alea
 365  * @param bool $tantpis
 366  * @return string
 367  */
 368 function fichier_session($alea, $tantpis=false) {
 369
 370         if (!isset($GLOBALS['meta'][$alea])) {
 371                 include_spip('base/abstract_sql');
 372                 $GLOBALS['meta'][$alea]  = sql_getfetsel('valeur', 'spip_meta', "nom=" . sql_quote($alea), '','', '', '', '', 'continue');
 373         }
 374
 375         if (!$GLOBALS['meta'][$alea]) {
 376                 if (!$tantpis) {
 377                         spip_log("fichier session ($tantpis): $alea indisponible");
 378                         include_spip('inc/minipres');
 379                         echo minipres();
 380                 }
 381                 return ''; // echec mais $tanpis
 382         }
 383         else {
 384                 $repertoire = sous_repertoire(_DIR_SESSIONS,'',false,$tantpis);
 385                 $c = $_COOKIE['spip_session'];
 386                 return $repertoire . intval($c) .'_' . md5($c.' '.$GLOBALS['meta'][$alea]). '.php';
 387         }
 388 }
 389
 390
 391 /**
 392  * Code a inserer par inc/presentation pour rejouer la session
 393  * Voir action/cookie qui sera appele.
 394  * Pourquoi insere-t-on le src par js et non directement en statique dans le HTML ?
 395  * Historiquement, insere par une balise <script> en r424
 396  * puis modifie par <img> statique + js en r427
 397  *
 398  * http://doc.spip.org/@rejouer_session
 399  *
 400  * @return string
 401  */
 402 function rejouer_session()
 403 {
 404         return '<img src="'.generer_url_action('cookie','change_session=oui', true).'" width="0" height="0" alt="" />';
 405 }
 406
 407
 408 /**
 409  * On verifie l'IP et le nom du navigateur
 410  *
 411  * http://doc.spip.org/@hash_env
 412  *
 413  * @return string
 414  */
 415 function hash_env() {
 416   static $res ='';
 417   if ($res) return $res;
 418   return $res = md5($GLOBALS['ip'] . $_SERVER['HTTP_USER_AGENT']);
 419 }
 420
 421 ?>