Subversion Repositories Applications.papyrus

<?php

// Remplacement de apache_request_headers pour les vieux serveurs
// http://stackoverflow.com/questions/2916232/call-to-undefined-function-apache-request-headers
if(!function_exists('apache_request_headers')) {
        function apache_request_headers() {
                // Based on: http://www.iana.org/assignments/message-headers/message-headers.xml#perm-headers
                $arrCasedHeaders = array(
                                // HTTP
                                'Dasl'             => 'DASL',
                                'Dav'              => 'DAV',
                                'Etag'             => 'ETag',
                                'Mime-Version'     => 'MIME-Version',
                                'Slug'             => 'SLUG',
                                'Te'               => 'TE',
                                'Www-Authenticate' => 'WWW-Authenticate',
                                // MIME
                                'Content-Md5'      => 'Content-MD5',
                                'Content-Id'       => 'Content-ID',
                                'Content-Features' => 'Content-features',
                );
                $arrHttpHeaders = array();

                foreach($_SERVER as $strKey => $mixValue) {
                        if('HTTP_' !== substr($strKey, 0, 5)) {
                                continue;
                        }

                        $strHeaderKey = strtolower(substr($strKey, 5));

                        if(0 < substr_count($strHeaderKey, '_')) {
                                $arrHeaderKey = explode('_', $strHeaderKey);
                                $arrHeaderKey = array_map('ucfirst', $arrHeaderKey);
                                $strHeaderKey = implode('-', $arrHeaderKey);
                        }
                        else {
                                $strHeaderKey = ucfirst($strHeaderKey);
                        }

                        if(array_key_exists($strHeaderKey, $arrCasedHeaders)) {
                                $strHeaderKey = $arrCasedHeaders[$strHeaderKey];
                        }

                        $arrHttpHeaders[$strHeaderKey] = $mixValue;
                }
                return $arrHttpHeaders;
        }
}

// Attention bien v�rifier la pr�sence des variables suivantes :
// IDEN_UTILISE_SSO, IDEN_URL_SSO, IDEN_COOKIE_SSO, IDEN_SSO_SYNC
// dans le fichier iden_config.inc.php
class identificationSso {
        /**
         * si la valeur est vraiment vide, le cookie n'est pas posé, alors on met
         * une valeur vide pas vide :)
         */
        public static $VALEUR_JETON_VIDE = "jeton-vide";

        protected $cookie_mandataire = "";
        /** le cookie qui dure jusqu'à Vladivostok, si synchro partielle seulement */
        protected $duree_cookie_mandataire;

        /**
         * lorsqu'appelé par un client non-navigateur (qui n'envoie et ne reçoit pas
         * de cookies), permet de ne pas rediriger en boucle, en fournissant le
         * paramètre GET "non_interactif"
         */
        protected $mode_non_interactif = false;

        /** voir IDEN_SSO_SYNC dans iden_config.inc.php  */
        protected $synchro_complete;

        protected $annuaire_url = '';
        protected $bdd_annuaire = '';
        protected $table_annuaire = '';
        protected $champ_login = '';
        protected $champ_mdp = '';
        
        protected $communs_papyrus = null;

        public function __construct() {
                $this->communs_papyrus = $GLOBALS['_GEN_commun'];
                
                $this->cookie_mandataire = IDEN_COOKIE_SSO;
                $this->auth_header = IDEN_HEADER_SSO;   
                $this->annuaire_url = IDEN_URL_SSO;
                $this->synchro_complete = IDEN_SSO_SYNC;

                // gestion des clients qui ne gèrent pas les cookies (file_get_contents...)
                if (isset($_GET['non_interactif'])) {
                        $this->mode_non_interactif = true;
                }

                // si on est en mode synchro complète, on vérifie périodiquement l'état
                // du SSO, en utilisant un cookie qui ne dure pas jusqu'à Vladivostok
                $this->duree_cookie_mandataire = 3600 * 24 * 365;
                if ($this->synchro_complete === true) {
                        $this->duree_cookie_mandataire = 180; // une fois toutes les trois minutes, à cause des zozos qui sont pas à l'heure
                }
                
                // c'est moche mais je n'ai pas trouv� plus simple pour r�cuperer la table annuaire en cours 
                // d'utilisation pour le site actuel (la bdd annuaire est la derni�re partie du dsn)
                $dsn_annuaire = $this->communs_papyrus['info_auth_bdd']->gsab_dsn;
                $dsn_annuaire = explode('/', $dsn_annuaire);
                $this->bdd_annuaire = end($dsn_annuaire);
                
                $this->table_annuaire = $this->communs_papyrus['info_auth_bdd']->gsab_nom_table;
                $this->champ_login = $this->communs_papyrus['info_auth_bdd']->gsab_nom_champ_login;
                $this->champ_mdp = $this->communs_papyrus['info_auth_bdd']->gsab_nom_champ_mdp;
        }

        // http://stackoverflow.com/questions/1251582/beautiful-way-to-remove-get-variables-with-php?lq=1
        protected function supprimerUrlVar($url, $var) {
                 return rtrim(preg_replace('/([?&])'.$var.'=[^&]*(&|$)/','$1',$url), '&?');
        }

        /**
         * Se connecte au SSO : redirige vers le service d'authentification, qui pose
         * le cookie tb_auth, puis re-redirige vers Papyrus avec le jeton en GET, puis
         * Papyrus stocke ce jeton dans son cookie mandataire, puis se re-redirige
         * vers lui-même pour éliminer le paramètre GET de l'URL (ouf !)
         */
        public function connecterEtRediriger() {
                //echo "JE CONNECTE<br/>";
                // sauvegarde de l'URL courante
                $url_redirect = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
                $params = 'login='.$_POST['username'].'&password='.$_POST['password'].'&redirect_url='.urlencode($url_redirect);
                $connexion_url = $this->annuaire_url."connexion?".$params;
                // redirection vers l'annuaire, qui va nous connecter au SSO et nous
                // renvoyer un jeton en GET
                header('Location: '.$connexion_url);
                exit;
        }

        /**
         * Se déconnecte du SSO : redirige vers le service d'authentification, qui
         * supprime le cookie tb_auth, puis re-redirige vers Papyrus avec un jeton
         * vide en GET; Papyrus stocke ce jeton vide dans son cookie mandataire,
         * puis se re-redirige vers lui-même pour éliminer le paramètre GET de l'URL
         */
        public function deconnecterEtRediriger() {
                //echo "JE DECONNECTE<br/>";
                // sauvegarde de l'URL courante
                $url_redirect = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
                $url_redirect = $this->supprimerUrlVar($url_redirect, 'logout');
                $deconnexion_url = $this->annuaire_url."deconnexion?".'redirect_url='.urlencode($url_redirect);
                // redirection vers l'annuaire, qui va nous déconnecter du SSO et nous
                // renvoyer un jeton vide en GET
                header('Location: '.$deconnexion_url);
                exit;
        }
        
        protected function synchroniserDepuisEtatSso() {
                //echo "JE SYNCHRONISE<br/>";
                // sauvegarde de l'URL courante
                $url_redirect = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
                $params = 'redirect_url='.urlencode($url_redirect);
                $identite_url = $this->annuaire_url."identite?".$params;
                // redirection vers l'annuaire, qui va nous donner l'état du SSO et nous
                // renvoyer un jeton en GET
                header('Location: '.$identite_url);
                exit;
        }

        /**
         * Appelée à chaque chargement de page
         */
        public function verifierIdentiteEtRediriger() {
                // si on fait autre chose qu'un GET, on ne vérifie pas l'identité, car
                // cela conduirait à une redirection en GET (avec le jeton), qui
                // supprimerait les données du corps de la requête
                if ($_SERVER['REQUEST_METHOD'] == "GET") {

                        // lecture jeton en GET si on vient de l'annuaire
                        if (isset($_GET['Authorization'])) {
                                //echo "Re-Redirection pour éliminer le GET<br/>";

                                // création / mise à jour du cookie mandataire (le jeton peut être
                                // vide en cas de déconnexion)
                                $jetonRecu = $_GET['Authorization'];
                                if ($jetonRecu == '') {
                                        $jetonRecu = self::$VALEUR_JETON_VIDE;
                                }
                                $this->setCookieMandataire($jetonRecu);
                                //echo "JETON REÇU: " . $_GET['Authorization'];
                                //echo "JETON POSÉ: "; var_dump($jetonRecu);
                                //exit;

                                // redirection pour éliminer le paramètre GET
                                $url_redirect = 'http://'.$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
                                $url_redirect = $this->supprimerUrlVar($url_redirect, 'Authorization');
                                //echo "URL Redirect: $url_redirect"; exit;
                                header('Location: ' . $url_redirect);
                                exit;
                        }

                        // une fois qu'on a fait une connexion ou une déconnexion, on se base
                        // sur le cookie mandataire pour gérer l'identité dans Papyrus
                        //var_dump($_COOKIE); echo "<br/>";
                        // lecture cookie mandataire de Papyrus
                        $jeton = null;
                        $cookiePresent = false;
                        if (isset($_COOKIE[$this->cookie_mandataire])) {
                                $cookiePresent = true;
                                $jeton = $_COOKIE[$this->cookie_mandataire];
                        }
                        //echo "Cookie Présent: "; var_dump($cookiePresent);
                        //echo "JETON: "; var_dump($jeton); echo "<br/>";
                        //exit;

                        // s'il y a un cookie, qu'il contienne un jeton valide ou vide
                        if ($cookiePresent) {
                                // s'il contient un jeton non-vide
                                if ($jeton != self::$VALEUR_JETON_VIDE) {
                                        // reconnexion PEAR (l'utilisateur peut avoir changé)
                                        //echo "RECONNEXION!<br/>"; exit;
                                        $this->deconnexionPear();
                                        $this->connexionPear($jeton);

                                        // prolonge le cookie de 30 secondes si on est connecté, pour
                                        // minimiser les synchros avec le SSO
                                        $this->setCookieMandataire($jeton, 30);

                                        // si mode synchro partielle, le cookie mandataire dure logntemps,
                                        // on rafraîchit donc le jeton pour... euh... on sait jamais :-/
                                        if (! $this->synchro_complete) {
                                                // appel annuaire / identité avec jeton en GET
                                                $infosJson = $this->rafraichirJeton($jeton);
                                                $infos = json_decode($infosJson, true);
                                                //echo "INFOS: "; var_dump($infos); echo "<br/>";
                                                $jetonRafraichi = null;
                                                if (isset($infos['token'])) {
                                                        $jetonRafraichi = $infos['token'];
                                                }
                                                //echo "JETON Rafraîchi: "; var_dump($jetonRafraichi); echo "<br/>";
                                                //exit;
                                                // si jeton rafraîchi reçu
                                                if ($jetonRafraichi != null) {
                                                        // màj cookie avec jeton rafraîchi
                                                        $this->setCookieMandataire($jetonRafraichi);
                                                        // reconnexion PEAR (l'utilisateur peut avoir changé)
                                                        $this->deconnexionPear();
                                                        $this->connexionPear($jetonRafraichi);
                                                        //exit;
                                                } else {
                                                // sinon (non connecté ou problème annuaire / jeton)
                                                        // écriture cookie avec jeton vide
                                                        $this->setCookieMandataire(self::$VALEUR_JETON_VIDE);
                                                        // déconnexion PEAR
                                                        $this->deconnexionPear();
                                                }
                                        }
                                } else {
                                        // déconnexion PEAR ?
                                        $this->deconnexionPear();       
                                }
                        } else { // sinon (aucun cookie mandataire)
                                // en mode synchro complète, on vérifie chaque minute (lorsque le
                                // cookie mandataire n'est plus présent) si on n'est pas connecté
                                // sur le SSO, sauf si on est en mode non interactif
                                if ($this->synchro_complete && (! $this->mode_non_interactif)) {
                                        $this->synchroniserDepuisEtatSso();
                                }
                        }
                }
        }

        protected function setCookieMandataire($valeur, $duree=null) {
                if ($duree === null) {
                        $duree = $this->duree_cookie_mandataire;
                }
                setcookie($this->cookie_mandataire, $valeur, time() + $duree);
        }

        /**
         * Connecte l'utilisateur à Papyrus avec le système traditionnel fourni par PEAR
         */
        protected function connexionPear($jeton) {
                $jeton_decode = $this->decoderToken($jeton);

                // R�cup�ration du mot de passe pour remplir les infos de l'objet PEAR Auth
                $requete =  'SELECT '.$this->champ_mdp.' '.
                                'FROM '.$this->bdd_annuaire.'.'.$this->table_annuaire.' '.
                                'WHERE '.$this->champ_login.' = "'.$jeton_decode['sub'].'" ';

                // TODO: normalement �a n'est jamais le cas mais que fait t'on si l'utilisateur n'existe pas
                // dans notre base de donn�es ? (au pire il ne sera pas connect�)
                $this->communs_papyrus['pear_auth']->username = $jeton_decode['sub'];
                $this->communs_papyrus['pear_auth']->password = $this->communs_papyrus['pear_db']->getOne($requete);

                // Le mot de passe est d�j� crypt� dans la bdd donc il faut indiquer � pear de ne pas le re crytper
                if (isset($this->communs_papyrus['pear_auth']->storage_options)) {
                        $this->communs_papyrus['pear_auth']->storage_options['cryptType'] = 'none';
                }
                if (isset($this->communs_papyrus['pear_auth']->storage->options)) {
                        $this->communs_papyrus['pear_auth']->storage->options['cryptType'] = 'none';
                }

                // si on fait pas ça, ça marche pas (régénération de session apparemment)
                //$this->communs_papyrus['pear_auth']->setAuth($jeton_decode['sub']);
        }

        /**
         * Supprime tout ce qui a trait à PEAR afin de déconnecter l'utilisateur du
         * système d'authentification traditionnel de Papyrus
         */
        protected function deconnexionPear() {
                $this->communs_papyrus['pear_auth']->logout();

                $cookie_persistant_nom = session_name().'-memo';
                $cookie_utilisateur_nom = session_name().'-utilisateur';
                // Destruction du cookie de session de Papyrus : est ce utile?
                setcookie(session_name(), session_id(), time()-3600, '/');
                // Destruction du cookie de permanence de l'identitification de Papyrus
                setcookie($cookie_persistant_nom, '', time()-3600, '/');
                setcookie($cookie_utilisateur_nom, '', time()-3600, '/');
        }

        /**
         * Fournit un jeton à l'annuaire (jeton provenant du cookie mandataire
         * de Papyrus), le fait rafraîchir puis met à jour le cookie mandataire avec
         * le jeton rafraîchi
         */
        protected function rafraichirJeton($jeton) {
                $identiteServiceURL = $this->annuaire_url . "identite";
                $identiteServiceURL .= "?token=" . $jeton;
                //echo "URL: $identiteServiceURL<br/>";
                $ch = curl_init($identiteServiceURL);
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
                curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
                $jetonRafraichi = curl_exec($ch);
                //var_dump($jetonRafraichi);
                //var_dump(curl_error($ch)); exit;

                return $jetonRafraichi;
        }

        protected function decoderToken($token) {
                $token_parts = explode('.', $token);
                return json_decode(base64_decode($token_parts[1]), true);
        }
}
?>