3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2017 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
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 \***************************************************************************/
14 * Gestion de l'authentification par sessions
15 * à utiliser pour valider l'accès (bloquant)
16 * ou pour reconnaître un utilisateur (non bloquant)
18 * @package SPIP\Core\Session
21 if (!defined('_ECRIRE_INC_VERSION')) {
26 $GLOBALS['visiteur_session'] = array(); # globale decrivant l'auteur
29 * 3 actions sur les sessions, selon le type de l'argument:
31 * - numerique: efface toutes les sessions de l'auteur (retour quelconque)
32 * - tableau: cree une session pour l'auteur decrit et retourne l'identifiant
33 * - bool: predicat de validite de la session indiquee par le cookie
35 * @uses supprimer_sessions()
36 * @uses ajouter_session()
37 * @uses verifier_session()
39 * @param int|array|bool $auteur
40 * @return bool|null|void
42 function inc_session_dist($auteur = false) {
43 if (is_numeric($auteur)) {
44 return supprimer_sessions($auteur, $auteur > 0);
46 if (is_array($auteur)) {
47 return ajouter_session($auteur);
49 return verifier_session($auteur);
56 * Supprimer toutes les vieilles sessions d'un auteur
58 * Cette fonction efface toutes les sessions appartenant a l'auteur
59 * On en profite pour effacer toutes les sessions
60 * creees il y a plus de 4*_RENOUVELLE_ALEA
61 * Tenir compte de l'ancien format ou les noms commencaient par "session_"
62 * et du meme coup des repertoires plats
64 * Attention : id_auteur peut etre negatif (cas des auteurs temporaires pendant le dump)
66 * @uses verifier_session()
67 * @uses fichier_session()
68 * @uses spip_session()
70 * @param int $id_auteur
71 * Identifiant d'auteur dont on veut supprimer les sessions
73 * Supprimer aussi les vieilles sessions des autres auteurs ?
74 * @param bool $actives
75 * false pour ne pas supprimer les sessions valides de $id_auteur.
76 * false revient donc a uniquement supprimer les vieilles sessions !
78 function supprimer_sessions($id_auteur, $toutes = true, $actives = true) {
80 spip_log("supprimer sessions auteur $id_auteur", "session");
81 if ($toutes or $id_auteur !== $GLOBALS['visiteur_session']['id_auteur']) {
82 if ($dir = opendir(_DIR_SESSIONS
)) {
83 $t = time() - (4 * _RENOUVELLE_ALEA
);
84 while (($f = readdir($dir)) !== false) {
85 if (preg_match(",^[^\d-]*(-?\d+)_\w{32}\.php[3]?$,", $f, $regs)) {
86 $f = _DIR_SESSIONS
. $f;
87 if (($actives and $regs[1] == $id_auteur) or ($t > filemtime($f))) {
95 spip_unlink(fichier_session('alea_ephemere', true));
98 // forcer le recalcul de la session courante
103 * Ajoute une session pour l'auteur décrit par un tableau issu d'un SELECT-SQL
105 * @uses spip_php_session_start() Lorsque session anonyme
107 * @uses preparer_ecriture_session()
108 * @uses fichier_session()
109 * @uses ecrire_fichier_session()
111 * @param array $auteur
112 * Description de la session de l'auteur. Peut contenir (par exemple)
113 * les clés : id_auteur, nom, login, email, statut, lang, ...
114 * @return bool|string
116 function ajouter_session($auteur) {
117 // Si le client a deja une session valide pour son id_auteur
118 // on conserve le meme fichier
120 // Attention un visiteur peut avoir une session et un id=0,
121 // => ne pas melanger les sessions des differents visiteurs
122 $id_auteur = isset($auteur['id_auteur']) ?
intval($auteur['id_auteur']) : 0;
124 // Si ce n'est pas un inscrit (les inscrits ont toujours des choses en session)
125 // on va vérifier s'il y a vraiment des choses à écrire
127 // On supprime les données de base pour voir le contenu réel de la session
128 $auteur_verif = $auteur;
129 if (isset($auteur_verif['id_auteur'])) {
130 unset($auteur_verif['id_auteur']);
132 if (isset($auteur_verif['hash_env'])) {
133 unset($auteur_verif['hash_env']);
135 if (isset($auteur_verif['ip_change'])) {
136 unset($auteur_verif['ip_change']);
138 if (isset($auteur_verif['date_session'])) {
139 unset($auteur_verif['date_session']);
142 // Les variables vraiment nulle ne sont pas à prendre en compte non plus
143 foreach ($auteur_verif as $variable => $valeur) {
144 if ($valeur === null) {
145 unset($auteur_verif[$variable]);
149 // Si après ça la session est vide alors on supprime l'éventuel fichier et on arrête là
150 if (!$auteur_verif) {
151 if (isset($_COOKIE['spip_session']) and isset($_SESSION[$_COOKIE['spip_session']])) {
152 unset($_SESSION[$_COOKIE['spip_session']]);
154 if (isset($_COOKIE['spip_session'])) {
155 unset($_COOKIE['spip_session']);
162 if (!isset($_COOKIE['spip_session'])
163 or !preg_match(',^' . $id_auteur . '_,', $_COOKIE['spip_session'])
165 $_COOKIE['spip_session'] = $id_auteur . '_' . md5(uniqid(rand(), true));
168 // Maintenant on sait qu'on a des choses à écrire
169 // On s'assure d'avoir au moins ces valeurs
170 $auteur['id_auteur'] = $id_auteur;
171 if (!isset($auteur['hash_env'])) {
172 $auteur['hash_env'] = hash_env();
174 if (!isset($auteur['ip_change'])) {
175 $auteur['ip_change'] = false;
178 if (!isset($auteur['date_session'])) {
179 $auteur['date_session'] = time();
181 if (isset($auteur['prefs']) and is_string($auteur['prefs'])) {
182 $auteur['prefs'] = unserialize($auteur['prefs']);
185 $fichier_session = "";
187 // les sessions anonymes sont stockees dans $_SESSION
189 spip_php_session_start();
190 $_SESSION[$_COOKIE['spip_session']] = preparer_ecriture_session($auteur);
192 $fichier_session = fichier_session('alea_ephemere');
193 if (!ecrire_fichier_session($fichier_session, $auteur)) {
194 spip_log('Echec ecriture fichier session ' . $fichier_session, "session" . _LOG_HS
);
195 include_spip('inc/minipres');
199 // verifier et limiter le nombre maxi de sessions
200 // https://core.spip.net/issues/3807
201 lister_sessions_auteur($id_auteur);
204 // poser le cookie de session SPIP
205 include_spip('inc/cookie');
206 $duree = definir_duree_cookie_session($auteur);
207 spip_setcookie( 'spip_session', $_COOKIE['spip_session'], time() +
$duree);
208 spip_log("ajoute session $fichier_session cookie $duree", "session");
210 // Si on est admin, poser le cookie de correspondance
211 if (!function_exists('autoriser')) {
212 include_spip('inc/autoriser');
214 if (autoriser('ecrire','','',$auteur) and _DUREE_COOKIE_ADMIN
) {
215 spip_setcookie('spip_admin', '@' . $auteur['login'], time() +
max(_DUREE_COOKIE_ADMIN
, $duree));
216 } // sinon le supprimer ...
218 spip_setcookie('spip_admin', '', 1);
221 # on en profite pour purger les vieilles sessions anonymes abandonnees
222 # supprimer_sessions(0, true, false);
224 return $_COOKIE['spip_session'];
228 * Calcule le temps de validité en seconde du cookie de session
230 * Applique un coefficient multiplicateur à la durée de renouvellement de l'alea
231 * (noté ensuite `dR`, valant 12h par défaut) pour déterminer la durée du cookie.
233 * - `2 * dR`, par défaut
234 * - `20 * dR` si le visiteur a indiqué vouloir rester connecté quelques jours
235 * sur le formulaire de login (la clé `cookie` vaut alors `oui`)
236 * - `c * dR`, un coeficient défini manuellement si la clé `cookie` est numérique
238 * @param array $auteur
239 * Description de l'auteur
243 function definir_duree_cookie_session($auteur) {
245 if (isset($auteur['cookie'])) {
246 if (is_numeric($auteur['cookie'])) {
247 $coef = $auteur['cookie'];
252 return (int)(_RENOUVELLE_ALEA
* $coef);
256 * Vérifie si le cookie spip_session indique une session valide
258 * Si oui, la decrit dans le tableau $visiteur_session et retourne id_auteur
259 * La rejoue si IP change puis accepte le changement si $change=true
261 * Retourne false en cas d'echec, l'id_auteur de la session si defini, null sinon
263 * @uses spip_php_session_start() Si session anonyme
264 * @uses fichier_session()
265 * @uses ajouter_session()
268 * @param bool $change
269 * @return bool|int|null
271 function verifier_session($change = false) {
272 // si pas de cookie, c'est fichu
273 if (!isset($_COOKIE['spip_session'])) {
277 $fichier_session = "";
279 // est-ce une session anonyme ?
280 if (!intval($_COOKIE['spip_session'])) {
281 spip_php_session_start();
282 if (!isset($_SESSION[$_COOKIE['spip_session']]) or !is_array($_SESSION[$_COOKIE['spip_session']])) {
285 $GLOBALS['visiteur_session'] = $_SESSION[$_COOKIE['spip_session']];
287 // Tester avec alea courant
288 $fichier_session = fichier_session('alea_ephemere', true);
289 if ($fichier_session and @file_exists
($fichier_session)) {
290 include($fichier_session);
292 // Sinon, tester avec alea precedent
293 $fichier_session = fichier_session('alea_ephemere_ancien', true);
294 if (!$fichier_session or !@file_exists
($fichier_session)) {
298 // Renouveler la session avec l'alea courant
299 include($fichier_session);
300 spip_log('renouvelle session ' . $GLOBALS['visiteur_session']['id_auteur'], "session");
301 spip_unlink($fichier_session);
302 ajouter_session($GLOBALS['visiteur_session']);
306 // Compatibilite ascendante : auteur_session est visiteur_session si
307 // c'est un auteur SPIP authentifie (tandis qu'un visiteur_session peut
308 // n'etre qu'identifie, sans aucune authentification).
310 if (isset($GLOBALS['visiteur_session']['id_auteur']) and $GLOBALS['visiteur_session']['id_auteur']) {
311 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
315 // Si l'adresse IP change, inc/presentation mettra une balise image
316 // avec un URL de rappel demandant a changer le nom de la session.
317 // Seul celui qui a l'IP d'origine est rejoue
318 // ainsi un eventuel voleur de cookie ne pourrait pas deconnecter
319 // sa victime, mais se ferait deconnecter par elle.
320 if (hash_env() != $GLOBALS['visiteur_session']['hash_env']) {
321 if (!$GLOBALS['visiteur_session']['ip_change']) {
322 define('_SESSION_REJOUER', true);
323 $GLOBALS['visiteur_session']['ip_change'] = true;
324 ajouter_session($GLOBALS['visiteur_session']);
327 spip_log("session non rejouee, vol de cookie ?", "session");
332 spip_log("rejoue session $fichier_session " . $_COOKIE['spip_session'], "session");
333 if ($fichier_session) {
334 spip_unlink($fichier_session);
336 $GLOBALS['visiteur_session']['ip_change'] = false;
337 unset($_COOKIE['spip_session']);
338 ajouter_session($GLOBALS['visiteur_session']);
342 // Si la session a ete initiee il y a trop longtemps, elle est annulee
343 if (isset($GLOBALS['visiteur_session'])
344 and defined('_AGE_SESSION_MAX')
345 and _AGE_SESSION_MAX
> 0
346 and time() - @$GLOBALS['visiteur_session']['date_session'] > _AGE_SESSION_MAX
348 unset($GLOBALS['visiteur_session']);
353 return is_numeric($GLOBALS['visiteur_session']['id_auteur'])
354 ?
$GLOBALS['visiteur_session']['id_auteur']
359 * Lire une valeur dans la session SPIP
362 * @example `$login = session_get('login');`
365 * Clé dont on souhaite la valeur
367 * Valeur, si trouvée, `null` sinon.
369 function session_get($nom) {
370 return isset($GLOBALS['visiteur_session'][$nom]) ?
$GLOBALS['visiteur_session'][$nom] : null;
375 * Ajouter une donnée dans la session SPIP
378 * @uses ajouter_session()
379 * @uses terminer_actualiser_sessions() Ajoute la fonction en fin de hit.
385 function session_set($nom, $val = null) {
386 static $remove = array();
387 static $actualiser_sessions = false;
388 if ($nom === false) {
393 if (!isset($GLOBALS['visiteur_session'][$nom])) {
396 unset($GLOBALS['visiteur_session'][$nom]);
399 // On ajoute la valeur dans la globale
400 $GLOBALS['visiteur_session'][$nom] = $val;
402 $remove = array_diff($remove, array($nom));
405 if (!$actualiser_sessions) {
406 // il faut creer la session si on en a pas, la premiere fois
407 ajouter_session($GLOBALS['visiteur_session']);
408 // in register la fonction qui mettra a jour toutes les sessions en fin de hit
409 register_shutdown_function('terminer_actualiser_sessions');
410 $actualiser_sessions = true;
415 * En fin de hit, synchroniser toutes les sessions
417 * @uses actualiser_sessions()
419 function terminer_actualiser_sessions() {
420 // se remettre dans le dossier de travail au cas ou Apache a change
422 // recuperer les variables a effacer
423 $remove = session_set(false);
424 // mettre a jour toutes les sessions
425 actualiser_sessions($GLOBALS['visiteur_session'], $remove);
430 * Mettre à jour les sessions existantes pour un auteur
432 * Quand on modifie une fiche auteur on appelle cette fonction qui va
433 * mettre à jour les fichiers de session de l'auteur en question.
434 * (auteurs identifiés seulement)
436 * Ne concerne que les sessions des auteurs loges (id_auteur connu)
438 * @uses ajouter_session()
439 * @uses fichier_session()
441 * @uses preparer_ecriture_session()
442 * @uses ecrire_fichier_session()
444 * @param array $auteur
445 * @param array $supprimer_cles
446 * Liste des clés à supprimer des tableaux de sessions
448 function actualiser_sessions($auteur, $supprimer_cles = array()) {
450 $id_auteur = isset($auteur['id_auteur']) ?
intval($auteur['id_auteur']) : 0;
451 $id_auteur_courant = isset($GLOBALS['visiteur_session']['id_auteur']) ?
intval($GLOBALS['visiteur_session']['id_auteur']) : 0;
453 // si l'auteur est celui de la session courante, verifier/creer la session si besoin
454 $fichier_session_courante = "";
455 if ($id_auteur == $id_auteur_courant) {
456 $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
457 ajouter_session($auteur);
459 $fichier_session_courante = fichier_session('alea_ephemere');
463 // si session anonyme on ne fait rien d'autre ici : les sessions anonymes sont non partagees
468 // les préférences sont désérialisées, toujours.
469 if (isset($auteur['prefs']) and is_string($auteur['prefs'])) {
470 $auteur['prefs'] = unserialize($auteur['prefs']);
473 // memoriser l'auteur courant (celui qui modifie la fiche)
474 $sauve = $GLOBALS['visiteur_session'];
476 // .. mettre a jour les sessions de l'auteur cible
477 // attention au $ final pour ne pas risquer d'embarquer un .php.jeton temporaire
478 // cree par une ecriture concurente d'une session (fichier atomique temporaire)
479 $sessions = lister_sessions_auteur($id_auteur);
481 // 1ere passe : lire et fusionner les sessions
482 foreach ($sessions as $session) {
483 $GLOBALS['visiteur_session'] = array();
484 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
485 if ($session !== $fichier_session_courante
486 and @file_exists
($session)
488 include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
490 $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
494 // supprimer les eventuelles cles dont on ne veut plus
495 foreach ($supprimer_cles as $cle) {
496 unset($auteur[$cle]);
499 $auteur_session = preparer_ecriture_session($auteur);
501 // seconde passe : ecrire les sessions qui ne sont pas a jour
502 foreach ($sessions as $session) {
503 $GLOBALS['visiteur_session'] = array();
504 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
505 if (@file_exists
($session)) {
506 include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
508 // est-ce que cette session est a mettre a jour ?
509 if ($auteur_session != $GLOBALS['visiteur_session']) {
510 ecrire_fichier_session($session, $auteur);
515 if ($id_auteur == $id_auteur_courant) {
516 $GLOBALS['visiteur_session'] = $auteur;
517 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
519 // restaurer l'auteur courant
520 $GLOBALS['visiteur_session'] = $sauve;
526 * lister les sessions et en verifier le nombre maxi
527 * en supprimant les plus anciennes si besoin
528 * https://core.spip.net/issues/3807
530 * @param int $id_auteur
534 function lister_sessions_auteur($id_auteur, $nb_max = null) {
536 if (is_null($nb_max)) {
537 if (!defined('_NB_SESSIONS_MAX')) {
538 define('_NB_SESSIONS_MAX', 100);
540 $nb_max = _NB_SESSIONS_MAX
;
543 // liste des sessions
544 $sessions = preg_files(_DIR_SESSIONS
, '/' . $id_auteur . '_.*\.php$');
546 // si on en a plus que la limite, supprimer les plus vieilles
547 // si ce ne sont pas des sessions anonymes car elles sont alors chacune differentes
549 and count($sessions) > $nb_max) {
551 // limiter le nombre de sessions ouvertes par un auteur
552 // filemtime sur les sessions
553 $sessions = array_flip($sessions);
555 // 1ere passe : lire les filemtime
556 foreach ($sessions as $session => $z) {
557 if ($d = @filemtime
($session)
559 $sessions[$session] = $d;
561 $sessions[$session] = 0;
565 // les plus anciennes en premier
568 $sessions = array_keys($sessions);
569 while (count($sessions) > $nb_max) {
570 $session = array_shift($sessions);
580 * Préparer le tableau de session avant écriture
582 * Nettoyage de quelques variables sensibles, et appel d'un pipeline
584 * @pipeline preparer_fichier_session
585 * @param array $auteur
588 function preparer_ecriture_session($auteur) {
591 // ne pas enregistrer ces elements de securite
592 // dans le fichier de session
593 unset($auteur['pass']);
594 unset($auteur['htpass']);
595 unset($auteur['low_sec']);
596 unset($auteur['alea_actuel']);
597 unset($auteur['alea_futur']);
599 $auteur = pipeline('preparer_fichier_session', array('args' => array('row' => $row), 'data' => $auteur));
601 // ne pas enregistrer les valeurs vraiment nulle dans le fichier
602 foreach ($auteur as $variable => $valeur) {
603 if ($valeur === null) {
604 unset($auteur[$variable]);
612 * Ecrire le fichier d'une session
614 * @param string $fichier
615 * @param array $auteur
618 function ecrire_fichier_session($fichier, $auteur) {
620 $auteur = preparer_ecriture_session($auteur);
622 // enregistrer les autres donnees du visiteur
623 $texte = "<" . "?php\n";
624 foreach ($auteur as $var => $val) {
625 $texte .= '$GLOBALS[\'visiteur_session\'][\'' . $var . '\'] = '
626 . var_export($val, true) . ";\n";
628 $texte .= "?" . ">\n";
630 return ecrire_fichier($fichier, $texte);
635 * Calculer le nom du fichier session
637 * @param string $alea
638 * @param bool $tantpis
641 function fichier_session($alea, $tantpis = false) {
643 include_spip('inc/acces');
646 if (empty($GLOBALS['meta'][$alea])) {
648 spip_log("fichier session ($tantpis): $alea indisponible", "session");
649 include_spip('inc/minipres');
653 return ''; // echec mais $tanpis
655 $repertoire = sous_repertoire(_DIR_SESSIONS
, '', false, $tantpis);
656 $c = $_COOKIE['spip_session'];
658 return $repertoire . intval($c) . '_' . md5($c . ' ' . $GLOBALS['meta'][$alea]) . '.php';
664 * Code à insérer par `inc/presentation` pour rejouer la session
667 * Pourquoi insère-t-on le src par js et non directement en statique dans le HTML ?
668 * Historiquement, inséré par une balise `<script>` en r424
669 * puis modifié par `<img>` statique + js en r427
671 * @see action_cookie_dist() qui sera appelé
675 function rejouer_session() {
676 return '<img src="' . generer_url_action('cookie', 'change_session=oui', true) . '" width="0" height="0" alt="" />';
681 * On verifie l'IP et le nom du navigateur
685 function hash_env() {
691 return $res = md5($GLOBALS['ip'] . (isset($_SERVER['HTTP_USER_AGENT']) ?
$_SERVER['HTTP_USER_AGENT'] : ''));
696 * Démarre une session PHP si ce n'est pas déjà fait.
698 * @link http://php.net/manual/fr/function.session-start.php
699 * @uses is_php_session_started()
700 * @return bool True si une session PHP est ouverte.
702 function spip_php_session_start() {
703 if (!is_php_session_started()) {
704 return session_start();
711 * Indique si une sesssion PHP est active
713 * @link http://php.net/manual/fr/function.session-status.php#113468
714 * @return bool true si une session PHP est active
716 function is_php_session_started() {
717 if (php_sapi_name() !== 'cli') {
718 if (PHP_VERSION_ID
>= 50400) {
719 return session_status() === PHP_SESSION_ACTIVE ?
true : false;
721 return session_id() === '' ?
false : true;