www/ecrire/inc/auth.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   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 /**
  14  * Gestion des authentifications
  15  *
  16  * @package SPIP\Core\Authentification
  17  **/
  18
  19 if (!defined('_ECRIRE_INC_VERSION')) {
  20         return;
  21 }
  22
  23 include_spip('base/abstract_sql');
  24
  25 /**
  26  * Teste l'authentification d'un visiteur
  27  *
  28  * Cette fonction ne fait pas l'authentification en soit ;
  29  * elle vérifie simplement qu'une personne est connectée ou non.
  30  *
  31  * @return array|int|string
  32  *  - URL de connexion si on ne sait rien (pas de cookie, pas Auth_user);
  33  *  - un tableau si visiteur sans droit (tableau = sa ligne SQL)
  34  *  - code numerique d'erreur SQL
  35  *  - une chaîne vide si autorisation à pénétrer dans l'espace privé.
  36  */
  37 function inc_auth_dist() {
  38         $row = auth_mode();
  39
  40         if ($row) {
  41                 return auth_init_droits($row);
  42         }
  43
  44         if (!$GLOBALS['connect_login']) {
  45                 return auth_a_loger();
  46         }
  47
  48         // Cas ou l'auteur a ete identifie mais on n'a pas d'info sur lui
  49         // C'est soit parce que la base est inutilisable,
  50         // soit parce que la table des auteurs a changee (restauration etc)
  51         // Pas la peine d'insister.
  52         // Renvoyer le nom fautif et une URL de remise a zero
  53
  54         if (spip_connect()) {
  55                 return array(
  56                         'login' => $GLOBALS['connect_login'],
  57                         'site' => generer_url_public('', 'action=logout&amp;logout=prive')
  58                 );
  59         }
  60
  61         $n = intval(sql_errno());
  62         spip_log("Erreur base de donnees $n " . sql_error());
  63
  64         return $n ? $n : 1;
  65 }
  66
  67 /**
  68  * fonction appliquee par ecrire/index sur le resultat de la precedente
  69  * en cas de refus de connexion.
  70  * Retourne un message a afficher ou redirige illico.
  71  *
  72  * @param  $raison
  73  * @return array|string
  74  */
  75 function auth_echec($raison) {
  76         include_spip('inc/minipres');
  77         include_spip('inc/headers');
  78         // pas authentifie. Pourquoi ?
  79         if (is_string($raison)) {
  80                 // redirection vers une page d'authentification
  81                 // on ne revient pas de cette fonction
  82                 // sauf si pb de header
  83                 $raison = redirige_formulaire($raison);
  84         } elseif (is_int($raison)) {
  85                 // erreur SQL a afficher
  86                 $raison = minipres(
  87                         _T('info_travaux_titre'),
  88                         _T('titre_probleme_technique') . '<p><tt>' . sql_errno() . ' ' . sql_error() . '</tt></p>'
  89                 );
  90         } elseif (@$raison['statut']) {
  91                 // un simple visiteur n'a pas acces a l'espace prive
  92                 spip_log('connexion refusee a ' . @$raison['id_auteur']);
  93                 $raison = minipres(_T('avis_erreur_connexion'), _T('avis_erreur_visiteur'));
  94         } else {
  95                 // auteur en fin de droits ...
  96                 $h = $raison['site'];
  97                 $raison = minipres(
  98                         _T('avis_erreur_connexion'),
  99                         '<br /><br /><p>'
 100                         . _T('texte_inc_auth_1', array('auth_login' => $raison['login']))
 101                         . " <a href='$h'>"
 102                         . _T('texte_inc_auth_2')
 103                         . '</a>'
 104                         . _T('texte_inc_auth_3')
 105                 );
 106         }
 107
 108         return $raison;
 109 }
 110
 111 /**
 112  * Retourne la description d'un authentifie par cookie ou http_auth
 113  * Et affecte la globale $connect_login
 114  *
 115  * @return array|bool|string
 116  */
 117 function auth_mode() {
 118         //
 119         // Initialiser variables (eviter hacks par URL)
 120         //
 121         $GLOBALS['connect_login'] = '';
 122         $id_auteur = null;
 123         $GLOBALS['auth_can_disconnect'] = false;
 124
 125         //
 126         // Recuperer les donnees d'identification
 127         //
 128         include_spip('inc/session');
 129         // Session valide en cours ?
 130         if (isset($_COOKIE['spip_session'])) {
 131                 $session = charger_fonction('session', 'inc');
 132                 if ($id_auteur = $session()
 133                         or $id_auteur === 0 // reprise sur restauration
 134                 ) {
 135                         $GLOBALS['auth_can_disconnect'] = true;
 136                         $GLOBALS['connect_login'] = session_get('login');
 137                 } else {
 138                         unset($_COOKIE['spip_session']);
 139                 }
 140         }
 141
 142         // Essayer auth http si significatif
 143         // (ignorer les login d'intranet independants de spip)
 144         if (!$GLOBALS['ignore_auth_http']) {
 145                 if (
 146                         (isset($_SERVER['PHP_AUTH_USER']) and isset($_SERVER['PHP_AUTH_PW'])
 147                                 and $r = lire_php_auth($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']))
 148                         or
 149                         // Si auth http differtente de basic, PHP_AUTH_PW
 150                         // est indisponible mais tentons quand meme pour
 151                         // autocreation via LDAP
 152                         (isset($_SERVER['REMOTE_USER'])
 153                                 and $r = lire_php_auth($_SERVER['PHP_AUTH_USER'] = $_SERVER['REMOTE_USER'], ''))
 154                 ) {
 155                         if (!$id_auteur) {
 156                                 $_SERVER['PHP_AUTH_PW'] = '';
 157                                 $GLOBALS['auth_can_disconnect'] = true;
 158                                 $GLOBALS['visiteur_session'] = $r;
 159                                 $GLOBALS['connect_login'] = session_get('login');
 160                                 $id_auteur = $r['id_auteur'];
 161                         } else {
 162                                 // cas de la session en plus de PHP_AUTH
 163                                 /*                                if ($id_auteur != $r['id_auteur']){
 164                                         spip_log("vol de session $id_auteur" . join(', ', $r));
 165                                 unset($_COOKIE['spip_session']);
 166                                 $id_auteur = '';
 167                                 } */
 168                         }
 169                 } else {
 170                         // Authentification .htaccess old style, car .htaccess semble
 171                         // souvent definir *aussi* PHP_AUTH_USER et PHP_AUTH_PW
 172                         if (isset($_SERVER['REMOTE_USER'])) {
 173                                 $GLOBALS['connect_login'] = $_SERVER['REMOTE_USER'];
 174                         }
 175                 }
 176         }
 177
 178         $where = (is_numeric($id_auteur)
 179                 /*AND $id_auteur>0*/ // reprise lors des restaurations
 180         ) ?
 181                 "id_auteur=$id_auteur" :
 182                 (!strlen($GLOBALS['connect_login']) ? '' : 'login=' . sql_quote($GLOBALS['connect_login'], '', 'text'));
 183
 184         if (!$where) {
 185                 return '';
 186         }
 187
 188         // Trouver les autres infos dans la table auteurs.
 189         // le champ 'quand' est utilise par l'agenda
 190
 191         return sql_fetsel('*, en_ligne AS quand', 'spip_auteurs', "$where AND statut!='5poubelle'");
 192 }
 193
 194 /**
 195  * Initialisation des globales pour tout l'espace privé si visiteur connu
 196  *
 197  * Le tableau global visiteur_session contient toutes les infos pertinentes et
 198  * à jour (tandis que `$visiteur_session` peut avoir des valeurs un peu datées
 199  * s'il est pris dans le fichier de session)
 200  *
 201  * Les plus utiles sont aussi dans les variables simples ci-dessus
 202  * si la globale est vide ce n'est pas un tableau, on la force pour empêcher un warning.
 203  *
 204  * @param array $row
 205  * @return array|string|bool
 206  */
 207 function auth_init_droits($row) {
 208
 209         include_spip('inc/autoriser');
 210         if (!autoriser('loger', '', 0, $row)) {
 211                 return false;
 212         }
 213
 214
 215         if ($row['statut'] == 'nouveau') {
 216                 include_spip('action/inscrire_auteur');
 217                 $row = confirmer_statut_inscription($row);
 218         }
 219
 220         $GLOBALS['connect_id_auteur'] = $row['id_auteur'];
 221         $GLOBALS['connect_login'] = $row['login'];
 222         $GLOBALS['connect_statut'] = $row['statut'];
 223
 224         $GLOBALS['visiteur_session'] = array_merge((array)$GLOBALS['visiteur_session'], $row);
 225
 226         // au cas ou : ne pas memoriser les champs sensibles
 227         unset($GLOBALS['visiteur_session']['pass']);
 228         unset($GLOBALS['visiteur_session']['htpass']);
 229         unset($GLOBALS['visiteur_session']['alea_actuel']);
 230         unset($GLOBALS['visiteur_session']['alea_futur']);
 231         unset($GLOBALS['visiteur_session']['ldap_password']);
 232
 233         // creer la session au besoin
 234         if (!isset($_COOKIE['spip_session'])) {
 235                 $session = charger_fonction('session', 'inc');
 236                 $spip_session = $session($row);
 237         }
 238
 239         // reinjecter les preferences_auteur apres le reset de spip_session
 240         // car utilisees au retour par auth_loger()
 241         $r = @unserialize($row['prefs']);
 242         $GLOBALS['visiteur_session']['prefs'] = ($r ? $r : array());
 243         // si prefs pas definies, les definir par defaut
 244         if (!isset($GLOBALS['visiteur_session']['prefs']['couleur'])) {
 245                 $GLOBALS['visiteur_session']['prefs']['couleur'] = 9;
 246                 $GLOBALS['visiteur_session']['prefs']['display'] = 2;
 247                 $GLOBALS['visiteur_session']['prefs']['display_navigation'] = 'navigation_avec_icones';
 248                 $GLOBALS['visiteur_session']['prefs']['display_outils'] = 'oui';
 249         }
 250
 251         $GLOBALS['visiteur_session'] = pipeline(
 252                 'preparer_visiteur_session',
 253                 array('args' => array('row' => $row),
 254                 'data' => $GLOBALS['visiteur_session'])
 255         );
 256
 257         // Etablir les droits selon le codage attendu
 258         // dans ecrire/index.php ecrire/prive.php
 259
 260         // Pas autorise a acceder a ecrire ? renvoyer le tableau
 261         // A noter : le premier appel a autoriser() a le bon gout
 262         // d'initialiser $GLOBALS['visiteur_session']['restreint'],
 263         // qui ne figure pas dans le fichier de session
 264
 265         if (!autoriser('ecrire')) {
 266                 return $row;
 267         }
 268
 269         // autoriser('ecrire') ne laisse passer que les Admin et les Redac
 270
 271         auth_trace($row);
 272
 273         // Administrateurs
 274         if (in_array($GLOBALS['connect_statut'], explode(',', _STATUT_AUTEUR_RUBRIQUE))) {
 275                 if (isset($GLOBALS['visiteur_session']['restreint']) and is_array($GLOBALS['visiteur_session']['restreint'])) {
 276                         $GLOBALS['connect_id_rubrique'] = $GLOBALS['visiteur_session']['restreint'];
 277                 }
 278                 if ($GLOBALS['connect_statut'] == '0minirezo') {
 279                         $GLOBALS['connect_toutes_rubriques'] = !$GLOBALS['connect_id_rubrique'];
 280                 }
 281         }
 282
 283         // Pour les redacteurs, inc_version a fait l'initialisation minimale
 284
 285         return ''; // i.e. pas de pb.
 286 }
 287
 288 /**
 289  * Retourne l'url de connexion
 290  *
 291  * @return string
 292  */
 293 function auth_a_loger() {
 294         $redirect = generer_url_public('login', 'url=' . rawurlencode(self('&', true)), '&');
 295
 296         // un echec au "bonjour" (login initial) quand le statut est
 297         // inconnu signale sans doute un probleme de cookies
 298         if (isset($_GET['bonjour'])) {
 299                 $redirect = parametre_url(
 300                         $redirect,
 301                         'var_erreur',
 302                         (!isset($GLOBALS['visiteur_session']['statut'])
 303                                 ? 'cookie'
 304                                 : 'statut'
 305                         ),
 306                         '&'
 307                 );
 308         }
 309
 310         return $redirect;
 311 }
 312
 313 /**
 314  * Tracer en base la date de dernière connexion de l'auteur
 315  *
 316  * @pipeline_appel trig_auth_trace
 317  *
 318  * @param array $row
 319  * @param null|string $date
 320  */
 321 function auth_trace($row, $date = null) {
 322         // Indiquer la connexion. A la minute pres ca suffit.
 323         if (!is_numeric($connect_quand = isset($row['quand']) ? $row['quand'] : '')) {
 324                 $connect_quand = strtotime($connect_quand);
 325         }
 326
 327         if (is_null($date)) {
 328                 $date = date('Y-m-d H:i:s');
 329         }
 330
 331         if (abs(strtotime($date) - $connect_quand) >= 60) {
 332                 sql_updateq('spip_auteurs', array('en_ligne' => $date), 'id_auteur=' . intval($row['id_auteur']));
 333                 $row['en_ligne'] = $date;
 334         }
 335
 336         pipeline('trig_auth_trace', array('args' => array('row' => $row, 'date' => $date)));
 337 }
 338
 339
 340 /** ----------------------------------------------------------------------------
 341  * API Authentification, gestion des identites centralisees
 342  */
 343
 344 /**
 345  * Fonction privée d'aiguillage des fonctions d'authentification
 346  *
 347  * Charge une fonction d'authentification présente dans un répertoire `auth/`.
 348  * Ainsi, utiliser `auth_administrer('informer_login', array('spip', ...)` appellera
 349  * `auth_spip_informer_login()` de `ecrire/auth/spip.php`.
 350  *
 351  * @uses charger_fonction()
 352  *
 353  * @param string $fonction
 354  *        Nom de la fonction d'authentification
 355  * @param array $args
 356  *        Le premier élément du tableau doit être le nom du système d'authentification
 357  *        choisi, tel que `spip` (par défaut) ou encore `ldap`.
 358  * @param mixed $defaut
 359  * @return mixed
 360  */
 361 function auth_administrer($fonction, $args, $defaut = false) {
 362         $auth_methode = array_shift($args);
 363         $auth_methode = $auth_methode ? $auth_methode : 'spip'; // valeur par defaut au cas ou
 364         if ($auth = charger_fonction($auth_methode, 'auth', true)
 365                 and function_exists($f = "auth_{$auth_methode}_$fonction")
 366         ) {
 367                 $res = call_user_func_array($f, $args);
 368         } else {
 369                 $res = $defaut;
 370         }
 371         $res = pipeline(
 372                 'auth_administrer',
 373                 array(
 374                         'args' => array(
 375                                 'fonction' => $fonction,
 376                                 'methode' => $auth_methode,
 377                                 'args' => $args
 378                         ),
 379                         'data' => $res
 380                 )
 381         );
 382         return $res;
 383 }
 384
 385 /**
 386  * Pipeline pour inserer du contenu dans le formulaire de login
 387  *
 388  * @param array $flux
 389  * @return array
 390  */
 391 function auth_formulaire_login($flux) {
 392         foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 393                 $flux = auth_administrer('formulaire_login', array($methode, $flux), $flux);
 394         }
 395
 396         return $flux;
 397 }
 398
 399
 400 /**
 401  * Retrouver le login interne lie a une info login saisie
 402  * la saisie peut correspondre a un login delegue
 403  * qui sera alors converti en login interne apres verification
 404  *
 405  * @param string $login
 406  * @param string $serveur
 407  * @return string/bool
 408  */
 409 function auth_retrouver_login($login, $serveur = '') {
 410         if (!spip_connect($serveur)) {
 411                 include_spip('inc/minipres');
 412                 echo minipres(_T('info_travaux_titre'), _T('titre_probleme_technique'));
 413                 exit;
 414         }
 415
 416         foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 417                 if ($auteur = auth_administrer('retrouver_login', array($methode, $login, $serveur))) {
 418                         return $auteur;
 419                 }
 420         }
 421
 422         return false;
 423 }
 424
 425 /**
 426  * informer sur un login
 427  * Ce dernier transmet le tableau ci-dessous a la fonction JS informer_auteur
 428  * Il est invoque par la fonction JS actualise_auteur via la globale JS
 429  * page_auteur=#URL_PAGE{informer_auteur} dans le squelette login
 430  * N'y aurait-il pas plus simple ?
 431  *
 432  * @param string $login
 433  * @param string $serveur
 434  * @return array
 435  */
 436 function auth_informer_login($login, $serveur = '') {
 437         if (!$login
 438                 or !$login_base = auth_retrouver_login($login, $serveur)
 439                 or !$row = sql_fetsel('*', 'spip_auteurs', 'login=' . sql_quote($login_base, $serveur, 'text'), '', '', '', '', $serveur)
 440         ) {
 441
 442                 // generer de fausses infos, mais credibles, pour eviter une attaque
 443                 // https://core.spip.net/issues/1758 + https://core.spip.net/issues/3691
 444                 include_spip('inc/securiser_action');
 445                 $fauxalea1 = md5('fauxalea' . secret_du_site() . $login . floor(date('U') / 86400));
 446                 $fauxalea2 = md5('fauxalea' . secret_du_site() . $login . ceil(date('U') / 86400));
 447
 448                 $row = array(
 449                         'login' => $login,
 450                         'cnx' => '0',
 451                         'logo' => '',
 452                         'alea_actuel' => substr_replace($fauxalea1, '.', 24, 0),
 453                         'alea_futur' => substr_replace($fauxalea2, '.', 24, 0)
 454                 );
 455
 456                 // permettre d'autoriser l'envoi de password non crypte lorsque
 457                 // l'auteur n'est pas (encore) declare dans SPIP, par exemple pour les cas
 458                 // de premiere authentification via SPIP a une autre application.
 459                 if (defined('_AUTORISER_AUTH_FAIBLE') and _AUTORISER_AUTH_FAIBLE) {
 460                         $row['alea_actuel'] = '';
 461                         $row['alea_futur'] = '';
 462                 }
 463
 464                 return $row;
 465         }
 466
 467         $prefs = unserialize($row['prefs']);
 468         $infos = array(
 469                 'id_auteur' => $row['id_auteur'],
 470                 'login' => $row['login'],
 471                 'cnx' => ($prefs['cnx'] == 'perma') ? '1' : '0',
 472                 'logo' => recuperer_fond('formulaires/inc-logo_auteur', $row),
 473         );
 474
 475         // desactiver le hash md5 si pas auteur spip ?
 476         if ($row['source'] !== 'spip') {
 477                 $row['alea_actuel'] = '';
 478                 $row['alea_futur'] = '';
 479         }
 480         verifier_visiteur();
 481
 482         return auth_administrer('informer_login', array($row['source'], $infos, $row, $serveur), $infos);
 483 }
 484
 485
 486 /**
 487  * Essayer les differentes sources d'authenfication dans l'ordre specifie.
 488  * S'en souvenir dans visiteur_session['auth']
 489  *
 490  * @param string $login
 491  * @param string $password
 492  * @param string $serveur
 493  * @return mixed
 494  */
 495 function auth_identifier_login($login, $password, $serveur = '') {
 496         $erreur = '';
 497         foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 498                 if ($auth = charger_fonction($methode, 'auth', true)) {
 499                         $auteur = $auth($login, $password, $serveur);
 500                         if (is_array($auteur) and count($auteur)) {
 501                                 spip_log("connexion de $login par methode $methode");
 502                                 $auteur['auth'] = $methode;
 503                                 return $auteur;
 504                         } elseif (is_string($auteur)) {
 505                                 $erreur .= "$auteur ";
 506                         }
 507                 }
 508         }
 509
 510         return $erreur;
 511 }
 512
 513 /**
 514  * Fournir une url de retour apres login par un SSO
 515  * pour finir l'authentification
 516  *
 517  * @param string $auth_methode
 518  * @param string $login
 519  * @param string $redirect
 520  * @param string $serveur
 521  * @return string
 522  */
 523 function auth_url_retour_login($auth_methode, $login, $redirect = '', $serveur = '') {
 524         $securiser_action = charger_fonction('securiser_action', 'inc');
 525         return $securiser_action('auth', "$auth_methode/$login", $redirect, true);
 526 }
 527
 528 /**
 529  * Terminer l'action d'authentification d'un auteur
 530  *
 531  * @uses auth_administrer()
 532  *
 533  * @param string $auth_methode
 534  * @param string $login
 535  * @param string $serveur
 536  * @return mixed
 537  */
 538 function auth_terminer_identifier_login($auth_methode, $login, $serveur = '') {
 539         $args = func_get_args();
 540         $auteur = auth_administrer('terminer_identifier_login', $args);
 541         return $auteur;
 542 }
 543
 544 /**
 545  * Loger un auteur suite a son identification
 546  *
 547  * @param array $auteur
 548  * @return bool
 549  */
 550 function auth_loger($auteur) {
 551         if (!is_array($auteur) or !count($auteur)) {
 552                 return false;
 553         }
 554
 555         // initialiser et poser le cookie de session
 556         unset($_COOKIE['spip_session']);
 557         if (auth_init_droits($auteur) === false) {
 558                 return false;
 559         }
 560
 561         // initialiser les prefs
 562         $p = $GLOBALS['visiteur_session']['prefs'];
 563         $p['cnx'] = (isset($auteur['cookie']) and $auteur['cookie'] == 'oui') ? 'perma' : '';
 564
 565         sql_updateq(
 566                 'spip_auteurs',
 567                 array('prefs' => serialize($p)),
 568                 'id_auteur=' . intval($auteur['id_auteur'])
 569         );
 570
 571         //  bloquer ici le visiteur qui tente d'abuser de ses droits
 572         verifier_visiteur();
 573         return true;
 574 }
 575
 576 /**
 577  * Déconnexion de l'auteur
 578  *
 579  * @uses action_logout_dist()
 580  * return void
 581  **/
 582 function auth_deloger() {
 583         $logout = charger_fonction('logout', 'action');
 584         $logout();
 585 }
 586
 587 /**
 588  * Tester la possibilité de modifier le login d'authentification
 589  * pour la méthode donnée
 590  *
 591  * @uses auth_administrer()
 592  *
 593  * @param string $auth_methode
 594  * @param string $serveur
 595  * @return bool
 596  */
 597 function auth_autoriser_modifier_login($auth_methode, $serveur = '') {
 598         $args = func_get_args();
 599         return auth_administrer('autoriser_modifier_login', $args);
 600 }
 601
 602 /**
 603  * Verifier la validite d'un nouveau login pour modification
 604  * pour la methode donnee
 605  *
 606  * @param string $auth_methode
 607  * @param string $new_login
 608  * @param int $id_auteur
 609  * @param string $serveur
 610  * @return string
 611  *  message d'erreur ou chaine vide si pas d'erreur
 612  */
 613 function auth_verifier_login($auth_methode, $new_login, $id_auteur = 0, $serveur = '') {
 614         $args = func_get_args();
 615         return auth_administrer('verifier_login', $args, '');
 616 }
 617
 618 /**
 619  * Modifier le login d'un auteur pour la methode donnee
 620  *
 621  * @param string $auth_methode
 622  * @param string $new_login
 623  * @param int $id_auteur
 624  * @param string $serveur
 625  * @return bool
 626  */
 627 function auth_modifier_login($auth_methode, $new_login, $id_auteur, $serveur = '') {
 628         $args = func_get_args();
 629         return auth_administrer('modifier_login', $args);
 630 }
 631
 632 /**
 633  * Tester la possibilité de modifier le pass
 634  * pour la méthode donnée
 635  *
 636  * @uses auth_administrer()
 637  *
 638  * @param string $auth_methode
 639  * @param string $serveur
 640  * @return bool
 641  *  succès ou échec
 642  */
 643 function auth_autoriser_modifier_pass($auth_methode, $serveur = '') {
 644         $args = func_get_args();
 645         return auth_administrer('autoriser_modifier_pass', $args);
 646 }
 647
 648 /**
 649  * Verifier la validite d'un pass propose pour modification
 650  * pour la methode donnee
 651  *
 652  * @param string $auth_methode
 653  * @param string $login
 654  * @param string $new_pass
 655  * @param int $id_auteur
 656  * @param string $serveur
 657  * @return string
 658  *  message d'erreur ou chaine vide si pas d'erreur
 659  */
 660 function auth_verifier_pass($auth_methode, $login, $new_pass, $id_auteur = 0, $serveur = '') {
 661         $args = func_get_args();
 662         return auth_administrer('verifier_pass', $args, '');
 663 }
 664
 665 /**
 666  * Modifier le mot de passe d'un auteur
 667  * pour la methode donnee
 668  *
 669  * @param string $auth_methode
 670  * @param string $login
 671  * @param string $new_pass
 672  * @param int $id_auteur
 673  * @param string $serveur
 674  * @return bool
 675  *  succes ou echec
 676  */
 677 function auth_modifier_pass($auth_methode, $login, $new_pass, $id_auteur, $serveur = '') {
 678         $args = func_get_args();
 679         return auth_administrer('modifier_pass', $args);
 680 }
 681
 682 /**
 683  * Synchroniser un compte sur une base distante pour la methode
 684  * donnée lorsque des modifications sont faites dans la base auteur
 685  *
 686  * @param string|bool $auth_methode
 687  *   ici true permet de forcer la synchronisation de tous les acces pour toutes les methodes
 688  * @param int $id_auteur
 689  * @param array $champs
 690  * @param array $options
 691  * @param string $serveur
 692  * @return void
 693  */
 694 function auth_synchroniser_distant(
 695         $auth_methode = true,
 696         $id_auteur = 0,
 697         $champs = array(),
 698         $options = array(),
 699         $serveur = ''
 700 ) {
 701         $args = func_get_args();
 702         if ($auth_methode === true or (isset($options['all']) and $options['all'] == true)) {
 703                 $options['all'] = true; // ajouter une option all=>true pour chaque auth
 704                 $args = array(true, $id_auteur, $champs, $options, $serveur);
 705                 foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 706                         array_shift($args);
 707                         array_unshift($args, $methode);
 708                         auth_administrer('synchroniser_distant', $args);
 709                 }
 710         } else {
 711                 auth_administrer('synchroniser_distant', $args);
 712         }
 713 }
 714
 715
 716 /**
 717  * Vérifier si l'auteur est bien authentifié
 718  *
 719  * @param string $login
 720  * @param string $pw
 721  * @param string $serveur
 722  * @return array|bool
 723  */
 724 function lire_php_auth($login, $pw, $serveur = '') {
 725         if (
 726                 !$login
 727                 or !$login = auth_retrouver_login($login, $serveur)
 728         ) {
 729                 return false;
 730         }
 731
 732         $row = sql_fetsel('*', 'spip_auteurs', 'login=' . sql_quote($login, $serveur, 'text'), '', '', '', '', $serveur);
 733
 734         if (!$row) {
 735                 if (spip_connect_ldap($serveur)
 736                         and $auth_ldap = charger_fonction('ldap', 'auth', true)
 737                 ) {
 738                         return $auth_ldap($login, $pw, $serveur, true);
 739                 }
 740
 741                 return false;
 742         }
 743         // su pas de source definie
 744         // ou auth/xxx introuvable, utiliser 'spip'
 745         if (!$auth_methode = $row['source']
 746                 or !$auth = charger_fonction($auth_methode, 'auth', true)
 747         ) {
 748                 $auth = charger_fonction('spip', 'auth', true);
 749         }
 750
 751         $auteur = '';
 752         if ($auth) {
 753                 $auteur = $auth($login, $pw, $serveur, true);
 754         }
 755         // verifier que ce n'est pas un message d'erreur
 756         if (is_array($auteur) and count($auteur)) {
 757                 return $auteur;
 758         }
 759
 760         return false;
 761 }
 762
 763 /**
 764  * entête php_auth (est-encore utilisé ?)
 765  *
 766  * @uses minipres()
 767  *
 768  * @param string $pb
 769  * @param string $raison
 770  * @param string $retour
 771  * @param string $url
 772  * @param string $re
 773  * @param string $lien
 774  */
 775 function ask_php_auth($pb, $raison, $retour = '', $url = '', $re = '', $lien = '') {
 776         @Header('WWW-Authenticate: Basic realm="espace prive"');
 777         @Header('HTTP/1.0 401 Unauthorized');
 778         $corps = '';
 779         $public = generer_url_public();
 780         $ecrire = generer_url_ecrire();
 781         $retour = $retour ? $retour : _T('icone_retour');
 782         $corps .= "<p>$raison</p>[<a href='$public'>$retour</a>] ";
 783         if ($url) {
 784                 $corps .= "[<a href='" . generer_url_action('cookie', "essai_auth_http=oui&$url") . "'>$re</a>]";
 785         }
 786
 787         if ($lien) {
 788                 $corps .= " [<a href='$ecrire'>" . _T('login_espace_prive') . '</a>]';
 789         }
 790         include_spip('inc/minipres');
 791         echo minipres($pb, $corps);
 792         exit;
 793 }