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'] = array(); # 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         $nb_files = 0;
  69         $nb_max_files = (defined('_MAX_NB_SESSIONS_OUVERTES')?_MAX_NB_SESSIONS_OUVERTES:1000);
  70         spip_log("supprimer sessions auteur $id_auteur");
  71         if ($toutes OR $id_auteur!==$GLOBALS['visiteur_session']['id_auteur']) {
  72                 if ($dir = opendir(_DIR_SESSIONS)){
  73                         $t = $_SERVER['REQUEST_TIME']  - (4*_RENOUVELLE_ALEA); // 48h par defaut
  74                         $t_short = $_SERVER['REQUEST_TIME']  - max(_RENOUVELLE_ALEA/4,3*3600); // 3h par defaut
  75                         while(($f = readdir($dir)) !== false) {
  76                                 $nb_files++;
  77                                 if (preg_match(",^[^\d-]*(-?\d+)_\w{32}\.php[3]?$,", $f, $regs)){
  78                                         $f = _DIR_SESSIONS . $f;
  79                                         if (($actives AND $regs[1] == $id_auteur) OR ($t > filemtime($f))){
  80                                                 spip_unlink($f);
  81                                         }
  82                                         // si il y a trop de sessions ouvertes, on purge les sessions anonymes de plus de 3H
  83                                         // cd http://core.spip.org/issues/3276
  84                                         elseif($nb_files>$nb_max_files AND !intval($regs[1]) AND ($t_short > filemtime($f))){
  85                                                 spip_unlink($f);
  86                                         }
  87                                 }
  88                         }
  89                 }
  90         }
  91         else {
  92                 verifier_session();
  93                 spip_unlink(fichier_session('alea_ephemere', true));
  94         }
  95
  96         // forcer le recalcul de la session courante
  97         spip_session(true);
  98 }
  99
 100 /**
 101  * Ajoute une session pour l'auteur decrit par un tableau issu d'un SELECT-SQL
 102  *
 103  * http://doc.spip.org/@ajouter_session
 104  *
 105  * @param array $auteur
 106  * @return bool|string
 107  */
 108 function ajouter_session($auteur) {
 109         // Si le client a deja une session valide pour son id_auteur
 110         // on conserve le meme fichier
 111
 112         // Attention un visiteur peut avoir une session et un id=0,
 113         // => ne pas melanger les sessions des differents visiteurs
 114         $id_auteur = intval($auteur['id_auteur']);
 115
 116         // Si ce n'est pas un inscrit (les inscrits ont toujours des choses en session)
 117         // on va vérifier s'il y a vraiment des choses à écrire
 118         if (!$id_auteur){
 119                 // On supprime les données de base pour voir le contenu réel de la session
 120                 $auteur_verif = $auteur;
 121                 if (isset($auteur_verif['id_auteur'])) unset($auteur_verif['id_auteur']);
 122                 if (isset($auteur_verif['hash_env'])) unset($auteur_verif['hash_env']);
 123                 if (isset($auteur_verif['ip_change'])) unset($auteur_verif['ip_change']);
 124                 if (isset($auteur_verif['date_session'])) unset($auteur_verif['date_session']);
 125
 126                 // Les variables vraiment nulle ne sont pas à prendre en compte non plus
 127                 foreach($auteur_verif as $variable=>$valeur){
 128                         if ($valeur === null){
 129                                 unset($auteur_verif[$variable]);
 130                         }
 131                 }
 132                 // Si après ça la session est vide et qu'on a pas de cookie session, on arrete
 133                 if (!$auteur_verif AND !isset($_COOKIE['spip_session'])){
 134                         return false;
 135                 }
 136         }
 137
 138         if (!isset($_COOKIE['spip_session'])
 139           OR !preg_match(',^'.$id_auteur.'_,', $_COOKIE['spip_session'])){
 140                 $_COOKIE['spip_session'] = $id_auteur.'_'.md5(uniqid(rand(),true));
 141         }
 142
 143         $fichier_session = fichier_session('alea_ephemere');
 144
 145         // Si la session est vide alors on supprime l'éventuel fichier et on arrête là
 146         if (!$id_auteur AND !$auteur_verif){
 147                 if (@file_exists($fichier_session)) spip_unlink($fichier_session);
 148                 // unset le COOKIE de session
 149                 // car il est pris en compte dans spip_session() qui va croire a tort qu'on est pas un visiteur anonyme
 150                 unset($_COOKIE['spip_session']);
 151                 return false;
 152         }
 153
 154         // Maintenant on sait qu'on a des choses à écrire
 155         // On s'assure d'avoir au moins ces valeurs
 156         $auteur['id_auteur'] = $id_auteur;
 157         if (!isset($auteur['hash_env'])) $auteur['hash_env'] = hash_env();
 158         if (!isset($auteur['ip_change'])) $auteur['ip_change'] = false;
 159
 160         if (!isset($auteur['date_session'])) $auteur['date_session'] = time();
 161         if (is_string($auteur['prefs']))
 162                 $auteur['prefs'] = unserialize($auteur['prefs']);
 163
 164         if (!ecrire_fichier_session($fichier_session, $auteur)) {
 165                 spip_log('Echec ecriture fichier session '.$fichier_session,_LOG_HS);
 166                 include_spip('inc/minipres');
 167                 echo minipres();
 168                 exit;
 169         } else {
 170                 include_spip('inc/cookie');
 171                 $duree = _RENOUVELLE_ALEA *
 172                   (!isset($auteur['cookie'])
 173                         ? 2 : (is_numeric($auteur['cookie'])
 174                                 ? $auteur['cookie'] : 20));
 175                 spip_setcookie(
 176                         'spip_session',
 177                         $_COOKIE['spip_session'],
 178                         time() + $duree
 179                         );
 180                 spip_log("ajoute session $fichier_session cookie $duree");
 181
 182                 # on en profite pour purger les vieilles sessions abandonnees
 183                 supprimer_sessions(0, true, false);
 184
 185                 return $_COOKIE['spip_session'];
 186         }
 187 }
 188
 189
 190 /**
 191  * Verifie si le cookie spip_session indique une session valide.
 192  * Si oui, la decrit dans le tableau $visiteur_session et retourne id_auteur
 193  * La rejoue si IP change puis accepte le changement si $change=true
 194  *
 195  * Retourne false en cas d'echec, l'id_auteur de la session si defini, null sinon
 196  *
 197  * http://doc.spip.org/@verifier_session
 198  *
 199  * @param bool $change
 200  * @return bool|int|null
 201  */
 202 function verifier_session($change=false) {
 203         // si pas de cookie, c'est fichu
 204
 205         if (!isset($_COOKIE['spip_session']))
 206                 return false;
 207
 208         // Tester avec alea courant
 209         $fichier_session = fichier_session('alea_ephemere', true);
 210
 211         if ($fichier_session AND @file_exists($fichier_session)) {
 212                 include($fichier_session);
 213         } else {
 214                 // Sinon, tester avec alea precedent
 215                 $fichier_session = fichier_session('alea_ephemere_ancien', true);
 216                 if (!$fichier_session OR !@file_exists($fichier_session)) return false;
 217
 218                 // Renouveler la session avec l'alea courant
 219                 include($fichier_session);
 220                 spip_log('renouvelle session '.$GLOBALS['visiteur_session']['id_auteur']);
 221                 spip_unlink($fichier_session);
 222                 ajouter_session($GLOBALS['visiteur_session']);
 223         }
 224
 225         // Compatibilite ascendante : auteur_session est visiteur_session si
 226         // c'est un auteur SPIP authentifie (tandis qu'un visiteur_session peut
 227         // n'etre qu'identifie, sans aucune authentification).
 228
 229         if ($GLOBALS['visiteur_session']['id_auteur'])
 230                 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
 231
 232
 233         // Si l'adresse IP change, inc/presentation mettra une balise image
 234         // avec un URL de rappel demandant a changer le nom de la session.
 235         // Seul celui qui a l'IP d'origine est rejoue
 236         // ainsi un eventuel voleur de cookie ne pourrait pas deconnecter
 237         // sa victime, mais se ferait deconnecter par elle.
 238         if (hash_env() != $GLOBALS['visiteur_session']['hash_env']) {
 239                 if (!$GLOBALS['visiteur_session']['ip_change']) {
 240                         define('_SESSION_REJOUER',rejouer_session());
 241                         $GLOBALS['visiteur_session']['ip_change'] = true;
 242                         ajouter_session($GLOBALS['visiteur_session']);
 243                 } else if ($change) {
 244                         spip_log("session non rejouee, vol de cookie ?");
 245                 }
 246         } else if ($change) {
 247                 spip_log("rejoue session $fichier_session ".$_COOKIE['spip_session']);
 248                 spip_unlink($fichier_session);
 249                 $GLOBALS['visiteur_session']['ip_change'] = false;
 250                 unset($_COOKIE['spip_session']);
 251                 ajouter_session($GLOBALS['visiteur_session']);
 252         }
 253
 254         // Si la session a ete initiee il y a trop longtemps, elle est annulee
 255         if (isset($GLOBALS['visiteur_session'])
 256         AND defined('_AGE_SESSION_MAX')
 257         AND _AGE_SESSION_MAX > 0
 258         AND time() - @$GLOBALS['visiteur_session']['date_session'] > _AGE_SESSION_MAX) {
 259                 unset($GLOBALS['visiteur_session']);
 260                 return false;
 261         }
 262
 263         return is_numeric($GLOBALS['visiteur_session']['id_auteur'])
 264                 ? $GLOBALS['visiteur_session']['id_auteur']
 265                 : null;
 266 }
 267
 268 /**
 269  * Lire une valeur dans la session SPIP
 270  *
 271  * http://doc.spip.org/@session_get
 272  *
 273  * @param string $nom
 274  * @return mixed
 275  */
 276 function session_get($nom) {
 277         return isset($GLOBALS['visiteur_session'][$nom]) ? $GLOBALS['visiteur_session'][$nom] : null;
 278 }
 279
 280
 281 /**
 282  * Ajouter une donnee dans la session SPIP
 283  * http://doc.spip.org/@session_set
 284  *
 285  * @param string $nom
 286  * @param null $val
 287  * @return void
 288  */
 289 function session_set($nom, $val=null) {
 290
 291         if (is_null($val)){
 292                 // rien a faire
 293                 if (!isset($GLOBALS['visiteur_session'][$nom])) return;
 294                 unset($GLOBALS['visiteur_session'][$nom]);
 295         }
 296         else {
 297                 // On ajoute la valeur dans la globale
 298                 $GLOBALS['visiteur_session'][$nom] = $val;
 299         }
 300
 301         ajouter_session($GLOBALS['visiteur_session']);
 302         actualiser_sessions($GLOBALS['visiteur_session']);
 303 }
 304
 305 /**
 306  * Mettre a jour les sessions existantes pour un auteur
 307  * Quand on modifie une fiche auteur on appelle cette fonction qui va
 308  * mettre a jour les fichiers de session de l'auteur en question.
 309  * (auteurs identifies seulement)
 310  *
 311  * http://doc.spip.org/@actualiser_sessions
 312  *
 313  * @param array $auteur
 314  */
 315 function actualiser_sessions($auteur) {
 316         if (!$id_auteur = intval($auteur['id_auteur']))
 317                 return;
 318
 319         // memoriser l'auteur courant (celui qui modifie la fiche)
 320         $sauve = $GLOBALS['visiteur_session'];
 321
 322         // .. mettre a jour les sessions de l'auteur cible
 323         // attention au $ final pour ne pas risquer d'embarquer un .php.jeton temporaire
 324         // cree par une ecriture concurente d'une session (fichier atomique temporaire)
 325         $sessions = preg_files(_DIR_SESSIONS, '/'.$id_auteur.'_.*\.php$');
 326         foreach($sessions as $session) {
 327                 $GLOBALS['visiteur_session'] = array();
 328                 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
 329                 if (@file_exists($session)){
 330                         include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
 331
 332                         $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
 333                         ecrire_fichier_session($session, $auteur);
 334                 }
 335         }
 336
 337         // restaurer l'auteur courant
 338         $GLOBALS['visiteur_session'] = $sauve;
 339
 340         // si c'est le meme, rafraichir les valeurs
 341         if (isset($sauve['id_auteur']) and $auteur['id_auteur'] == $sauve['id_auteur'])
 342                 verifier_session();
 343 }
 344
 345 /**
 346  * Ecrire le fichier d'une session
 347  *
 348  * http://doc.spip.org/@ecrire_fichier_session
 349  *
 350  * @param string $fichier
 351  * @param array $auteur
 352  * @return bool
 353  */
 354 function ecrire_fichier_session($fichier, $auteur) {
 355
 356         $row = $auteur;
 357
 358         // ne pas enregistrer ces elements de securite
 359         // dans le fichier de session
 360         unset($auteur['pass']);
 361         unset($auteur['htpass']);
 362         unset($auteur['low_sec']);
 363         unset($auteur['alea_actuel']);
 364         unset($auteur['alea_futur']);
 365
 366         $auteur = pipeline('preparer_fichier_session',array('args'=>array('row'=>$row),'data'=>$auteur));
 367
 368         // ne pas enregistrer les valeurs vraiment nulle dans le fichier
 369         foreach($auteur as $variable=>$valeur){
 370                 if ($valeur === null){
 371                         unset($auteur[$variable]);
 372                 }
 373         }
 374
 375         // enregistrer les autres donnees du visiteur
 376         $texte = "<"."?php\n";
 377         foreach ($auteur as $var => $val)
 378                 $texte .= '$GLOBALS[\'visiteur_session\'][\''.$var.'\'] = '
 379                         . var_export($val,true).";\n";
 380         $texte .= "?".">\n";
 381
 382         return ecrire_fichier($fichier, $texte);
 383 }
 384
 385
 386 /**
 387  * Calculer le nom du fichier session
 388  *
 389  * http://doc.spip.org/@fichier_session
 390  *
 391  * @param string $alea
 392  * @param bool $tantpis
 393  * @return string
 394  */
 395 function fichier_session($alea, $tantpis=false) {
 396
 397         if (!isset($GLOBALS['meta'][$alea])) {
 398                 include_spip('base/abstract_sql');
 399                 $GLOBALS['meta'][$alea]  = sql_getfetsel('valeur', 'spip_meta', "nom=" . sql_quote($alea), '','', '', '', '', 'continue');
 400         }
 401
 402         if (!$GLOBALS['meta'][$alea]) {
 403                 if (!$tantpis) {
 404                         spip_log("fichier session ($tantpis): $alea indisponible");
 405                         include_spip('inc/minipres');
 406                         echo minipres();
 407                 }
 408                 return ''; // echec mais $tanpis
 409         }
 410         else {
 411                 $repertoire = sous_repertoire(_DIR_SESSIONS,'',false,$tantpis);
 412                 $c = $_COOKIE['spip_session'];
 413                 return $repertoire . intval($c) .'_' . md5($c.' '.$GLOBALS['meta'][$alea]). '.php';
 414         }
 415 }
 416
 417
 418 /**
 419  * Code a inserer par inc/presentation pour rejouer la session
 420  * Voir action/cookie qui sera appele.
 421  * Pourquoi insere-t-on le src par js et non directement en statique dans le HTML ?
 422  * Historiquement, insere par une balise <script> en r424
 423  * puis modifie par <img> statique + js en r427
 424  *
 425  * http://doc.spip.org/@rejouer_session
 426  *
 427  * @return string
 428  */
 429 function rejouer_session()
 430 {
 431         return '<img src="'.generer_url_action('cookie','change_session=oui', true).'" width="0" height="0" alt="" />';
 432 }
 433
 434
 435 /**
 436  * On verifie l'IP et le nom du navigateur
 437  *
 438  * http://doc.spip.org/@hash_env
 439  *
 440  * @return string
 441  */
 442 function hash_env() {
 443   static $res ='';
 444   if ($res) return $res;
 445   return $res = md5($GLOBALS['ip'] . $_SERVER['HTTP_USER_AGENT']);
 446 }
 447
 448 ?>