ここの情報は古いです。ご理解頂いた上でお取り扱いください。

Changeset 4883 for OpenPNE/trunk


Ignore:
Timestamp:
Jan 9, 2008, 9:58:22 PM (15 years ago)
Author:
ebihara
Message:

#1749:PEAR::Authを1.3.0から1.5.4にバージョンアップ

Location:
OpenPNE/trunk
Files:
5 added
19 edited

Legend:

Unmodified
Added
Removed
  • OpenPNE/trunk/lib/include/Auth.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: Auth.php,v 1.101 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: Auth.php,v 1.119 2007/07/02 03:38:52 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 */
     
    3131 */
    3232define('AUTH_EXPIRED',                  -2);
    33 /** 
     33/**
    3434 * Returned if container is unable to authenticate user/password pair
    3535 */
     
    4343 */
    4444define('AUTH_SECURITY_BREACH',          -5);
     45/**
     46 * Returned if checkAuthCallback says session should not continue.
     47 */
     48define('AUTH_CALLBACK_ABORT',           -6);
     49
     50/**
     51 * Auth Log level - INFO
     52 */
     53define('AUTH_LOG_INFO',     6);
     54/**
     55 * Auth Log level - DEBUG
     56 */
     57define('AUTH_LOG_DEBUG',    7);
     58
    4559
    4660/**
     
    5670 * @copyright  2001-2006 The PHP Group
    5771 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    58  * @version    Release: 1.3.0  File: $Revision: 1.101 $
     72 * @version    Release: 1.5.4  File: $Revision: 1.119 $
    5973 * @link       http://pear.php.net/package/Auth
    6074 */
     
    123137     */
    124138    var $showLogin = true;
    125    
     139
    126140    /**
    127141      * Is Login Allowed from this page
     
    154168
    155169    /**
     170     * checkAuth callback function name
     171     *
     172     * @var string
     173     * @see setCheckAuthCallback()
     174     */
     175    var $checkAuthCallback = '';
     176
     177    /**
    156178     * Login callback function name
    157179     *
     
    165187     *
    166188     * @var string
    167      * @see setLoginFailedCallback()
     189     * @see setFailedLoginCallback()
    168190     */
    169191    var $loginFailedCallback = '';
     
    193215    /**
    194216     * Flag to use advanced security
    195      * When set extra checks will be made to see if the 
    196      * user's IP or useragent have changed across requests. 
     217     * When set extra checks will be made to see if the
     218     * user's IP or useragent have changed across requests.
    197219     * Turned off by default to preserve BC.
    198220     *
    199221     * @var boolean
    200      */     
     222     */
    201223    var $advancedsecurity = false;
    202224
     
    244266     */
    245267    var $authdata;
    246    
     268
    247269    /**
    248270      * How many times has checkAuth been called
    249       * var int
     271      * @var int
    250272      */
    251273    var $authChecks = 0;
     274
     275    /**
     276     * PEAR::Log object
     277     *
     278     * @var object Log
     279     */
     280    var $logger = null;
     281
     282    /**
     283     * Whether to enable logging of behaviour
     284     *
     285     * @var boolean
     286     */
     287    var $enableLogging = false;
     288
     289    /**
     290     * Whether to regenerate session id everytime start is called
     291     *
     292     * @var boolean
     293     */
     294    var $regenerateSessionId = false;
    252295
    253296    // }}}
     
    280323                PEAR::throwError('Session could not be started by Auth, '
    281324                        .'possibly headers are already sent, try putting '
    282                         .'ob_start in the begninig of your script');
     325                        .'ob_start in the beginning of your script');
    283326            }
    284327        }
    285328
    286329        // Make Sure Auth session variable is there
    287         if(   !isset($_SESSION[$this->_sessionName])
    288            && !isset($GLOBALS['HTTP_SESSION_VARS'][$this->_sessionName])) {
    289             session_register($this->_sessionName);
     330        if(!isset($_SESSION[$this->_sessionName])) {
     331            $_SESSION[$this->_sessionName] = array();
    290332        }
    291333
    292334        // Assign Some globals to internal references, this will replace _importGlobalVariable
    293         isset($_SESSION)
    294             ? $this->session =& $_SESSION[$this->_sessionName]
    295             : $this->session =& $GLOBALS['HTTP_SESSION_VARS'][$this->_sessionName] ;
    296         isset($_SERVER)
    297             ? $this->server =& $_SERVER
    298             : $this->server =& $GLOBALS['HTTP_SERVER_VARS'];
    299         isset($_POST)
    300             ? $this->post =& $_POST
    301             : $this->post =& $GLOBALS['HTTP_POST_VARS'];
    302         isset($_COOKIE)
    303             ? $this->cookie =& $_COOKIE
    304             : $this->cookie =& $GLOBALS['HTTP_COOKIE_VARS'];
    305         //isset($_GET) ? $var = &$_GET : $var = &$GLOBALS['HTTP_GET_VARS'];
     335        $this->session =& $_SESSION[$this->_sessionName];
     336        $this->server =& $_SERVER;
     337        $this->post =& $_POST;
     338        $this->cookie =& $_COOKIE;
    306339
    307340        if ($loginFunction != '' && is_callable($loginFunction)) {
     
    320353        } else {
    321354            // $this->storage = $this->_factory($storageDriver, $options);
    322             // 
     355            //
    323356            $this->storage_driver = $storageDriver;
    324357            $this->storage_options =& $options;
     
    330363
    331364    /**
    332       * Set the Auth options 
     365      * Set the Auth options
    333366      *
    334367      * Some options which are Auth specific will be applied
    335368      * the rest will be left for usage by the container
    336       * 
     369      *
    337370      * @param array    An array of Auth options
    338371      * @return array   The options which were not applied
     
    346379                unset($options['sessionName']);
    347380            }
    348             if (!empty($options['allowLogin'])) {
     381            if (isset($options['allowLogin'])) {
    349382                $this->allowLogin = $options['allowLogin'];
    350383                unset($options['allowLogin']);
     
    358391                unset($options['postPassword']);
    359392            }
    360             if (!empty($options['advancedsecurity'])) {
     393            if (isset($options['advancedsecurity'])) {
    361394                $this->advancedsecurity = $options['advancedsecurity'];
    362395                unset($options['advancedsecurity']);
    363396            }
     397            if (isset($options['enableLogging'])) {
     398                $this->enableLogging = $options['enableLogging'];
     399                unset($options['enableLogging']);
     400            }
     401            if (isset($options['regenerateSessionId']) && is_bool($options['regenerateSessionId'])) {
     402                $this->regenerateSessionId = $options['regenerateSessionId'];
     403            }
    364404        }
    365405        return($options);
     
    368408    // }}}
    369409    // {{{ _loadStorage()
    370    
     410
    371411    /**
    372412      * Load Storage Driver if not already loaded
    373413      *
    374       * Suspend storage instantiation to make Auth lighter to use 
     414      * Suspend storage instantiation to make Auth lighter to use
    375415      * for calls which do not require login
    376416      *
     
    382422    {
    383423        if(!is_object($this->storage)) {
    384             $this->storage =& $this->_factory($this->storage_driver, 
     424            $this->storage =& $this->_factory($this->storage_driver,
    385425                    $this->storage_options);
    386426            $this->storage->_auth_obj =& $this;
     427            $this->log('Loaded storage container ('.$this->storage_driver.')', AUTH_LOG_DEBUG);
    387428            return(true);
    388429        }
     
    428469    function assignData()
    429470    {
    430         if (   isset($this->post[$this->_postUsername])
     471        $this->log('Auth::assignData() called.', AUTH_LOG_DEBUG);
     472
     473        if (   isset($this->post[$this->_postUsername])
    431474            && $this->post[$this->_postUsername] != '') {
    432             $this->username = (get_magic_quotes_gpc() == 1 
    433                     ? stripslashes($this->post[$this->_postUsername]) 
     475            $this->username = (get_magic_quotes_gpc() == 1
     476                    ? stripslashes($this->post[$this->_postUsername])
    434477                    : $this->post[$this->_postUsername]);
    435478        }
    436         if (   isset($this->post[$this->_postPassword]) 
     479        if (   isset($this->post[$this->_postPassword])
    437480            && $this->post[$this->_postPassword] != '') {
    438             $this->password = (get_magic_quotes_gpc() == 1 
    439                     ? stripslashes($this->post[$this->_postPassword]) 
     481            $this->password = (get_magic_quotes_gpc() == 1
     482                    ? stripslashes($this->post[$this->_postPassword])
    440483                    : $this->post[$this->_postPassword] );
    441484        }
     
    453496    function start()
    454497    {
     498        $this->log('Auth::start() called.', AUTH_LOG_DEBUG);
     499
     500        // #10729 - Regenerate session id here if we are generating it on every
     501        //          page load.
     502        if ($this->regenerateSessionId) {
     503            session_regenerate_id(true);
     504        }
     505
    455506        $this->assignData();
    456507        if (!$this->checkAuth() && $this->allowLogin) {
     
    470521    function login()
    471522    {
     523        $this->log('Auth::login() called.', AUTH_LOG_DEBUG);
     524
    472525        $login_ok = false;
    473526        $this->_loadStorage();
    474        
     527
    475528        // Check if using challenge response
    476         (isset($this->post['authsecret']) && $this->post['authsecret'] == 1) 
    477             ? $usingChap = true 
     529        (isset($this->post['authsecret']) && $this->post['authsecret'] == 1)
     530            ? $usingChap = true
    478531            : $usingChap = false;
    479532
    480        
     533
    481534        // When the user has already entered a username, we have to validate it.
    482535        if (!empty($this->username)) {
     
    484537                $this->session['challengekey'] = md5($this->username.$this->password);
    485538                $login_ok = true;
     539                $this->log('Successful login.', AUTH_LOG_INFO);
    486540            }
    487541        }
     
    490544            $this->setAuth($this->username);
    491545            if (is_callable($this->loginCallback)) {
    492                 call_user_func_array($this->loginCallback, array($this->username, $this));
    493             }
    494         }
    495 
    496         // If the login failed or the user entered no username,
     546                $this->log('Calling loginCallback ('.$this->loginCallback.').', AUTH_LOG_DEBUG);
     547                call_user_func_array($this->loginCallback, array($this->username, &$this));
     548            }
     549        }
     550
     551        // If the login failed or the user entered no username,
    497552        // output the login screen again.
    498553        if (!empty($this->username) && !$login_ok) {
     554            $this->log('Incorrect login.', AUTH_LOG_INFO);
    499555            $this->status = AUTH_WRONG_LOGIN;
    500556            if (is_callable($this->loginFailedCallback)) {
    501                 call_user_func_array($this->loginFailedCallback, array($this->username, $this));
     557                $this->log('Calling loginFailedCallback ('.$this->loginFailedCallback.').', AUTH_LOG_DEBUG);
     558                call_user_func_array($this->loginFailedCallback, array($this->username, &$this));
    502559            }
    503560        }
    504561
    505562        if ((empty($this->username) || !$login_ok) && $this->showLogin) {
     563            $this->log('Rendering Login Form.', AUTH_LOG_INFO);
    506564            if (is_callable($this->loginFunction)) {
    507                 call_user_func_array($this->loginFunction, array($this->username, $this->status, $this));
     565                $this->log('Calling loginFunction ('.$this->loginFunction.').', AUTH_LOG_DEBUG);
     566                call_user_func_array($this->loginFunction, array($this->username, $this->status, &$this));
    508567            } else {
    509568                // BC fix Auth used to use drawLogin for this
    510569                // call is sub classes implement this
    511570                if (is_callable(array($this, 'drawLogin'))) {
     571                    $this->log('Calling Auth::drawLogin()', AUTH_LOG_DEBUG);
    512572                    return $this->drawLogin($this->username, $this);
    513573                }
     574
     575                $this->log('Using default Auth_Frontend_Html', AUTH_LOG_DEBUG);
    514576
    515577                // New Login form
     
    563625     * on the same domain, you can change the name of
    564626     * session per application via this function.
    565      * This will chnage the name of the session variable 
     627     * This will chnage the name of the session variable
    566628     * auth uses to store it's data in the session
    567629     *
     
    573635    {
    574636        $this->_sessionName = '_auth_'.$name;
    575         isset($_SESSION)
    576             ? $this->session =& $_SESSION[$this->_sessionName]
    577             : $this->session =& $GLOBALS['HTTP_SESSION_VARS'][$this->_sessionName] ;
     637        // Make Sure Auth session variable is there
     638        if(!isset($_SESSION[$this->_sessionName])) {
     639            $_SESSION[$this->_sessionName] = array();
     640        }
     641        $this->session =& $_SESSION[$this->_sessionName];
    578642    }
    579643
     
    609673
    610674    // }}}
     675    // {{{ setCheckAuthCallback()
     676
     677    /**
     678     * Register a callback function to be called whenever the validity of the login is checked
     679     * The function will receive two parameters, the username and a reference to the auth object.
     680     *
     681     * @param  string  callback function name
     682     * @return void
     683     * @access public
     684     * @since Method available since Release 1.4.3
     685     */
     686    function setCheckAuthCallback($checkAuthCallback)
     687    {
     688        $this->checkAuthCallback = $checkAuthCallback;
     689    }
     690
     691    // }}}
    611692    // {{{ setLoginCallback()
    612    
     693
    613694    /**
    614695     * Register a callback function to be called on user login.
     
    630711    /**
    631712     * Register a callback function to be called on failed user login.
    632      * The function will receive a single parameter, the username and a reference to the auth object.
     713     * The function will receive two parameters, the username and a reference to the auth object.
    633714     *
    634715     * @param  string  callback function name
     
    697778        if (!isset($this->session['data'])) {
    698779            return null;
    699         }   
     780        }
    700781        if(!isset($name)) {
    701782            return $this->session['data'];
     
    704785            return $this->session['data'][$name];
    705786        }
    706         return null;       
     787        return null;
    707788    }
    708789
     
    720801    function setAuth($username)
    721802    {
    722    
    723         // #2021 - Change the session id to avoid session fixation attacks php 4.3.3 >
    724         session_regenerate_id();
     803        $this->log('Auth::setAuth() called.', AUTH_LOG_DEBUG);
     804
     805        // #10729 - Regenerate session id here only if generating at login only
     806        //          Don't do it if we are regenerating on every request so we don't
     807        //          regenerate it twice in one request.
     808        if (!$this->regenerateSessionId) {
     809            // #2021 - Change the session id to avoid session fixation attacks php 4.3.3 >
     810            session_regenerate_id(true);
     811        }
    725812
    726813        if (!isset($this->session) || !is_array($this->session)) {
     
    732819        }
    733820
    734         $this->session['sessionip'] = isset($this->server['REMOTE_ADDR']) 
    735             ? $this->server['REMOTE_ADDR'] 
     821        $this->session['sessionip'] = isset($this->server['REMOTE_ADDR'])
     822            ? $this->server['REMOTE_ADDR']
    736823            : '';
    737         $this->session['sessionuseragent'] = isset($this->server['HTTP_USER_AGENT'])
    738             ? $this->server['HTTP_USER_AGENT']
     824        $this->session['sessionuseragent'] = isset($this->server['HTTP_USER_AGENT'])
     825            ? $this->server['HTTP_USER_AGENT']
     826            : '';
     827        $this->session['sessionforwardedfor'] = isset($this->server['HTTP_X_FORWARDED_FOR'])
     828            ? $this->server['HTTP_X_FORWARDED_FOR']
    739829            : '';
    740830
     
    756846    // }}}
    757847    // {{{ setAdvancedSecurity()
    758    
     848
    759849    /**
    760850      * Enables advanced security checks
    761851      *
    762       * Currently only ip change and useragent change 
     852      * Currently only ip change and useragent change
    763853      * are detected
    764       * @todo Add challenge cookies - Create a cookie which changes every time 
     854      * @todo Add challenge cookies - Create a cookie which changes every time
    765855      *       and contains some challenge key which the server can verify with
    766856      *       a session var cookie might need to be crypted (user pass)
     
    785875    function checkAuth()
    786876    {
     877        $this->log('Auth::checkAuth() called.', AUTH_LOG_DEBUG);
    787878        $this->authChecks++;
    788879        if (isset($this->session)) {
     
    791882                && isset($this->session['timestamp'])
    792883                && ($this->session['timestamp'] + $this->expire) < time()) {
     884                $this->log('Session Expired', AUTH_LOG_INFO);
    793885                $this->expired = true;
    794886                $this->status = AUTH_EXPIRED;
     
    799891            // Check if maximum idle time is reached
    800892            if (   $this->idle > 0
    801                 && isset($this->session['idle']) 
     893                && isset($this->session['idle'])
    802894                && ($this->session['idle'] + $this->idle) < time()) {
     895                $this->log('Session Idle Time Reached', AUTH_LOG_INFO);
    803896                $this->idled = true;
    804897                $this->status = AUTH_IDLED;
     
    807900            }
    808901
    809             if (   isset($this->session['registered']) 
    810                 && isset($this->session['username']) 
    811                 && $this->session['registered'] == true 
     902            if (   isset($this->session['registered'])
     903                && isset($this->session['username'])
     904                && $this->session['registered'] == true
    812905                && $this->session['username'] != '') {
    813906                Auth::updateIdle();
    814907
    815908                if ($this->advancedsecurity) {
    816                    
     909                    $this->log('Advanced Security Mode Enabled.', AUTH_LOG_DEBUG);
     910
    817911                    // Only Generate the challenge once
    818912                    if($this->authChecks == 1) {
     913                        $this->log('Generating new Challenge Cookie.', AUTH_LOG_DEBUG);
    819914                        $this->session['challengecookieold'] = $this->session['challengecookie'];
    820915                        $this->session['challengecookie'] = md5($this->session['challengekey'].microtime());
    821916                        setcookie('authchallenge', $this->session['challengecookie']);
    822917                    }
    823                    
     918
    824919                    // Check for ip change
    825                     if (   isset($this->server['REMOTE_ADDR']) 
     920                    if (   isset($this->server['REMOTE_ADDR'])
    826921                        && $this->session['sessionip'] != $this->server['REMOTE_ADDR']) {
    827                         // Check if the IP of the user has changed, if so we
     922                        $this->log('Security Breach. Remote IP Address changed.', AUTH_LOG_INFO);
     923                        // Check if the IP of the user has changed, if so we
    828924                        // assume a man in the middle attack and log him out
    829925                        $this->expired = true;
     
    832928                        return false;
    833929                    }
    834                    
     930
     931                    // Check for ip change (if connected via proxy)
     932                    if (   isset($this->server['HTTP_X_FORWARDED_FOR'])
     933                        && $this->session['sessionforwardedfor'] != $this->server['HTTP_X_FORWARDED_FOR']) {
     934                        $this->log('Security Breach. Forwarded For IP Address changed.', AUTH_LOG_INFO);
     935                        // Check if the IP of the user connecting via proxy has
     936                        // changed, if so we assume a man in the middle attack
     937                        // and log him out.
     938                        $this->expired = true;
     939                        $this->status = AUTH_SECURITY_BREACH;
     940                        $this->logout();
     941                        return false;
     942                    }
     943
    835944                    // Check for useragent change
    836                     if (   isset($this->server['HTTP_USER_AGENT']) 
     945                    if (   isset($this->server['HTTP_USER_AGENT'])
    837946                        && $this->session['sessionuseragent'] != $this->server['HTTP_USER_AGENT']) {
    838                         // Check if the User-Agent of the user has changed, if
     947                        $this->log('Security Breach. User Agent changed.', AUTH_LOG_INFO);
     948                        // Check if the User-Agent of the user has changed, if
    839949                        // so we assume a man in the middle attack and log him out
    840950                        $this->expired = true;
     
    843953                        return false;
    844954                    }
    845    
    846                     // Check challenge cookie here, if challengecookieold is not set 
     955
     956                    // Check challenge cookie here, if challengecookieold is not set
    847957                    // this is the first time and check is skipped
    848                     // TODO when user open two pages similtaneuly (open in new window,open 
     958                    // TODO when user open two pages similtaneuly (open in new window,open
    849959                    // in tab) auth breach is caused find out a way around that if possible
    850                     if (   isset($this->session['challengecookieold']) 
     960                    if (   isset($this->session['challengecookieold'])
    851961                        && $this->session['challengecookieold'] != $this->cookie['authchallenge']) {
     962                        $this->log('Security Breach. Challenge Cookie mismatch.', AUTH_LOG_INFO);
    852963                        $this->expired = true;
    853964                        $this->status = AUTH_SECURITY_BREACH;
     
    858969                }
    859970
     971                if (is_callable($this->checkAuthCallback)) {
     972                    $this->log('Calling checkAuthCallback ('.$this->checkAuthCallback.').', AUTH_LOG_DEBUG);
     973                    $checkCallback = call_user_func_array($this->checkAuthCallback, array($this->username, &$this));
     974                    if ($checkCallback == false) {
     975                        $this->log('checkAuthCallback failed.', AUTH_LOG_INFO);
     976                        $this->expired = true;
     977                        $this->status = AUTH_CALLBACK_ABORT;
     978                        $this->logout();
     979                        return false;
     980                    }
     981                }
     982
     983                $this->log('Session OK.', AUTH_LOG_INFO);
    860984                return true;
    861985            }
    862986        }
     987        $this->log('Unable to locate session storage.', AUTH_LOG_DEBUG);
    863988        return false;
    864989    }
     
    8811006            $staticAuth = new Auth('null', $options);
    8821007        }
     1008        $staticAuth->log('Auth::staticCheckAuth() called', AUTH_LOG_DEBUG);
    8831009        return $staticAuth->checkAuth();
    8841010    }
     
    8951021    function getAuth()
    8961022    {
     1023        $this->log('Auth::getAuth() called.', AUTH_LOG_DEBUG);
    8971024        return $this->checkAuth();
    8981025    }
     
    9131040    function logout()
    9141041    {
    915         if (is_callable($this->logoutCallback)) {
    916             call_user_func_array($this->logoutCallback, array($this->session['username'], $this));
     1042        $this->log('Auth::logout() called.', AUTH_LOG_DEBUG);
     1043
     1044        if (is_callable($this->logoutCallback) && isset($this->session['username'])) {
     1045            $this->log('Calling logoutCallback ('.$this->logoutCallback.').', AUTH_LOG_DEBUG);
     1046            call_user_func_array($this->logoutCallback, array($this->session['username'], &$this));
    9171047        }
    9181048
    9191049        $this->username = '';
    9201050        $this->password = '';
    921        
     1051
    9221052        $this->session = null;
    9231053    }
     
    9701100    // }}}
    9711101    // {{{ getPostUsernameField()
    972    
     1102
    9731103    /**
    9741104     * Gets the post varible used for the username
    975      * 
     1105     *
    9761106     * @return string
    9771107     * @access public
     
    9871117    /**
    9881118     * Gets the post varible used for the username
    989      * 
     1119     *
    9901120     * @return string
    9911121     * @access public
     
    10101140            return 0;
    10111141        }
     1142        if ($this->idle == 0) {
     1143            return 0;
     1144        }
    10121145        return ($this->session['idle'] + $this->idle);
    10131146    }
     
    10251158    function listUsers()
    10261159    {
     1160        $this->log('Auth::listUsers() called.', AUTH_LOG_DEBUG);
    10271161        $this->_loadStorage();
    10281162        return $this->storage->listUsers();
     
    10441178    function addUser($username, $password, $additional = '')
    10451179    {
     1180        $this->log('Auth::addUser() called.', AUTH_LOG_DEBUG);
    10461181        $this->_loadStorage();
    10471182        return $this->storage->addUser($username, $password, $additional);
     
    10611196    function removeUser($username)
    10621197    {
     1198        $this->log('Auth::removeUser() called.', AUTH_LOG_DEBUG);
    10631199        $this->_loadStorage();
    10641200        return $this->storage->removeUser($username);
     
    10731209     * @access public
    10741210     * @param string Username
    1075      * @param string The new password 
     1211     * @param string The new password
    10761212     * @return mixed True on success, PEAR error object on error
    10771213     *               and AUTH_METHOD_NOT_SUPPORTED otherwise.
     
    10791215    function changePassword($username, $password)
    10801216    {
     1217        $this->log('Auth::changePassword() called', AUTH_LOG_DEBUG);
    10811218        $this->_loadStorage();
    10821219        return $this->storage->changePassword($username, $password);
     
    10841221
    10851222    // }}}
     1223    // {{{ log()
     1224
     1225    /**
     1226     * Log a message from the Auth system
     1227     *
     1228     * @access public
     1229     * @param string The message to log
     1230     * @param string The log level to log the message under. See the Log documentation for more info.
     1231     * @return boolean
     1232     */
     1233    function log($message, $level = AUTH_LOG_DEBUG)
     1234    {
     1235        if (!$this->enableLogging) return false;
     1236
     1237        $this->_loadLogger();
     1238
     1239        $this->logger->log('AUTH: '.$message, $level);
     1240    }
     1241
     1242    // }}}
     1243    // {{{ _loadLogger()
     1244
     1245    /**
     1246      * Load Log object if not already loaded
     1247      *
     1248      * Suspend logger instantiation to make Auth lighter to use
     1249      * for calls which do not require logging
     1250      *
     1251      * @return bool    True if the logger is loaded, false if the logger
     1252      *                 is already loaded
     1253      * @access private
     1254      */
     1255    function _loadLogger()
     1256    {
     1257        if(is_null($this->logger)) {
     1258            if (!class_exists('Log')) {
     1259                include_once 'Log.php';
     1260            }
     1261            $this->logger =& Log::singleton('null',
     1262                    null,
     1263                    'auth['.getmypid().']',
     1264                    array(),
     1265                    AUTH_LOG_DEBUG);
     1266            return(true);
     1267        }
     1268        return(false);
     1269    }
     1270
     1271    // }}}
     1272    // {{{ attachLogObserver()
     1273
     1274    /**
     1275     * Attach an Observer to the Auth Log Source
     1276     *
     1277     * @param object Log_Observer A Log Observer instance
     1278     * @return boolean
     1279     */
     1280    function attachLogObserver(&$observer) {
     1281
     1282        $this->_loadLogger();
     1283
     1284        return $this->logger->attach($observer);
     1285
     1286    }
     1287
     1288    // }}}
    10861289
    10871290}
  • OpenPNE/trunk/lib/include/Auth/Anonymous.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: Anonymous.php,v 1.5 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: Anonymous.php,v 1.6 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.3.0
     
    3131/**
    3232 * Anonymous Authentication
    33  * 
    34  * This class provides anonymous authentication if username and password 
     33 *
     34 * This class provides anonymous authentication if username and password
    3535 * were not supplied
    3636 *
     
    4141 * @copyright  2001-2006 The PHP Group
    4242 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    43  * @version    Release: 1.3.0  File: $Revision: 1.5 $
     43 * @version    Release: 1.5.4  File: $Revision: 1.6 $
    4444 * @link       http://pear.php.net/package/Auth
    4545 * @since      Class available since Release 1.3.0
    4646 */
    47 class Auth_Anonymous extends Auth 
     47class Auth_Anonymous extends Auth
    4848{
    4949
     
    6666    // }}}
    6767    // {{{ Auth_Anonymous() [constructor]
    68    
     68
    6969    /**
    7070     * Pass all parameters to Parent Auth class
    71      * 
     71     *
    7272     * Set up the storage driver.
    7373     *
     
    8888    // }}}
    8989    // {{{ login()
    90    
     90
    9191    /**
    9292     * Login function
    93      * 
     93     *
    9494     * If no username & password is passed then login as the username
    9595     * provided in $this->anonymous_username else call standard login()
     
    101101     */
    102102    function login() {
    103         if (   $this->allow_anonymous 
    104             && empty($this->username) 
     103        if (   $this->allow_anonymous
     104            && empty($this->username)
    105105            && empty($this->password) ) {
    106106            $this->setAuth($this->anonymous_username);
     
    116116    // }}}
    117117    // {{{ forceLogin()
    118    
     118
    119119    /**
    120120     * Force the user to login
  • OpenPNE/trunk/lib/include/Auth/Container.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: Container.php,v 1.23 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: Container.php,v 1.28 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 */
     
    3232 * @copyright  2001-2006 The PHP Group
    3333 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    34  * @version    Release: 1.3.0  File: $Revision: 1.23 $
     34 * @version    Release: 1.5.4  File: $Revision: 1.28 $
    3535 * @link       http://pear.php.net/package/Auth
    3636 */
     
    4747    var $activeUser = "";
    4848
     49    /**
     50     * The Auth object this container is attached to.
     51     *
     52     * @access public
     53     */
     54    var $_auth_obj = null;
     55
    4956    // }}}
    5057    // {{{ Auth_Container() [constructor]
     
    7380    function fetchData($username, $password, $isChallengeResponse=false)
    7481    {
     82        $this->log('Auth_Container::fetchData() called.', AUTH_LOG_DEBUG);
    7583    }
    7684
     
    9199    function verifyPassword($password1, $password2, $cryptType = "md5")
    92100    {
     101        $this->log('Auth_Container::verifyPassword() called.', AUTH_LOG_DEBUG);
    93102        switch ($cryptType) {
    94103            case "crypt" :
    95                 return ( crypt($password1, $password2) == $password2 );
     104                return ((string)crypt($password1, $password2) === (string)$password2);
    96105                break;
    97106            case "none" :
    98107            case "" :
    99                 return ($password1 == $password2);
     108                return ((string)$password1 === (string)$password2);
    100109                break;
    101110            case "md5" :
    102                 return (md5($password1) == $password2);
     111                return ((string)md5($password1) === (string)$password2);
    103112                break;
    104113            default :
    105114                if (function_exists($cryptType)) {
    106                     return ($cryptType($password1) == $password2);
    107                 } elseif (method_exists($this,$cryptType)) { 
    108                     return ($this->$cryptType($password1) == $password2);
     115                    return ((string)$cryptType($password1) === (string)$password2);
     116                } elseif (method_exists($this,$cryptType)) {
     117                    return ((string)$this->$cryptType($password1) === (string)$password2);
    109118                } else {
    110119                    return false;
     
    116125    // }}}
    117126    // {{{ supportsChallengeResponse()
    118    
    119     /**
    120       * Returns true if the container supports Challenge Response 
     127
     128    /**
     129      * Returns true if the container supports Challenge Response
    121130      * password authentication
    122131      */
     
    128137    // }}}
    129138    // {{{ getCryptType()
    130    
     139
    131140    /**
    132141      * Returns the crypt current crypt type of the container
     
    147156    function listUsers()
    148157    {
     158        $this->log('Auth_Container::listUsers() called.', AUTH_LOG_DEBUG);
    149159        return AUTH_METHOD_NOT_SUPPORTED;
    150160    }
     
    162172    function getUser($username)
    163173    {
     174        $this->log('Auth_Container::getUser() called.', AUTH_LOG_DEBUG);
    164175        $users = $this->listUsers();
    165176        if ($users === AUTH_METHOD_NOT_SUPPORTED) {
     
    188199    function addUser($username, $password, $additional=null)
    189200    {
     201        $this->log('Auth_Container::addUser() called.', AUTH_LOG_DEBUG);
    190202        return AUTH_METHOD_NOT_SUPPORTED;
    191203    }
     
    201213    function removeUser($username)
    202214    {
     215        $this->log('Auth_Container::removeUser() called.', AUTH_LOG_DEBUG);
    203216        return AUTH_METHOD_NOT_SUPPORTED;
    204217    }
     
    215228    function changePassword($username, $password)
    216229    {
    217         return AUTH_METHOD_NOT_SUPPORTED;
     230        $this->log('Auth_Container::changePassword() called.', AUTH_LOG_DEBUG);
     231        return AUTH_METHOD_NOT_SUPPORTED;
     232    }
     233
     234    // }}}
     235    // {{{ log()
     236
     237    /**
     238     * Log a message to the Auth log
     239     *
     240     * @param string The message
     241     * @param int
     242     * @return boolean
     243     */
     244    function log($message, $level = AUTH_LOG_DEBUG) {
     245
     246        if (is_null($this->_auth_obj)) {
     247
     248            return false;
     249
     250        } else {
     251
     252            return $this->_auth_obj->log($message, $level);
     253
     254        }
     255
    218256    }
    219257
  • OpenPNE/trunk/lib/include/Auth/Container/DB.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: DB.php,v 1.60 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: DB.php,v 1.72 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 */
     
    4444 * @copyright  2001-2006 The PHP Group
    4545 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    46  * @version    Release: 1.3.0  File: $Revision: 1.60 $
     46 * @version    Release: 1.5.4  File: $Revision: 1.72 $
    4747 * @link       http://pear.php.net/package/Auth
    4848 */
     
    110110    function _connect($dsn)
    111111    {
     112        $this->log('Auth_Container_DB::_connect() called.', AUTH_LOG_DEBUG);
     113
    112114        if (is_string($dsn) || is_array($dsn)) {
    113115            $this->db = DB::Connect($dsn, $this->options['db_options']);
     
    132134    }
    133135
     136    // }}}
     137    // {{{ _prepare()
     138
    134139    /**
    135140     * Prepare database connection
     
    148153                return $res;
    149154            }
     155        }
     156        if ($this->options['auto_quote'] && $this->db->dsn['phptype'] != 'sqlite') {
     157            $this->options['final_table'] = $this->db->quoteIdentifier($this->options['table']);
     158            $this->options['final_usernamecol'] = $this->db->quoteIdentifier($this->options['usernamecol']);
     159            $this->options['final_passwordcol'] = $this->db->quoteIdentifier($this->options['passwordcol']);
     160        } else {
     161            $this->options['final_table'] = $this->options['table'];
     162            $this->options['final_usernamecol'] = $this->options['usernamecol'];
     163            $this->options['final_passwordcol'] = $this->options['passwordcol'];
    150164        }
    151165        return true;
     
    194208        $this->options['cryptType']   = 'md5';
    195209        $this->options['db_options']  = array();
     210        $this->options['db_where']    = '';
     211        $this->options['auto_quote']  = true;
    196212    }
    197213
     
    212228            }
    213229        }
    214 
    215         /* Include additional fields if they exist */
    216         if (!empty($this->options['db_fields'])) {
     230    }
     231
     232    // }}}
     233    // {{{ _quoteDBFields()
     234
     235    /**
     236     * Quote the db_fields option to avoid the possibility of SQL injection.
     237     *
     238     * @access private
     239     * @return string A properly quoted string that can be concatenated into a
     240     * SELECT clause.
     241     */
     242    function _quoteDBFields()
     243    {
     244        if (isset($this->options['db_fields'])) {
    217245            if (is_array($this->options['db_fields'])) {
    218                 $this->options['db_fields'] = join($this->options['db_fields'], ', ');
    219             }
    220             $this->options['db_fields'] = ', '.$this->options['db_fields'];
    221         }
     246                if ($this->options['auto_quote']) {
     247                    $fields = array();
     248                    foreach ($this->options['db_fields'] as $field) {
     249                        $fields[] = $this->db->quoteIdentifier($field);
     250                    }
     251                    return implode(', ', $fields);
     252                } else {
     253                    return implode(', ', $this->options['db_fields']);
     254                }
     255            } else {
     256                if (strlen($this->options['db_fields']) > 0) {
     257                    if ($this->options['auto_quote']) {
     258                        return $this->db->quoteIdentifier($this->options['db_fields']);
     259                    } else {
     260                        return $this->options['db_fields'];
     261                    }
     262                }
     263            }
     264        }
     265
     266        return '';
    222267    }
    223268
     
    243288    function fetchData($username, $password, $isChallengeResponse=false)
    244289    {
     290        $this->log('Auth_Container_DB::fetchData() called.', AUTH_LOG_DEBUG);
    245291        // Prepare for a database query
    246292        $err = $this->_prepare();
     
    250296
    251297        // Find if db_fields contains a *, if so assume all columns are selected
    252         if (strstr($this->options['db_fields'], '*')) {
     298        if (is_string($this->options['db_fields'])
     299            && strstr($this->options['db_fields'], '*')) {
    253300            $sql_from = "*";
    254301        } else {
    255             $sql_from = $this->options['usernamecol'] . ", ".$this->options['passwordcol'].$this->options['db_fields'];
    256         }
    257         /*
    258          Old Style, removed to go around the oci8
    259          problem
    260          See bug 206
    261          http://pear.php.net/bugs/bug.php?id=206
    262 
    263         $query = "SELECT ! FROM ! WHERE ! = ?";
    264         $query_params = array(
    265                          $sql_from,
    266                          $this->options['table'],
    267                          $this->options['usernamecol'],
    268                          $username
    269                          );
    270         */
     302            $sql_from = $this->options['final_usernamecol'].
     303                ", ".$this->options['final_passwordcol'];
     304
     305            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     306                $sql_from .= ', '.$fields;
     307            }
     308        }
    271309
    272310        $query = "SELECT ".$sql_from.
    273                 " FROM ".$this->options['table'].
    274                 " WHERE ".$this->options['usernamecol']." = ".$this->db->quoteSmart($username);
     311                " FROM ".$this->options['final_table'].
     312                " WHERE ".$this->options['final_usernamecol']." = ".$this->db->quoteSmart($username);
     313
     314        // check if there is an optional parameter db_where
     315        if ($this->options['db_where'] != '') {
     316            // there is one, so add it to the query
     317            $query .= " AND ".$this->options['db_where'];
     318        }
     319
     320        $this->log('Running SQL against DB: '.$query, AUTH_LOG_DEBUG);
    275321
    276322        $res = $this->db->getRow($query, null, DB_FETCHMODE_ASSOC);
     
    293339            $res[$this->options['passwordcol']] = md5($res[$this->options['passwordcol']]
    294340                    .$this->_auth_obj->session['loginchallenege']);
    295            
     341
    296342            // UGLY cannot avoid without modifying verifyPassword
    297343            if ($this->options['cryptType'] == 'md5') {
    298344                $res[$this->options['passwordcol']] = md5($res[$this->options['passwordcol']]);
    299345            }
    300            
     346
    301347            //print " Hashed Password [{$res[$this->options['passwordcol']]}]<br/>\n";
    302348        }
     
    311357                    continue;
    312358                }
     359
     360                $this->log('Storing additional field: '.$key, AUTH_LOG_DEBUG);
     361
    313362                // Use reference to the auth object if exists
    314                 // This is because the auth session variable can change so a 
     363                // This is because the auth session variable can change so a
    315364                // static call to setAuthData does not make sence
    316365                $this->_auth_obj->setAuthData($key, $value);
     
    333382    function listUsers()
    334383    {
     384        $this->log('Auth_Container_DB::listUsers() called.', AUTH_LOG_DEBUG);
    335385        $err = $this->_prepare();
    336386        if ($err !== true) {
     
    341391
    342392        // Find if db_fields contains a *, if so assume all col are selected
    343         if (strstr($this->options['db_fields'], '*')) {
     393        if (   is_string($this->options['db_fields'])
     394            && strstr($this->options['db_fields'], '*')) {
    344395            $sql_from = "*";
    345396        } else {
    346             $sql_from = $this->options['usernamecol'] . ", ".$this->options['passwordcol'].$this->options['db_fields'];
     397            $sql_from = $this->options['final_usernamecol'].
     398                ", ".$this->options['final_passwordcol'];
     399
     400            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     401                $sql_from .= ', '.$fields;
     402            }
    347403        }
    348404
    349405        $query = sprintf("SELECT %s FROM %s",
    350406                         $sql_from,
    351                          $this->options['table']
     407                         $this->options['final_table']
    352408                         );
     409
     410        // check if there is an optional parameter db_where
     411        if ($this->options['db_where'] != '') {
     412            // there is one, so add it to the query
     413            $query .= " WHERE ".$this->options['db_where'];
     414        }
     415
     416        $this->log('Running SQL against DB: '.$query, AUTH_LOG_DEBUG);
     417
    353418        $res = $this->db->getAll($query, null, DB_FETCHMODE_ASSOC);
    354419
     
    361426            }
    362427        }
     428        $this->log('Found '.count($retVal).' users.', AUTH_LOG_DEBUG);
    363429        return $retVal;
    364430    }
     
    379445    function addUser($username, $password, $additional = "")
    380446    {
     447        $this->log('Auth_Container_DB::addUser() called.', AUTH_LOG_DEBUG);
    381448        $err = $this->_prepare();
    382449        if ($err !== true) {
     
    384451        }
    385452
    386         if (   isset($this->options['cryptType']) 
     453        if (   isset($this->options['cryptType'])
    387454            && $this->options['cryptType'] == 'none') {
    388455            $cryptFunction = 'strval';
    389         } elseif (   isset($this->options['cryptType']) 
     456        } elseif (   isset($this->options['cryptType'])
    390457                  && function_exists($this->options['cryptType'])) {
    391458            $cryptFunction = $this->options['cryptType'];
     
    401468        if (is_array($additional)) {
    402469            foreach ($additional as $key => $value) {
    403                 $additional_key .= ', ' . $key;
     470                if ($this->options['auto_quote']) {
     471                    $additional_key .= ', ' . $this->db->quoteIdentifier($key);
     472                } else {
     473                    $additional_key .= ', ' . $key;
     474                }
    404475                $additional_value .= ", " . $this->db->quoteSmart($value);
    405476            }
     
    407478
    408479        $query = sprintf("INSERT INTO %s (%s, %s%s) VALUES (%s, %s%s)",
    409                          $this->options['table'],
    410                          $this->options['usernamecol'],
    411                          $this->options['passwordcol'],
     480                         $this->options['final_table'],
     481                         $this->options['final_usernamecol'],
     482                         $this->options['final_passwordcol'],
    412483                         $additional_key,
    413484                         $this->db->quoteSmart($username),
     
    416487                         );
    417488
     489        $this->log('Running SQL against DB: '.$query, AUTH_LOG_DEBUG);
     490
    418491        $res = $this->query($query);
    419492
     
    438511    function removeUser($username)
    439512    {
     513        $this->log('Auth_Container_DB::removeUser() called.', AUTH_LOG_DEBUG);
     514
    440515        $err = $this->_prepare();
    441516        if ($err !== true) {
     
    443518        }
    444519
    445         $query = sprintf("DELETE FROM %s WHERE %s = %s",
    446                          $this->options['table'],
    447                          $this->options['usernamecol'],
    448                          $this->db->quoteSmart($username)
     520        // check if there is an optional parameter db_where
     521        if ($this->options['db_where'] != '') {
     522            // there is one, so add it to the query
     523            $where = " AND ".$this->options['db_where'];
     524        } else {
     525            $where = '';
     526        }
     527
     528        $query = sprintf("DELETE FROM %s WHERE %s = %s %s",
     529                         $this->options['final_table'],
     530                         $this->options['final_usernamecol'],
     531                         $this->db->quoteSmart($username),
     532                         $where
    449533                         );
     534
     535        $this->log('Running SQL against DB: '.$query, AUTH_LOG_DEBUG);
    450536
    451537        $res = $this->query($query);
     
    469555    function changePassword($username, $password)
    470556    {
     557        $this->log('Auth_Container_DB::changePassword() called.', AUTH_LOG_DEBUG);
    471558        $err = $this->_prepare();
    472559        if ($err !== true) {
     
    474561        }
    475562
    476         if (   isset($this->options['cryptType']) 
     563        if (   isset($this->options['cryptType'])
    477564            && $this->options['cryptType'] == 'none') {
    478565            $cryptFunction = 'strval';
    479         } elseif (   isset($this->options['cryptType']) 
     566        } elseif (   isset($this->options['cryptType'])
    480567                  && function_exists($this->options['cryptType'])) {
    481568            $cryptFunction = $this->options['cryptType'];
     
    486573        $password = $cryptFunction($password);
    487574
    488         $query = sprintf("UPDATE %s SET %s = %s WHERE %s = %s",
    489                          $this->options['table'],
    490                          $this->options['passwordcol'],
     575        // check if there is an optional parameter db_where
     576        if ($this->options['db_where'] != '') {
     577            // there is one, so add it to the query
     578            $where = " AND ".$this->options['db_where'];
     579        } else {
     580            $where = '';
     581        }
     582
     583        $query = sprintf("UPDATE %s SET %s = %s WHERE %s = %s %s",
     584                         $this->options['final_table'],
     585                         $this->options['final_passwordcol'],
    491586                         $this->db->quoteSmart($password),
    492                          $this->options['usernamecol'],
    493                          $this->db->quoteSmart($username)
     587                         $this->options['final_usernamecol'],
     588                         $this->db->quoteSmart($username),
     589                         $where
    494590                         );
     591
     592        $this->log('Running SQL against DB: '.$query, AUTH_LOG_DEBUG);
    495593
    496594        $res = $this->query($query);
  • OpenPNE/trunk/lib/include/Auth/Container/DBLite.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: DBLite.php,v 1.7 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: DBLite.php,v 1.18 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.3.0
     
    4646 * @copyright  2001-2006 The PHP Group
    4747 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    48  * @version    Release: 1.3.0  File: $Revision: 1.7 $
     48 * @version    Release: 1.5.4  File: $Revision: 1.18 $
    4949 * @link       http://pear.php.net/package/Auth
    5050 * @since      Class available since Release 1.3.0
     
    9494        $this->options['cryptType']   = 'md5';
    9595        $this->options['db_options']  = array();
     96        $this->options['db_where']    = '';
     97        $this->options['auto_quote']  = true;
    9698
    9799        if (is_array($dsn)) {
     
    117119    function _connect(&$dsn)
    118120    {
     121        $this->log('Auth_Container_DBLite::_connect() called.', AUTH_LOG_DEBUG);
    119122        if (is_string($dsn) || is_array($dsn)) {
    120123            $this->db =& DB::connect($dsn, $this->options['db_options']);
     
    152155            }
    153156        }
     157        if ($this->options['auto_quote'] && $this->db->dsn['phptype'] != 'sqlite') {
     158            $this->options['final_table'] = $this->db->quoteIdentifier($this->options['table']);
     159            $this->options['final_usernamecol'] = $this->db->quoteIdentifier($this->options['usernamecol']);
     160            $this->options['final_passwordcol'] = $this->db->quoteIdentifier($this->options['passwordcol']);
     161        } else {
     162            $this->options['final_table'] = $this->options['table'];
     163            $this->options['final_usernamecol'] = $this->options['usernamecol'];
     164            $this->options['final_passwordcol'] = $this->options['passwordcol'];
     165        }
    154166        return true;
    155167    }
     
    171183            }
    172184        }
    173 
    174         /* Include additional fields if they exist */
    175         if (!empty($this->options['db_fields'])) {
     185    }
     186
     187    // }}}
     188    // {{{ _quoteDBFields()
     189
     190    /**
     191     * Quote the db_fields option to avoid the possibility of SQL injection.
     192     *
     193     * @access private
     194     * @return string A properly quoted string that can be concatenated into a
     195     * SELECT clause.
     196     */
     197    function _quoteDBFields()
     198    {
     199        if (isset($this->options['db_fields'])) {
    176200            if (is_array($this->options['db_fields'])) {
    177                 $this->options['db_fields'] = join($this->options['db_fields'], ', ');
    178             }
    179             $this->options['db_fields'] = ', '.$this->options['db_fields'];
    180         }
     201                if ($this->options['auto_quote']) {
     202                    $fields = array();
     203                    foreach ($this->options['db_fields'] as $field) {
     204                        $fields[] = $this->db->quoteIdentifier($field);
     205                    }
     206                    return implode(', ', $fields);
     207                } else {
     208                    return implode(', ', $this->options['db_fields']);
     209                }
     210            } else {
     211                if (strlen($this->options['db_fields']) > 0) {
     212                    if ($this->options['auto_quote']) {
     213                        return $this->db->quoteIdentifier($this->options['db_fields']);
     214                    } else {
     215                        $this->options['db_fields'];
     216                    }
     217                }
     218            }
     219        }
     220
     221        return '';
    181222    }
    182223
     
    199240    function fetchData($username, $password)
    200241    {
     242        $this->log('Auth_Container_DBLite::fetchData() called.', AUTH_LOG_DEBUG);
    201243        // Prepare for a database query
    202244        $err = $this->_prepare();
     
    206248
    207249        // Find if db_fields contains a *, if so assume all col are selected
    208         if (strstr($this->options['db_fields'], '*')) {
     250        if (is_string($this->options['db_fields'])
     251            && strstr($this->options['db_fields'], '*')) {
    209252            $sql_from = "*";
    210253        } else {
    211             $sql_from = $this->options['usernamecol'] . ", ".$this->options['passwordcol'].$this->options['db_fields'];
    212         }
    213        
     254            $sql_from = $this->options['final_usernamecol'].
     255                ", ".$this->options['final_passwordcol'];
     256
     257            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     258                $sql_from .= ', '.$fields;
     259            }
     260        }
     261
    214262        $query = "SELECT ".$sql_from.
    215                 " FROM ".$this->options['table'].
    216                 " WHERE ".$this->options['usernamecol']." = ".$this->db->quoteSmart($username);
     263                " FROM ".$this->options['final_table'].
     264                " WHERE ".$this->options['final_usernamecol']." = ".$this->db->quoteSmart($username);
     265
     266        // check if there is an optional parameter db_where
     267        if ($this->options['db_where'] != '') {
     268            // there is one, so add it to the query
     269            $query .= " AND ".$this->options['db_where'];
     270        }
     271
     272        $this->log('Running SQL against DB: '.$query, AUTH_LOG_DEBUG);
     273
    217274        $res = $this->db->getRow($query, null, DB_FETCHMODE_ASSOC);
    218275
     
    233290                    continue;
    234291                }
     292
     293                $this->log('Storing additional field: '.$key, AUTH_LOG_DEBUG);
     294
    235295                // Use reference to the auth object if exists
    236296                // This is because the auth session variable can change so a static call to setAuthData does not make sence
  • OpenPNE/trunk/lib/include/Auth/Container/File.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Stefan Ekman <stekman@sedata.org> 
     17 * @author     Stefan Ekman <stekman@sedata.org>
    1818 * @author     Martin Jansen <mj@php.net>
    19  * @author     Mika Tuupola <tuupola@appelsiini.net> 
     19 * @author     Mika Tuupola <tuupola@appelsiini.net>
    2020 * @author     Michael Wallner <mike@php.net>
    2121 * @author     Adam Ashley <aashley@php.net>
    2222 * @copyright  2001-2006 The PHP Group
    2323 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    24  * @version    CVS: $Id: File.php,v 1.20 2006/03/02 06:53:08 aashley Exp $
     24 * @version    CVS: $Id: File.php,v 1.25 2007/06/12 03:11:26 aashley Exp $
    2525 * @link       http://pear.php.net/package/Auth
    2626 */
     
    4646 * @category   Authentication
    4747 * @package    Auth
    48  * @author     Stefan Ekman <stekman@sedata.org> 
     48 * @author     Stefan Ekman <stekman@sedata.org>
    4949 * @author     Martin Jansen <mj@php.net>
    50  * @author     Mika Tuupola <tuupola@appelsiini.net> 
     50 * @author     Mika Tuupola <tuupola@appelsiini.net>
    5151 * @author     Michael Wallner <mike@php.net>
    5252 * @author     Adam Ashley <aashley@php.net>
    5353 * @copyright  2001-2006 The PHP Group
    5454 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    55  * @version    Release: 1.3.0  File: $Revision: 1.20 $
     55 * @version    Release: 1.5.4  File: $Revision: 1.25 $
    5656 * @link       http://pear.php.net/package/Auth
    5757 */
     
    6363    /**
    6464     * Path to passwd file
    65      * 
     65     *
    6666     * @var string
    6767     */
    6868    var $pwfile = '';
     69
     70    /**
     71     * Options for container
     72     *
     73     * @var array
     74     */
     75    var $options = array();
    6976
    7077    // }}}
     
    7885     */
    7986    function Auth_Container_File($filename) {
     87        $this->_setDefaults();
     88
    8089        // Only file is a valid option here
    8190        if(is_array($filename)) {
    82             $filename = $filename['file'];
    83         }
    84         $this->pwfile = $filename;
     91            $this->pwfile = $filename['file'];
     92            $this->_parseOptions($filename);
     93        } else {
     94            $this->pwfile = $filename;
     95        }
    8596    }
    8697
     
    97108    function fetchData($user, $pass)
    98109    {
    99         return File_Passwd::staticAuth('Cvs', $this->pwfile, $user, $pass);
     110        $this->log('Auth_Container_File::fetchData() called.', AUTH_LOG_DEBUG);
     111        return File_Passwd::staticAuth($this->options['type'], $this->pwfile, $user, $pass);
    100112    }
    101113
    102114    // }}}
    103115    // {{{ listUsers()
    104    
     116
    105117    /**
    106118     * List all available users
    107      * 
     119     *
    108120     * @return   array
    109121     */
    110122    function listUsers()
    111123    {
     124        $this->log('Auth_Container_File::listUsers() called.', AUTH_LOG_DEBUG);
     125
    112126        $pw_obj = &$this->_load();
    113127        if (PEAR::isError($pw_obj)) {
     
    121135
    122136        foreach ($users as $key => $value) {
    123             $retVal[] = array("username" => $key, 
     137            $retVal[] = array("username" => $key,
    124138                              "password" => $value['passwd'],
    125139                              "cvsuser"  => $value['system']);
    126140        }
    127141
     142        $this->log('Found '.count($retVal).' users.', AUTH_LOG_DEBUG);
     143
    128144        return $retVal;
    129145    }
     
    137153     * @param string username
    138154     * @param string password
    139      * @param mixed  CVS username
     155     * @param mixed  Additional parameters to File_Password_*::addUser()
    140156     *
    141157     * @return boolean
     
    143159    function addUser($user, $pass, $additional='')
    144160    {
    145         $cvs = (string) (is_array($additional) && isset($additional['cvsuser'])) ?
    146                $additional['cvsuser'] : $additional;
     161        $this->log('Auth_Container_File::addUser() called.', AUTH_LOG_DEBUG);
     162        $params = array($user, $pass);
     163        if (is_array($additional)) {
     164            foreach ($additional as $item) {
     165                $params[] = $item;
     166            }
     167        } else {
     168            $params[] = $additional;
     169        }
    147170
    148171        $pw_obj = &$this->_load();
     
    150173            return false;
    151174        }
    152        
    153         $res = $pw_obj->addUser($user, $pass, $cvs);
    154         if (PEAR::isError($res)) {
    155             return false;
    156         }
    157        
     175
     176        $res = call_user_func_array(array(&$pw_obj, 'addUser'), $params);
     177        if (PEAR::isError($res)) {
     178            return false;
     179        }
     180
    158181        $res = $pw_obj->save();
    159182        if (PEAR::isError($res)) {
    160183            return false;
    161184        }
    162        
     185
    163186        return true;
    164187    }
     
    175198    function removeUser($user)
    176199    {
     200        $this->log('Auth_Container_File::removeUser() called.', AUTH_LOG_DEBUG);
    177201        $pw_obj = &$this->_load();
    178202        if (PEAR::isError($pw_obj)) {
    179203            return false;
    180204        }
    181        
     205
    182206        $res = $pw_obj->delUser($user);
    183207        if (PEAR::isError($res)) {
    184208            return false;
    185209        }
    186        
     210
    187211        $res = $pw_obj->save();
    188212        if (PEAR::isError($res)) {
    189213            return false;
    190214        }
    191        
     215
    192216        return true;
    193217    }
     
    200224     *
    201225     * @param string Username
    202      * @param string The new password 
     226     * @param string The new password
    203227     */
    204228    function changePassword($username, $password)
    205229    {
     230        $this->log('Auth_Container_File::changePassword() called.', AUTH_LOG_DEBUG);
    206231        $pw_obj = &$this->_load();
    207232        if (PEAR::isError($pw_obj)) {
    208233            return false;
    209234        }
    210        
     235
    211236        $res = $pw_obj->changePasswd($username, $password);
    212237        if (PEAR::isError($res)) {
    213238            return false;
    214239        }
    215        
     240
    216241        $res = $pw_obj->save();
    217242        if (PEAR::isError($res)) {
    218243            return false;
    219244        }
    220        
     245
    221246        return true;
    222247    }
     
    224249    // }}}
    225250    // {{{ _load()
    226    
     251
    227252    /**
    228253     * Load and initialize the File_Passwd object
    229      * 
     254     *
    230255     * @return  object  File_Passwd_Cvs|PEAR_Error
    231256     */
     
    233258    {
    234259        static $pw_obj;
    235        
     260
    236261        if (!isset($pw_obj)) {
    237             $pw_obj = File_Passwd::factory('Cvs');
     262            $this->log('Instanciating File_Password object of type '.$this->options['type'], AUTH_LOG_DEBUG);
     263            $pw_obj = File_Passwd::factory($this->options['type']);
    238264            if (PEAR::isError($pw_obj)) {
    239265                return $pw_obj;
    240266            }
    241            
     267
    242268            $pw_obj->setFile($this->pwfile);
    243            
     269
    244270            $res = $pw_obj->load();
    245271            if (PEAR::isError($res)) {
     
    247273            }
    248274        }
    249        
     275
    250276        return $pw_obj;
     277    }
     278
     279    // }}}
     280    // {{{ _setDefaults()
     281
     282    /**
     283     * Set some default options
     284     *
     285     * @access private
     286     * @return void
     287     */
     288    function _setDefaults()
     289    {
     290        $this->options['type']       = 'Cvs';
     291    }
     292
     293    // }}}
     294    // {{{ _parseOptions()
     295
     296    /**
     297     * Parse options passed to the container class
     298     *
     299     * @access private
     300     * @param  array
     301     */
     302    function _parseOptions($array)
     303    {
     304        foreach ($array as $key => $value) {
     305            if (isset($this->options[$key])) {
     306                $this->options[$key] = $value;
     307            }
     308        }
    251309    }
    252310
  • OpenPNE/trunk/lib/include/Auth/Container/IMAP.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Jeroen Houben <jeroen@terena.nl> 
     17 * @author     Jeroen Houben <jeroen@terena.nl>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: IMAP.php,v 1.14 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: IMAP.php,v 1.18 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.2.0
     
    2525
    2626/**
    27  * Include Auth_Container base class 
     27 * Include Auth_Container base class
    2828 */
    2929require_once "Auth/Container.php";
     
    7878 * @copyright  2001-2006 The PHP Group
    7979 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    80  * @version    Release: 1.3.0  File: $Revision: 1.14 $
     80 * @version    Release: 1.5.4  File: $Revision: 1.18 $
    8181 * @link       http://pear.php.net/package/Auth
    8282 * @since      Class available since Release 1.2.0
     
    149149     */
    150150    function _checkServer() {
     151        $this->log('Auth_Container_IMAP::_checkServer() called.', AUTH_LOG_DEBUG);
    151152        $fp = @fsockopen ($this->options['host'], $this->options['port'],
    152153                          $errno, $errstr, $this->options['timeout']);
     
    189190    function fetchData($username, $password)
    190191    {
     192        $this->log('Auth_Container_IMAP::fetchData() called.', AUTH_LOG_DEBUG);
    191193        $dsn = '{'.$this->options['host'].':'.$this->options['port'].$this->options['baseDSN'].'}';
    192194        $conn = @imap_open ($dsn, $username, $password, OP_HALFOPEN);
    193195        if (is_resource($conn)) {
     196            $this->log('Successfully connected to IMAP server.', AUTH_LOG_DEBUG);
    194197            $this->activeUser = $username;
    195198            @imap_close($conn);
    196199            return true;
    197200        } else {
     201            $this->log('Connection to IMAP server failed.', AUTH_LOG_DEBUG);
    198202            $this->activeUser = '';
    199203            return false;
  • OpenPNE/trunk/lib/include/Auth/Container/LDAP.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Jan Wagner <wagner@netsols.de> 
     17 * @author     Jan Wagner <wagner@netsols.de>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @author     Hugues Peeters <hugues.peeters@claroline.net>
    2020 * @copyright  2001-2006 The PHP Group
    2121 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    22  * @version    CVS: $Id: LDAP.php,v 1.30 2006/03/02 06:53:08 aashley Exp $
     22 * @version    CVS: $Id: LDAP.php,v 1.43 2007/06/12 03:11:26 aashley Exp $
    2323 * @link       http://pear.php.net/package/Auth
    2424 */
     
    7676 *              Auth::getAuthData(). An empty array will fetch all attributes,
    7777 *              array('') will fetch no attributes at all (default)
     78 *              If you add 'dn' as a value to this array, the users DN that was
     79 *              used for binding will be added to auth data as well.
    7880 * attrformat:  The returned format of the additional data defined in the
    7981 *              'attributes' option. Two formats are available.
     
    102104 * group:       the name of group to search for
    103105 * groupscope:  Scope for group searching: one, sub (default), or base
     106 * start_tls:   enable/disable the use of START_TLS encrypted connection
     107 *              (default: false)
    104108 * debug:       Enable/Disable debugging output (default: false)
     109 * try_all:     Whether to try all user accounts returned from the search
     110 *              or just the first one. (default: false)
    105111 *
    106112 * To use this storage container, you have to use the following syntax:
     
    172178 * is not allowed, so you have to set binddn and bindpw for
    173179 * user searching.
    174  * 
     180 *
    175181 * LDAP Referrals need to be set to false for AD to work sometimes.
    176182 *
    177  * Example a3 shows a full blown and tested example for connection to 
     183 * Example a3 shows a full blown and tested example for connection to
    178184 * Windows 2000 Active Directory with group mebership checking
     185 *
     186 * Note also that if you want an encrypted connection to an MS LDAP
     187 * server, then, on your webserver, you must specify
     188 *        TLS_REQCERT never
     189 * in /etc/ldap/ldap.conf or in the webserver user's ~/.ldaprc (which
     190 * may or may not be read depending on your configuration).
     191 *
    179192 *
    180193 * @category   Authentication
     
    185198 * @copyright  2001-2006 The PHP Group
    186199 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    187  * @version    Release: 1.3.0  File: $Revision: 1.30 $
     200 * @version    Release: 1.5.4  File: $Revision: 1.43 $
    188201 * @link       http://pear.php.net/package/Auth
    189202 */
     
    230243
    231244    // }}}
     245    // {{{ _prepare()
     246
     247    /**
     248     * Prepare LDAP connection
     249     *
     250     * This function checks if we have already opened a connection to
     251     * the LDAP server. If that's not the case, a new connection is opened.
     252     *
     253     * @access private
     254     * @return mixed True or a PEAR error object.
     255     */
     256    function _prepare()
     257    {
     258        if (!$this->_isValidLink()) {
     259            $res = $this->_connect();
     260            if (PEAR::isError($res)) {
     261                return $res;
     262            }
     263        }
     264        return true;
     265    }
     266
     267    // }}}
    232268    // {{{ _connect()
    233269
     
    240276    function _connect()
    241277    {
     278        $this->log('Auth_Container_LDAP::_connect() called.', AUTH_LOG_DEBUG);
    242279        // connect
    243280        if (isset($this->options['url']) && $this->options['url'] != '') {
    244             $this->_debug('Connecting with URL', __LINE__);
     281            $this->log('Connecting with URL', AUTH_LOG_DEBUG);
    245282            $conn_params = array($this->options['url']);
    246283        } else {
    247             $this->_debug('Connecting with host:port', __LINE__);
     284            $this->log('Connecting with host:port', AUTH_LOG_DEBUG);
    248285            $conn_params = array($this->options['host'], $this->options['port']);
    249286        }
    250287
    251288        if (($this->conn_id = @call_user_func_array('ldap_connect', $conn_params)) === false) {
     289            $this->log('Connection to server failed.', AUTH_LOG_DEBUG);
     290            $this->log('LDAP ERROR: '.ldap_errno($this->conn_id).': '.ldap_error($this->conn_id), AUTH_LOG_DEBUG);
    252291            return PEAR::raiseError('Auth_Container_LDAP: Could not connect to server.', 41);
    253292        }
    254         $this->_debug('Successfully connected to server', __LINE__);
     293        $this->log('Successfully connected to server', AUTH_LOG_DEBUG);
    255294
    256295        // switch LDAP version
    257         if (is_int($this->options['version']) && $this->options['version'] > 2) {
    258             $this->_debug("Switching to LDAP version {$this->options['version']}", __LINE__);
     296        if (is_numeric($this->options['version']) && $this->options['version'] > 2) {
     297            $this->log("Switching to LDAP version {$this->options['version']}", AUTH_LOG_DEBUG);
    259298            @ldap_set_option($this->conn_id, LDAP_OPT_PROTOCOL_VERSION, $this->options['version']);
     299
     300            // start TLS if available
     301            if (isset($this->options['start_tls']) && $this->options['start_tls']) {
     302                $this->log("Starting TLS session", AUTH_LOG_DEBUG);
     303                if (@ldap_start_tls($this->conn_id) === false) {
     304                    $this->log('Could not start TLS session', AUTH_LOG_DEBUG);
     305                    $this->log('LDAP ERROR: '.ldap_errno($this->conn_id).': '.ldap_error($this->conn_id), AUTH_LOG_DEBUG);
     306                    return PEAR::raiseError('Auth_Container_LDAP: Could not start tls.', 41);
     307                }
     308            }
    260309        }
    261310
    262311        // switch LDAP referrals
    263312        if (is_bool($this->options['referrals'])) {
    264           $this->_debug("Switching LDAP referrals to " . (($this->options['referrals']) ? 'true' : 'false'), __LINE__);
    265           @ldap_set_option($this->conn_id, LDAP_OPT_REFERRALS, $this->options['referrals']);
     313            $this->log("Switching LDAP referrals to " . (($this->options['referrals']) ? 'true' : 'false'), AUTH_LOG_DEBUG);
     314            if (@ldap_set_option($this->conn_id, LDAP_OPT_REFERRALS, $this->options['referrals']) === false) {
     315                $this->log('Could not change LDAP referrals options', AUTH_LOG_DEBUG);
     316                $this->log('LDAP ERROR: '.ldap_errno($this->conn_id).': '.ldap_error($this->conn_id), AUTH_LOG_DEBUG);
     317            }
    266318        }
    267319
    268320        // bind with credentials or anonymously
    269321        if (strlen($this->options['binddn']) && strlen($this->options['bindpw'])) {
    270             $this->_debug('Binding with credentials', __LINE__);
     322            $this->log('Binding with credentials', AUTH_LOG_DEBUG);
    271323            $bind_params = array($this->conn_id, $this->options['binddn'], $this->options['bindpw']);
    272324        } else {
    273             $this->_debug('Binding anonymously', __LINE__);
     325            $this->log('Binding anonymously', AUTH_LOG_DEBUG);
    274326            $bind_params = array($this->conn_id);
    275327        }
     
    277329        // bind for searching
    278330        if ((@call_user_func_array('ldap_bind', $bind_params)) === false) {
    279             $this->_debug();
     331            $this->log('Bind failed', AUTH_LOG_DEBUG);
     332            $this->log('LDAP ERROR: '.ldap_errno($this->conn_id).': '.ldap_error($this->conn_id), AUTH_LOG_DEBUG);
    280333            $this->_disconnect();
    281334            return PEAR::raiseError("Auth_Container_LDAP: Could not bind to LDAP server.", 41);
    282335        }
    283         $this->_debug('Binding was successful', __LINE__);
     336        $this->log('Binding was successful', AUTH_LOG_DEBUG);
     337
     338        return true;
    284339    }
    285340
     
    294349    function _disconnect()
    295350    {
     351        $this->log('Auth_Container_LDAP::_disconnect() called.', AUTH_LOG_DEBUG);
    296352        if ($this->_isValidLink()) {
    297             $this->_debug('disconnecting from server');
     353            $this->log('disconnecting from server');
    298354            @ldap_unbind($this->conn_id);
    299355        }
     
    310366    function _getBaseDN()
    311367    {
     368        $this->log('Auth_Container_LDAP::_getBaseDN() called.', AUTH_LOG_DEBUG);
     369        $err = $this->_prepare();
     370        if ($err !== true) {
     371            return PEAR::raiseError($err->getMessage(), $err->getCode());
     372        }
     373
    312374        if ($this->options['basedn'] == "" && $this->_isValidLink()) {
    313             $this->_debug("basedn not set, searching via namingContexts.", __LINE__);
     375            $this->log("basedn not set, searching via namingContexts.", AUTH_LOG_DEBUG);
    314376
    315377            $result_id = @ldap_read($this->conn_id, "", "(objectclass=*)", array("namingContexts"));
     
    317379            if (@ldap_count_entries($this->conn_id, $result_id) == 1) {
    318380
    319                 $this->_debug("got result for namingContexts", __LINE__);
     381                $this->log("got result for namingContexts", AUTH_LOG_DEBUG);
    320382
    321383                $entry_id = @ldap_first_entry($this->conn_id, $result_id);
     
    324386
    325387                if ($basedn != "") {
    326                     $this->_debug("result for namingContexts was $basedn", __LINE__);
     388                    $this->log("result for namingContexts was $basedn", AUTH_LOG_DEBUG);
    327389                    $this->options['basedn'] = $basedn;
    328390                }
     
    333395        // if base ist still not set, raise error
    334396        if ($this->options['basedn'] == "") {
    335             return PEAR::raiseError("Auth_Container_LDAP: LDAP search base not specified!", 41, PEAR_ERROR_DIE);
     397            return PEAR::raiseError("Auth_Container_LDAP: LDAP search base not specified!", 41);
    336398        }
    337399        return true;
     
    380442        $this->options['userfilter']  = '(objectClass=posixAccount)';
    381443        $this->options['attributes']  = array(''); // no attributes
    382      // $this->options['attrformat']  = 'LDAP'; // returns attribute array as PHP LDAP functions return it
    383444        $this->options['attrformat']  = 'AUTH'; // returns attribute like other Auth containers
    384445        $this->options['group']       = '';
     
    389450        $this->options['memberattr']  = 'uniqueMember';
    390451        $this->options['memberisdn']  = true;
     452        $this->options['start_tls']   = false;
    391453        $this->options['debug']       = false;
     454        $this->options['try_all']     = false; // Try all user ids returned not just the first one
    392455    }
    393456
     
    425488    /**
    426489     * Adapt deprecated options from Auth 1.2 LDAP to Auth 1.3 LDAP
    427      * 
     490     *
    428491     * @author Hugues Peeters <hugues.peeters@claroline.net>
    429492     * @access private
     
    484547    function fetchData($username, $password)
    485548    {
    486         $this->_connect();
    487         $this->_getBaseDN();
     549        $this->log('Auth_Container_LDAP::fetchData() called.', AUTH_LOG_DEBUG);
     550        $err = $this->_prepare();
     551        if ($err !== true) {
     552            return PEAR::raiseError($err->getMessage(), $err->getCode());
     553        }
     554
     555        $err = $this->_getBaseDN();
     556        if ($err !== true) {
     557            return PEAR::raiseError($err->getMessage(), $err->getCode());
     558        }
    488559
    489560        // UTF8 Encode username for LDAPv3
    490561        if (@ldap_get_option($this->conn_id, LDAP_OPT_PROTOCOL_VERSION, $ver) && $ver == 3) {
    491             $this->_debug('UTF8 encoding username for LDAPv3', __LINE__);
     562            $this->log('UTF8 encoding username for LDAPv3', AUTH_LOG_DEBUG);
    492563            $username = utf8_encode($username);
    493564        }
     
    507578
    508579        // attributes
    509         $attributes = $this->options['attributes'];
     580        $searchAttributes = $this->options['attributes'];
    510581
    511582        // make functions params array
    512         $func_params = array($this->conn_id, $search_basedn, $filter, $attributes);
     583        $func_params = array($this->conn_id, $search_basedn, $filter, $searchAttributes);
    513584
    514585        // search function to use
    515586        $func_name = $this->_scope2function($this->options['userscope']);
    516587
    517         $this->_debug("Searching with $func_name and filter $filter in $search_basedn", __LINE__);
     588        $this->log("Searching with $func_name and filter $filter in $search_basedn", AUTH_LOG_DEBUG);
    518589
    519590        // search
    520591        if (($result_id = @call_user_func_array($func_name, $func_params)) === false) {
    521             $this->_debug('User not found', __LINE__);
    522         } elseif (@ldap_count_entries($this->conn_id, $result_id) == 1) { // did we get just one entry?
    523 
    524             $this->_debug('User was found', __LINE__);
    525 
    526             // then get the user dn
    527             $entry_id = @ldap_first_entry($this->conn_id, $result_id);
    528             $user_dn  = @ldap_get_dn($this->conn_id, $entry_id);
    529 
    530             // fetch attributes
    531             if ($attributes = @ldap_get_attributes($this->conn_id, $entry_id)) {
    532 
    533                 if (is_array($attributes) && isset($attributes['count']) &&
    534                      $attributes['count'] > 0) {
    535 
    536                     // ldap_get_attributes() returns a specific multi dimensional array
    537                     // format containing all the attributes and where each array starts
    538                     // with a 'count' element providing the number of attributes in the
    539                     // entry, or the number of values for attribute. For compatibility
    540                     // reasons, it remains the default format returned by LDAP container
    541                     // setAuthData().
    542                     // The code below optionally returns attributes in another format,
    543                     // more compliant with other Auth containers, where each attribute
    544                     // element are directly set in the 'authData' list. This option is
    545                     // enabled by setting 'attrformat' to
    546                     // 'AUTH' in the 'options' array.
    547                     // eg. $this->options['attrformat'] = 'AUTH'
    548 
    549                     if ( strtoupper($this->options['attrformat']) == 'AUTH' ) {
    550                         $this->_debug('Saving attributes to Auth data in AUTH format', __LINE__);
    551                         unset ($attributes['count']);
    552                         foreach ($attributes as $attributeName => $attributeValue ) {
    553                             if (is_int($attributeName)) continue;
    554                             if (is_array($attributeValue) && isset($attributeValue['count'])) {
    555                                 unset ($attributeValue['count']);
     592            $this->log('User not found', AUTH_LOG_DEBUG);
     593        } elseif (@ldap_count_entries($this->conn_id, $result_id) >= 1) { // did we get some possible results?
     594
     595            $this->log('User(s) found', AUTH_LOG_DEBUG);
     596
     597            $first = true;
     598            $entry_id = null;
     599
     600            do {
     601
     602                // then get the user dn
     603                if ($first) {
     604                    $entry_id = @ldap_first_entry($this->conn_id, $result_id);
     605                    $first = false;
     606                } else {
     607                    $entry_id = @ldap_next_entry($this->conn_id, $entry_id);
     608                    if ($entry_id === false)
     609                        break;
     610                }
     611                $user_dn  = @ldap_get_dn($this->conn_id, $entry_id);
     612
     613                // as the dn is not fetched as an attribute, we save it anyway
     614                if (is_array($searchAttributes) && in_array('dn', $searchAttributes)) {
     615                    $this->log('Saving DN to AuthData', AUTH_LOG_DEBUG);
     616                    $this->_auth_obj->setAuthData('dn', $user_dn);
     617                }
     618
     619                // fetch attributes
     620                if ($attributes = @ldap_get_attributes($this->conn_id, $entry_id)) {
     621
     622                    if (is_array($attributes) && isset($attributes['count']) &&
     623                         $attributes['count'] > 0) {
     624
     625                        // ldap_get_attributes() returns a specific multi dimensional array
     626                        // format containing all the attributes and where each array starts
     627                        // with a 'count' element providing the number of attributes in the
     628                        // entry, or the number of values for attribute. For compatibility
     629                        // reasons, it remains the default format returned by LDAP container
     630                        // setAuthData().
     631                        // The code below optionally returns attributes in another format,
     632                        // more compliant with other Auth containers, where each attribute
     633                        // element are directly set in the 'authData' list. This option is
     634                        // enabled by setting 'attrformat' to
     635                        // 'AUTH' in the 'options' array.
     636                        // eg. $this->options['attrformat'] = 'AUTH'
     637
     638                        if ( strtoupper($this->options['attrformat']) == 'AUTH' ) {
     639                            $this->log('Saving attributes to Auth data in AUTH format', AUTH_LOG_DEBUG);
     640                            unset ($attributes['count']);
     641                            foreach ($attributes as $attributeName => $attributeValue ) {
     642                                if (is_int($attributeName)) continue;
     643                                if (is_array($attributeValue) && isset($attributeValue['count'])) {
     644                                    unset ($attributeValue['count']);
     645                                }
     646                                if (count($attributeValue)<=1) $attributeValue = $attributeValue[0];
     647                                $this->log('Storing additional field: '.$attributeName, AUTH_LOG_DEBUG);
     648                                $this->_auth_obj->setAuthData($attributeName, $attributeValue);
    556649                            }
    557                             if (count($attributeValue)<=1) $attributeValue = $attributeValue[0];
    558                             $this->_auth_obj->setAuthData($attributeName, $attributeValue);
     650                        }
     651                        else
     652                        {
     653                            $this->log('Saving attributes to Auth data in LDAP format', AUTH_LOG_DEBUG);
     654                            $this->_auth_obj->setAuthData('attributes', $attributes);
    559655                        }
    560656                    }
    561                     else
    562                     {
    563                         $this->_debug('Saving attributes to Auth data in LDAP format', __LINE__);
    564                         $this->_auth_obj->setAuthData('attributes', $attributes);
    565                     }
    566657                }
    567             }
    568             @ldap_free_result($result_id);
    569 
    570             // need to catch an empty password as openldap seems to return TRUE
    571             // if anonymous binding is allowed
    572             if ($password != "") {
    573                 $this->_debug("Bind as $user_dn", __LINE__);
    574 
    575                 // try binding as this user with the supplied password
    576                 if (@ldap_bind($this->conn_id, $user_dn, $password)) {
    577                     $this->_debug('Bind successful', __LINE__);
    578 
    579                     // check group if appropiate
    580                     if (strlen($this->options['group'])) {
    581                         // decide whether memberattr value is a dn or the username
    582                         $this->_debug('Checking group membership', __LINE__);
    583                         return $this->checkGroup(($this->options['memberisdn']) ? $user_dn : $username);
    584                     } else {
    585                         $this->_debug('Authenticated', __LINE__);
    586                         $this->_disconnect();
    587                         return true; // user authenticated
    588                     } // checkGroup
    589                 } // bind
    590             } // non-empty password
    591         } // one entry
     658                @ldap_free_result($result_id);
     659
     660                // need to catch an empty password as openldap seems to return TRUE
     661                // if anonymous binding is allowed
     662                if ($password != "") {
     663                    $this->log("Bind as $user_dn", AUTH_LOG_DEBUG);
     664
     665                    // try binding as this user with the supplied password
     666                    if (@ldap_bind($this->conn_id, $user_dn, $password)) {
     667                        $this->log('Bind successful', AUTH_LOG_DEBUG);
     668
     669                        // check group if appropiate
     670                        if (strlen($this->options['group'])) {
     671                            // decide whether memberattr value is a dn or the username
     672                            $this->log('Checking group membership', AUTH_LOG_DEBUG);
     673                            $return = $this->checkGroup(($this->options['memberisdn']) ? $user_dn : $username);
     674                            $this->_disconnect();
     675                            return $return;
     676                        } else {
     677                            $this->log('Authenticated', AUTH_LOG_DEBUG);
     678                            $this->_disconnect();
     679                            return true; // user authenticated
     680                        } // checkGroup
     681                    } // bind
     682                } // non-empty password
     683            } while ($this->options['try_all'] == true); // interate through entries
     684        } // get results
    592685        // default
    593         $this->_debug('NOT authenticated!', __LINE__);
     686        $this->log('NOT authenticated!', AUTH_LOG_DEBUG);
    594687        $this->_disconnect();
    595688        return false;
     
    603696     *
    604697     * Searches the LDAP server for group membership of the
    605      * authenticated user.  Quotes all LDAP filter meta characters in
     698     * supplied username.  Quotes all LDAP filter meta characters in
    606699     * the user name before querying the LDAP server.
    607700     *
     
    611704    function checkGroup($user)
    612705    {
     706        $this->log('Auth_Container_LDAP::checkGroup() called.', AUTH_LOG_DEBUG);
     707        $err = $this->_prepare();
     708        if ($err !== true) {
     709            return PEAR::raiseError($err->getMessage(), $err->getCode());
     710        }
     711
    613712        // make filter
    614713        $filter = sprintf('(&(%s=%s)(%s=%s)%s)',
     
    630729        $func_name = $this->_scope2function($this->options['groupscope']);
    631730
    632         $this->_debug("Searching with $func_name and filter $filter in $search_basedn", __LINE__);
     731        $this->log("Searching with $func_name and filter $filter in $search_basedn", AUTH_LOG_DEBUG);
    633732
    634733        // search
     
    636735            if (@ldap_count_entries($this->conn_id, $result_id) == 1) {
    637736                @ldap_free_result($result_id);
    638                 $this->_debug('User is member of group', __LINE__);
    639                 $this->_disconnect();
     737                $this->log('User is member of group', AUTH_LOG_DEBUG);
    640738                return true;
    641739            }
    642740        }
    643741        // default
    644         $this->_debug('User is NOT member of group', __LINE__);
    645         $this->_disconnect();
     742        $this->log('User is NOT member of group', AUTH_LOG_DEBUG);
    646743        return false;
    647     }
    648 
    649     // }}}
    650     // {{{ _debug()
    651 
    652     /**
    653      * Outputs debugging messages
    654      *
    655      * @access private
    656      * @param string Debugging Message
    657      * @param integer Line number
    658      */
    659     function _debug($msg = '', $line = 0)
    660     {
    661         if ($this->options['debug'] === true) {
    662             if ($msg == '' && $this->_isValidLink()) {
    663                 $msg = 'LDAP_Error: ' . @ldap_err2str(@ldap_errno($this->_conn_id));
    664             }
    665             print("$line: $msg <br />");
    666         }
    667744    }
    668745
  • OpenPNE/trunk/lib/include/Auth/Container/MDB.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Lorenzo Alberton <l.alberton@quipo.it> 
     17 * @author     Lorenzo Alberton <l.alberton@quipo.it>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: MDB.php,v 1.24 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: MDB.php,v 1.35 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.2.3
     
    4545 * @copyright  2001-2006 The PHP Group
    4646 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    47  * @version    Release: 1.3.0  File: $Revision: 1.24 $
     47 * @version    Release: 1.5.4  File: $Revision: 1.35 $
    4848 * @link       http://pear.php.net/package/Auth
    4949 * @since      Class available since Release 1.2.3
     
    110110    function _connect($dsn)
    111111    {
     112        $this->log('Auth_Container_MDB::_connect() called.', AUTH_LOG_DEBUG);
    112113        if (is_string($dsn) || is_array($dsn)) {
    113114            $this->db =& MDB::connect($dsn, $this->options['db_options']);
     
    129130            return PEAR::raiseError($this->db->getMessage(), $this->db->code);
    130131        }
     132
     133        if ($this->options['auto_quote']) {
     134            $this->options['final_table'] = $this->db->quoteIdentifier($this->options['table']);
     135            $this->options['final_usernamecol'] = $this->db->quoteIdentifier($this->options['usernamecol']);
     136            $this->options['final_passwordcol'] = $this->db->quoteIdentifier($this->options['passwordcol']);
     137        } else {
     138            $this->options['final_table'] = $this->options['table'];
     139            $this->options['final_usernamecol'] = $this->options['usernamecol'];
     140            $this->options['final_passwordcol'] = $this->options['passwordcol'];
     141        }
     142
    131143        return true;
    132144    }
     
    169181    function query($query)
    170182    {
     183        $this->log('Auth_Container_MDB::query() called.', AUTH_LOG_DEBUG);
    171184        $err = $this->_prepare();
    172185        if ($err !== true) {
     
    194207        $this->options['cryptType']   = 'md5';
    195208        $this->options['db_options']  = array();
     209        $this->options['db_where']    = '';
     210        $this->options['auto_quote']  = true;
    196211    }
    197212
     
    212227            }
    213228        }
    214 
    215         // Include additional fields if they exist
    216         if (!empty($this->options['db_fields'])) {
     229    }
     230
     231    // }}}
     232    // {{{ _quoteDBFields()
     233
     234    /**
     235     * Quote the db_fields option to avoid the possibility of SQL injection.
     236     *
     237     * @access private
     238     * @return string A properly quoted string that can be concatenated into a
     239     * SELECT clause.
     240     */
     241    function _quoteDBFields()
     242    {
     243        if (isset($this->options['db_fields'])) {
    217244            if (is_array($this->options['db_fields'])) {
    218                 $this->options['db_fields'] = join($this->options['db_fields'], ', ');
    219             }
    220             $this->options['db_fields'] = ', ' . $this->options['db_fields'];
    221         }
     245                if ($this->options['auto_quote']) {
     246                    $fields = array();
     247                    foreach ($this->options['db_fields'] as $field) {
     248                        $fields[] = $this->db->quoteIdentifier($field);
     249                    }
     250                    return implode(', ', $fields);
     251                } else {
     252                    return implode(', ', $this->options['db_fields']);
     253                }
     254            } else {
     255                if (strlen($this->options['db_fields']) > 0) {
     256                    if ($this->options['auto_quote']) {
     257                        return $this->db->quoteIdentifier($this->options['db_fields']);
     258                    } else {
     259                        return $this->options['db_fields'];
     260                    }
     261                }
     262            }
     263        }
     264
     265        return '';
    222266    }
    223267
     
    243287    function fetchData($username, $password, $isChallengeResponse=false)
    244288    {
     289        $this->log('Auth_Container_MDB::fetchData() called.', AUTH_LOG_DEBUG);
    245290        // Prepare for a database query
    246291        $err = $this->_prepare();
     
    250295
    251296        //Check if db_fields contains a *, if so assume all columns are selected
    252         if (strstr($this->options['db_fields'], '*')) {
     297        if (is_string($this->options['db_fields'])
     298            && strstr($this->options['db_fields'], '*')) {
    253299            $sql_from = '*';
    254300        } else {
    255             $sql_from = $this->options['usernamecol'] . ', '. $this->options['passwordcol'] . $this->options['db_fields'];
     301            $sql_from = $this->options['final_usernamecol'].
     302                ", ".$this->options['final_passwordcol'];
     303
     304            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     305                $sql_from .= ', '.$fields;
     306            }
    256307        }
    257308
    258309        $query = sprintf("SELECT %s FROM %s WHERE %s = %s",
    259310                         $sql_from,
    260                          $this->options['table'],
    261                          $this->options['usernamecol'],
     311                         $this->options['final_table'],
     312                         $this->options['final_usernamecol'],
    262313                         $this->db->getTextValue($username)
    263314                         );
     315
     316        // check if there is an optional parameter db_where
     317        if ($this->options['db_where'] != '') {
     318            // there is one, so add it to the query
     319            $query .= " AND ".$this->options['db_where'];
     320        }
     321
     322        $this->log('Running SQL against MDB: '.$query, AUTH_LOG_DEBUG);
    264323
    265324        $res = $this->db->getRow($query, null, null, null, MDB_FETCHMODE_ASSOC);
     
    276335        $password = trim($password, "\r\n");
    277336        $res[$this->options['passwordcol']] = trim($res[$this->options['passwordcol']], "\r\n");
    278        
     337
    279338        // If using Challenge Response md5 the pass with the secret
    280339        if ($isChallengeResponse) {
     
    286345            }
    287346        }
    288        
     347
    289348        if ($this->verifyPassword($password,
    290349                                  $res[$this->options['passwordcol']],
     
    296355                    continue;
    297356                }
     357
     358                $this->log('Storing additional field: '.$key, AUTH_LOG_DEBUG);
    298359                // Use reference to the auth object if exists
    299360                // This is because the auth session variable can change so a static
     
    319380    function listUsers()
    320381    {
     382        $this->log('Auth_Container_MDB::listUsers() called.', AUTH_LOG_DEBUG);
    321383        $err = $this->_prepare();
    322384        if ($err !== true) {
     
    327389
    328390        //Check if db_fields contains a *, if so assume all columns are selected
    329         if (strstr($this->options['db_fields'], '*')) {
     391        if (   is_string($this->options['db_fields'])
     392            && strstr($this->options['db_fields'], '*')) {
    330393            $sql_from = '*';
    331394        } else {
    332             $sql_from = $this->options['db_fields'];
     395            $sql_from = $this->options['final_usernamecol']
     396                .', '.$this->options['final_passwordcol'];
     397
     398            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     399                $sql_from .= ', '.$fields;
     400            }
    333401        }
    334402
    335403        $query = sprintf('SELECT %s FROM %s',
    336404                         $sql_from,
    337                          $this->options['table']
     405                         $this->options['final_table']
    338406                         );
     407
     408        // check if there is an optional parameter db_where
     409        if ($this->options['db_where'] != '') {
     410            // there is one, so add it to the query
     411            $query .= " WHERE ".$this->options['db_where'];
     412        }
     413
     414        $this->log('Running SQL against MDB: '.$query, AUTH_LOG_DEBUG);
    339415
    340416        $res = $this->db->getAll($query, null, null, null, MDB_FETCHMODE_ASSOC);
     
    348424            }
    349425        }
     426        $this->log('Found '.count($retVal).' users.', AUTH_LOG_DEBUG);
    350427        return $retVal;
    351428    }
     
    366443    function addUser($username, $password, $additional = "")
    367444    {
     445        $this->log('Auth_Container_MDB::addUser() called.', AUTH_LOG_DEBUG);
    368446        $err = $this->_prepare();
    369447        if ($err !== true) {
     
    386464        if (is_array($additional)) {
    387465            foreach ($additional as $key => $value) {
    388                 $additional_key   .= ', ' . $key;
     466                if ($this->options['auto_quote']) {
     467                    $additional_key   .= ', ' . $this->db->quoteIdentifier($key);
     468                } else {
     469                    $additional_key   .= ', ' . $key;
     470                }
    389471                $additional_value .= ', ' . $this->db->getTextValue($value);
    390472            }
     
    392474
    393475        $query = sprintf("INSERT INTO %s (%s, %s%s) VALUES (%s, %s%s)",
    394                          $this->options['table'],
    395                          $this->options['usernamecol'],
    396                          $this->options['passwordcol'],
     476                         $this->options['final_table'],
     477                         $this->options['final_usernamecol'],
     478                         $this->options['final_passwordcol'],
    397479                         $additional_key,
    398480                         $this->db->getTextValue($username),
     
    401483                         );
    402484
     485        $this->log('Running SQL against MDB: '.$query, AUTH_LOG_DEBUG);
     486
    403487        $res = $this->query($query);
    404488
     
    422506    function removeUser($username)
    423507    {
     508        $this->log('Auth_Container_MDB::removeUser() called.', AUTH_LOG_DEBUG);
    424509        $err = $this->_prepare();
    425510        if ($err !== true) {
     
    428513
    429514        $query = sprintf("DELETE FROM %s WHERE %s = %s",
    430                          $this->options['table'],
    431                          $this->options['usernamecol'],
     515                         $this->options['final_table'],
     516                         $this->options['final_usernamecol'],
    432517                         $this->db->getTextValue($username)
    433518                         );
    434519
     520        // check if there is an optional parameter db_where
     521        if ($this->options['db_where'] != '') {
     522            // there is one, so add it to the query
     523            $query .= " AND ".$this->options['db_where'];
     524        }
     525
     526        $this->log('Running SQL against MDB: '.$query, AUTH_LOG_DEBUG);
     527
    435528        $res = $this->query($query);
    436529
     
    452545    function changePassword($username, $password)
    453546    {
     547        $this->log('Auth_Container_MDB::changePassword() called.', AUTH_LOG_DEBUG);
    454548        $err = $this->_prepare();
    455549        if ($err !== true) {
     
    468562
    469563        $query = sprintf("UPDATE %s SET %s = %s WHERE %s = %s",
    470                          $this->options['table'],
    471                          $this->options['passwordcol'],
     564                         $this->options['final_table'],
     565                         $this->options['final_passwordcol'],
    472566                         $this->db->getTextValue($password),
    473                          $this->options['usernamecol'],
     567                         $this->options['final_usernamecol'],
    474568                         $this->db->getTextValue($username)
    475569                         );
    476570
     571        // check if there is an optional parameter db_where
     572        if ($this->options['db_where'] != '') {
     573            // there is one, so add it to the query
     574            $query .= " AND ".$this->options['db_where'];
     575        }
     576
     577        $this->log('Running SQL against MDB: '.$query, AUTH_LOG_DEBUG);
     578
    477579        $res = $this->query($query);
    478580
  • OpenPNE/trunk/lib/include/Auth/Container/MDB2.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Lorenzo Alberton <l.alberton@quipo.it> 
     17 * @author     Lorenzo Alberton <l.alberton@quipo.it>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: MDB2.php,v 1.10 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: MDB2.php,v 1.22 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.3.0
     
    4545 * @copyright  2001-2006 The PHP Group
    4646 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    47  * @version    Release: 1.3.0  File: $Revision: 1.10 $
     47 * @version    Release: 1.5.4  File: $Revision: 1.22 $
    4848 * @link       http://pear.php.net/package/Auth
    4949 * @since      Class available since Release 1.3.0
     
    110110    function _connect($dsn)
    111111    {
     112        $this->log('Auth_Container_MDB2::_connect() called.', AUTH_LOG_DEBUG);
    112113        if (is_string($dsn) || is_array($dsn)) {
    113114            $this->db =& MDB2::connect($dsn, $this->options['db_options']);
     
    129130            return PEAR::raiseError($this->db->getMessage(), $this->db->code);
    130131        }
     132
     133        if ($this->options['auto_quote']) {
     134            $this->options['final_table'] = $this->db->quoteIdentifier($this->options['table'], true);
     135            $this->options['final_usernamecol'] = $this->db->quoteIdentifier($this->options['usernamecol'], true);
     136            $this->options['final_passwordcol'] = $this->db->quoteIdentifier($this->options['passwordcol'], true);
     137        } else {
     138            $this->options['final_table'] = $this->options['table'];
     139            $this->options['final_usernamecol'] = $this->options['usernamecol'];
     140            $this->options['final_passwordcol'] = $this->options['passwordcol'];
     141        }
     142
    131143        return true;
    132144    }
     
    169181    function query($query)
    170182    {
     183        $this->log('Auth_Container_MDB2::query() called.', AUTH_LOG_DEBUG);
    171184        $err = $this->_prepare();
    172185        if ($err !== true) {
     
    194207        $this->options['cryptType']   = 'md5';
    195208        $this->options['db_options']  = array();
     209        $this->options['db_where']    = '';
     210        $this->options['auto_quote']  = true;
    196211    }
    197212
     
    212227            }
    213228        }
    214 
    215         // Include additional fields if they exist
    216         if (!empty($this->options['db_fields'])) {
     229    }
     230
     231    // }}}
     232    // {{{ _quoteDBFields()
     233
     234    /**
     235     * Quote the db_fields option to avoid the possibility of SQL injection.
     236     *
     237     * @access private
     238     * @return string A properly quoted string that can be concatenated into a
     239     * SELECT clause.
     240     */
     241    function _quoteDBFields()
     242    {
     243        if (isset($this->options['db_fields'])) {
    217244            if (is_array($this->options['db_fields'])) {
    218                 $this->options['db_fields'] = join($this->options['db_fields'], ', ');
    219             }
    220             $this->options['db_fields'] = ', ' . $this->options['db_fields'];
    221         }
     245                if ($this->options['auto_quote']) {
     246                    $fields = array();
     247                    foreach ($this->options['db_fields'] as $field) {
     248                        $fields[] = $this->db->quoteIdentifier($field, true);
     249                    }
     250                    return implode(', ', $fields);
     251                } else {
     252                    return implode(', ', $this->options['db_fields']);
     253                }
     254            } else {
     255                if (strlen($this->options['db_fields']) > 0) {
     256                    if ($this->options['auto_quote']) {
     257                        return $this->db->quoteIdentifier($this->options['db_fields'], true);
     258                    } else {
     259                        return $this->options['db_fields'];
     260                    }
     261                }
     262            }
     263        }
     264
     265        return '';
    222266    }
    223267
     
    243287    function fetchData($username, $password, $isChallengeResponse=false)
    244288    {
     289        $this->log('Auth_Container_MDB2::fetchData() called.', AUTH_LOG_DEBUG);
    245290        // Prepare for a database query
    246291        $err = $this->_prepare();
     
    250295
    251296        //Check if db_fields contains a *, if so assume all columns are selected
    252         if (strstr($this->options['db_fields'], '*')) {
     297        if (is_string($this->options['db_fields'])
     298            && strstr($this->options['db_fields'], '*')) {
    253299            $sql_from = '*';
    254300        } else {
    255             $sql_from = $this->options['usernamecol'] . ', '. $this->options['passwordcol'] . $this->options['db_fields'];
     301            $sql_from = $this->options['final_usernamecol'].
     302                ", ".$this->options['final_passwordcol'];
     303
     304            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     305                $sql_from .= ', '.$fields;
     306            }
    256307        }
    257308        $query = sprintf("SELECT %s FROM %s WHERE %s = %s",
    258309                         $sql_from,
    259                          $this->options['table'],
    260                          $this->options['usernamecol'],
     310                         $this->options['final_table'],
     311                         $this->options['final_usernamecol'],
    261312                         $this->db->quote($username, 'text')
    262313                         );
     314
     315        // check if there is an optional parameter db_where
     316        if ($this->options['db_where'] != '') {
     317            // there is one, so add it to the query
     318            $query .= " AND ".$this->options['db_where'];
     319        }
     320
     321        $this->log('Running SQL against MDB2: '.$query, AUTH_LOG_DEBUG);
    263322
    264323        $res = $this->db->queryRow($query, null, MDB2_FETCHMODE_ASSOC);
     
    292351                    continue;
    293352                }
     353
     354                $this->log('Storing additional field: '.$key, AUTH_LOG_DEBUG);
     355
    294356                // Use reference to the auth object if exists
    295357                // This is because the auth session variable can change so a static call to setAuthData does not make sense
     
    314376    function listUsers()
    315377    {
     378        $this->log('Auth_Container_MDB2::listUsers() called.', AUTH_LOG_DEBUG);
    316379        $err = $this->_prepare();
    317380        if ($err !== true) {
     
    322385
    323386        //Check if db_fields contains a *, if so assume all columns are selected
    324         if (strstr($this->options['db_fields'], '*')) {
     387        if (   is_string($this->options['db_fields'])
     388            && strstr($this->options['db_fields'], '*')) {
    325389            $sql_from = '*';
    326390        } else {
    327             $sql_from = $this->options['db_fields'];
     391            $sql_from = $this->options['final_usernamecol'].
     392                ", ".$this->options['final_passwordcol'];
     393
     394            if (strlen($fields = $this->_quoteDBFields()) > 0) {
     395                $sql_from .= ', '.$fields;
     396            }
    328397        }
    329398
    330399        $query = sprintf('SELECT %s FROM %s',
    331400                         $sql_from,
    332                          $this->options['table']
     401                         $this->options['final_table']
    333402                         );
     403
     404        // check if there is an optional parameter db_where
     405        if ($this->options['db_where'] != '') {
     406            // there is one, so add it to the query
     407            $query .= " WHERE ".$this->options['db_where'];
     408        }
     409
     410        $this->log('Running SQL against MDB2: '.$query, AUTH_LOG_DEBUG);
    334411
    335412        $res = $this->db->queryAll($query, null, MDB2_FETCHMODE_ASSOC);
     
    342419            }
    343420        }
     421        $this->log('Found '.count($retVal).' users.', AUTH_LOG_DEBUG);
    344422        return $retVal;
    345423    }
     
    360438    function addUser($username, $password, $additional = "")
    361439    {
     440        $this->log('Auth_Container_MDB2::addUser() called.', AUTH_LOG_DEBUG);
    362441
    363442        // Prepare for a database query
     
    382461        if (is_array($additional)) {
    383462            foreach ($additional as $key => $value) {
    384                 $additional_key   .= ', ' . $key;
     463                if ($this->options['auto_quote']) {
     464                    $additional_key   .= ', ' . $this->db->quoteIdentifier($key, true);
     465                } else {
     466                    $additional_key   .= ', ' . $key;
     467                }
    385468                $additional_value .= ', ' . $this->db->quote($value, 'text');
    386469            }
     
    388471
    389472        $query = sprintf("INSERT INTO %s (%s, %s%s) VALUES (%s, %s%s)",
    390                          $this->options['table'],
    391                          $this->options['usernamecol'],
    392                          $this->options['passwordcol'],
     473                         $this->options['final_table'],
     474                         $this->options['final_usernamecol'],
     475                         $this->options['final_passwordcol'],
    393476                         $additional_key,
    394477                         $this->db->quote($username, 'text'),
     
    397480                         );
    398481
     482        $this->log('Running SQL against MDB2: '.$query, AUTH_LOG_DEBUG);
     483
    399484        $res = $this->query($query);
    400485
     
    418503    function removeUser($username)
    419504    {
     505        $this->log('Auth_Container_MDB2::removeUser() called.', AUTH_LOG_DEBUG);
    420506        // Prepare for a database query
    421507        $err = $this->_prepare();
     
    425511
    426512        $query = sprintf("DELETE FROM %s WHERE %s = %s",
    427                          $this->options['table'],
    428                          $this->options['usernamecol'],
     513                         $this->options['final_table'],
     514                         $this->options['final_usernamecol'],
    429515                         $this->db->quote($username, 'text')
    430516                         );
    431517
     518        // check if there is an optional parameter db_where
     519        if ($this->options['db_where'] != '') {
     520            // there is one, so add it to the query
     521            $query .= " AND ".$this->options['db_where'];
     522        }
     523
     524        $this->log('Running SQL against MDB2: '.$query, AUTH_LOG_DEBUG);
     525
    432526        $res = $this->query($query);
    433527
     
    449543    function changePassword($username, $password)
    450544    {
     545        $this->log('Auth_Container_MDB2::changePassword() called.', AUTH_LOG_DEBUG);
    451546        // Prepare for a database query
    452547        $err = $this->_prepare();
     
    466561
    467562        $query = sprintf("UPDATE %s SET %s = %s WHERE %s = %s",
    468                          $this->options['table'],
    469                          $this->options['passwordcol'],
     563                         $this->options['final_table'],
     564                         $this->options['final_passwordcol'],
    470565                         $this->db->quote($password, 'text'),
    471                          $this->options['usernamecol'],
     566                         $this->options['final_usernamecol'],
    472567                         $this->db->quote($username, 'text')
    473568                         );
    474569
     570        // check if there is an optional parameter db_where
     571        if ($this->options['db_where'] != '') {
     572            // there is one, so add it to the query
     573            $query .= " AND ".$this->options['db_where'];
     574        }
     575
     576        $this->log('Running SQL against MDB2: '.$query, AUTH_LOG_DEBUG);
     577
    475578        $res = $this->query($query);
    476579
  • OpenPNE/trunk/lib/include/Auth/Container/PEAR.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: PEAR.php,v 1.7 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: PEAR.php,v 1.12 2007/07/02 05:09:43 aharvey Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.3.0
     
    2525
    2626/**
     27 * Include PEAR HTTP_Client.
     28 */
     29require_once 'HTTP/Client.php';
     30/**
    2731 * Include Auth_Container base class
    2832 */
    2933require_once 'Auth/Container.php';
    30 /**
    31  * Include PEAR XML_RPC
    32  */
    33 require_once 'XML/RPC.php';
    3434
    3535/**
     
    4343 * @author     Yavor Shahpasov <yavo@netsmart.com.cy>
    4444 * @author     Adam Ashley <aashley@php.net>
    45  * @copyright  2001-2006 The PHP Group
     45 * @author     Adam Harvey <aharvey@php.net>
     46 * @copyright  2001-2007 The PHP Group
    4647 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    47  * @version    Release: 1.3.0  File: $Revision: 1.7 $
     48 * @version    Release: 1.5.4  File: $Revision: 1.12 $
    4849 * @link       http://pear.php.net/package/Auth
    4950 * @since      Class available since Release 1.3.0
     
    5859     *
    5960     * Currently does nothing
    60      * 
     61     *
    6162     * @return void
    6263     */
    6364    function Auth_Container_Pear()
    6465    {
    65    
     66
    6667    }
    6768
    6869    // }}}
    6970    // {{{ fetchData()
    70    
     71
    7172    /**
    7273     * Get user information from pear.php.net
     
    8182    function fetchData($username, $password)
    8283    {
    83         $rpc = new XML_RPC_Client('/xmlrpc.php', 'pear.php.net');
    84         $rpc_message = new XML_RPC_Message("user.info", array(new XML_RPC_Value($username, "string")) );
    85        
    86         // Error Checking howto ???
    87         $result = $rpc->send($rpc_message);
    88         $value = $result->value();
    89         $userinfo = xml_rpc_decode($value);
    90         if ($userinfo['password'] == md5($password)) {
    91             $this->activeUser = $userinfo['handle'];
    92             foreach ($userinfo as $uk=>$uv) {
    93                 $this->_auth_obj->setAuthData($uk, $uv);
    94             }
    95             return true;
     84        $this->log('Auth_Container_PEAR::fetchData() called.', AUTH_LOG_DEBUG);
     85
     86        $client = new HTTP_Client;
     87
     88        $this->log('Auth_Container_PEAR::fetchData() getting salt.', AUTH_LOG_DEBUG);
     89        $code = $client->get('https://pear.php.net/rest-login.php/getsalt');
     90        if ($code != 200) {
     91            return PEAR::raiseError('Bad response to salt request.', $code);
    9692        }
    97         return false;
     93        $resp = $client->currentResponse();
     94        $salt = $resp['body'];
     95
     96        $this->log('Auth_Container_PEAR::fetchData() calling validate.', AUTH_LOG_DEBUG);
     97        $code = $client->post('https://pear.php.net/rest-login.php/validate',
     98                              array('username' => $username,
     99                                    'password' => md5($salt.md5($password))));
     100        if ($code != 200) {
     101            return PEAR::raiseError('Bad response to validate request.', $code);
     102        }
     103        $resp = $client->currentResponse();
     104
     105        list($code, $message) = explode(' ', $resp['body'], 1);
     106        if ($code != 8) {
     107            return PEAR::raiseError($message, $code);
     108        }
     109        return true;
    98110    }
    99111
    100112    // }}}
    101    
     113
    102114}
    103115?>
  • OpenPNE/trunk/lib/include/Auth/Container/POP3.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Stefan Ekman <stekman@sedata.org> 
     17 * @author     Stefan Ekman <stekman@sedata.org>
    1818 * @author     Martin Jansen <mj@php.net>
    19  * @author     Mika Tuupola <tuupola@appelsiini.net> 
     19 * @author     Mika Tuupola <tuupola@appelsiini.net>
    2020 * @author     Adam Ashley <aashley@php.net>
    2121 * @copyright  2001-2006 The PHP Group
    2222 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    23  * @version    CVS: $Id: POP3.php,v 1.8 2006/03/02 06:53:08 aashley Exp $
     23 * @version    CVS: $Id: POP3.php,v 1.12 2007/06/12 03:11:26 aashley Exp $
    2424 * @link       http://pear.php.net/package/Auth
    2525 * @since      File available since Release 1.2.0
     
    4545 * @package    Auth
    4646 * @author     Martin Jansen <mj@php.net>
    47  * @author     Mika Tuupola <tuupola@appelsiini.net> 
     47 * @author     Mika Tuupola <tuupola@appelsiini.net>
    4848 * @author     Adam Ashley <aashley@php.net>
    4949 * @copyright  2001-2006 The PHP Group
    5050 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    51  * @version    Release: 1.3.0  File: $Revision: 1.8 $
     51 * @version    Release: 1.5.4  File: $Revision: 1.12 $
    5252 * @link       http://pear.php.net/package/Auth
    5353 * @since      Class available since Release 1.2.0
     
    7878     *                      - Attempt this authentication style first
    7979     *                        then fallback to autodetection.
    80      * @var mixed 
     80     * @var mixed
    8181     */
    8282    var $method=true;
     
    9393    function Auth_Container_POP3($server=null)
    9494    {
    95         if (isset($server)) {
     95        if (isset($server) && !is_null($server)) {
    9696            if (is_array($server)) {
    9797                if (isset($server['host'])) {
     
    128128    function fetchData($username, $password)
    129129    {
     130        $this->log('Auth_Container_POP3::fetchData() called.', AUTH_LOG_DEBUG);
    130131        $pop3 =& new Net_POP3();
    131132        $res = $pop3->connect($this->server, $this->port, $this->method);
    132133        if (!$res) {
     134            $this->log('Connection to POP3 server failed.', AUTH_LOG_DEBUG);
    133135            return $res;
    134136        }
  • OpenPNE/trunk/lib/include/Auth/Container/RADIUS.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Michael Bretterklieber <michael@bretterklieber.com> 
     17 * @author     Michael Bretterklieber <michael@bretterklieber.com>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: RADIUS.php,v 1.11 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: RADIUS.php,v 1.16 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.2.0
     
    4242 * @copyright  2001-2006 The PHP Group
    4343 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    44  * @version    Release: 1.3.0  File: $Revision: 1.11 $
     44 * @version    Release: 1.5.4  File: $Revision: 1.16 $
    4545 * @link       http://pear.php.net/package/Auth
    4646 * @since      Class available since Release 1.2.0
     
    5656     */
    5757    var $radius;
    58    
     58
    5959    /**
    6060     * Contains the authentication type
    6161     * @var string
    6262     */
    63     var $authtype;   
     63    var $authtype;
    6464
    6565    // }}}
     
    8787        $classname = 'Auth_RADIUS_' . $this->authtype;
    8888        if (!class_exists($classname)) {
    89             PEAR::raiseError("Unknown Authtype, please use on of: "
     89            PEAR::raiseError("Unknown Authtype, please use one of: "
    9090                    ."PAP, CHAP_MD5, MSCHAPv1, MSCHAPv2!", 41, PEAR_ERROR_DIE);
    9191        }
    92        
     92
    9393        $this->radius = new $classname;
    9494
     
    108108            }
    109109        }
    110        
     110
    111111        if (!$this->radius->start()) {
    112112            PEAR::raiseError($this->radius->getError(), 41, PEAR_ERROR_DIE);
     
    126126    function fetchData($username, $password, $challenge = null)
    127127    {
     128        $this->log('Auth_Container_RADIUS::fetchData() called.', AUTH_LOG_DEBUG);
     129
    128130        switch($this->authtype) {
    129         case 'CHAP_MD5':
    130         case 'MSCHAPv1':
    131             if (isset($challenge)) {
    132                 echo $password;
    133                 $this->radius->challenge = $challenge;
    134                 $this->radius->chapid    = 1;
    135                 $this->radius->response  = pack('H*', $password);
    136             } else {
     131            case 'CHAP_MD5':
     132            case 'MSCHAPv1':
     133                if (isset($challenge)) {
     134                    $this->radius->challenge = $challenge;
     135                    $this->radius->chapid    = 1;
     136                    $this->radius->response  = pack('H*', $password);
     137                } else {
     138                    require_once 'Crypt/CHAP.php';
     139                    $classname = 'Crypt_' . $this->authtype;
     140                    $crpt = new $classname;
     141                    $crpt->password = $password;
     142                    $this->radius->challenge = $crpt->challenge;
     143                    $this->radius->chapid    = $crpt->chapid;
     144                    $this->radius->response  = $crpt->challengeResponse();
     145                }
     146                break;
     147
     148            case 'MSCHAPv2':
    137149                require_once 'Crypt/CHAP.php';
    138                 $classname = 'Crypt_' . $this->authtype;
    139                 $crpt = new $classname;
     150                $crpt = new Crypt_MSCHAPv2;
     151                $crpt->username = $username;
    140152                $crpt->password = $password;
    141                 $this->radius->challenge = $crpt->challenge;
    142                 $this->radius->chapid    = $crpt->chapid;
    143                 $this->radius->response  = $crpt->challengeResponse();
     153                $this->radius->challenge     = $crpt->authChallenge;
     154                $this->radius->peerChallenge = $crpt->peerChallenge;
     155                $this->radius->chapid        = $crpt->chapid;
     156                $this->radius->response      = $crpt->challengeResponse();
    144157                break;
    145             }
    146158
    147         case 'MSCHAPv2':
    148             require_once 'Crypt/CHAP.php';
    149             $crpt = new Crypt_MSCHAPv2;
    150             $crpt->username = $username;
    151             $crpt->password = $password;
    152             $this->radius->challenge     = $crpt->authChallenge;
    153             $this->radius->peerChallenge = $crpt->peerChallenge;
    154             $this->radius->chapid        = $crpt->chapid;
    155             $this->radius->response      = $crpt->challengeResponse();
    156             break;
    157 
    158         default:
    159             $this->radius->password = $password;
    160             break;
     159            default:
     160                $this->radius->password = $password;
     161                break;
    161162        }
    162163
  • OpenPNE/trunk/lib/include/Auth/Container/SMBPasswd.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Michael Bretterklieber <michael@bretterklieber.com> 
     17 * @author     Michael Bretterklieber <michael@bretterklieber.com>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: SMBPasswd.php,v 1.5 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: SMBPasswd.php,v 1.8 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.2.3
     
    5757 * @copyright  2001-2006 The PHP Group
    5858 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    59  * @version    Release: 1.3.0  File: $Revision: 1.5 $
     59 * @version    Release: 1.5.4  File: $Revision: 1.8 $
    6060 * @link       http://pear.php.net/package/Auth
    6161 * @since      Class available since Release 1.2.3
     
    105105    function fetchData($username, $password)
    106106    {
     107        $this->log('Auth_Container_SMBPasswd::fetchData() called.', AUTH_LOG_DEBUG);
    107108        return $this->pwfile->verifyAccount($username, $password);
    108109    }
     
    110111    // }}}
    111112    // {{{ listUsers()
    112    
     113
    113114    function listUsers()
    114115    {
     116        $this->log('Auth_Container_SMBPasswd::fetchData() called.', AUTH_LOG_DEBUG);
    115117        return $this->pwfile->getAccounts();
    116118    }
     
    130132    function addUser($username, $password, $additional = '')
    131133    {
     134        $this->log('Auth_Container_SMBPasswd::addUser() called.', AUTH_LOG_DEBUG);
    132135        $res = $this->pwfile->addUser($user, $additional['userid'], $pass);
    133136        if ($res === true) {
     
    147150    function removeUser($username)
    148151    {
     152        $this->log('Auth_Container_SMBPasswd::removeUser() called.', AUTH_LOG_DEBUG);
    149153        $res = $this->pwfile->delUser($username);
    150154        if ($res === true) {
     
    161165     *
    162166     * @param string Username
    163      * @param string The new password 
     167     * @param string The new password
    164168     */
    165169    function changePassword($username, $password)
    166170    {
    167          $res = $this->pwfile->modUser($username, '', $password);
    168          if ($res === true) {
    169              return $this->pwfile->save();
    170          }
    171          return $res;
     171        $this->log('Auth_Container_SMBPasswd::changePassword() called.', AUTH_LOG_DEBUG);
     172        $res = $this->pwfile->modUser($username, '', $password);
     173        if ($res === true) {
     174            return $this->pwfile->save();
     175        }
     176        return $res;
    172177    }
    173178
  • OpenPNE/trunk/lib/include/Auth/Container/SOAP.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Bruno Pedro <bpedro@co.sapo.pt> 
     17 * @author     Bruno Pedro <bpedro@co.sapo.pt>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: SOAP.php,v 1.10 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: SOAP.php,v 1.13 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.2.0
     
    8484 * @copyright  2001-2006 The PHP Group
    8585 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    86  * @version    Release: 1.3.0  File: $Revision: 1.10 $
     86 * @version    Release: 1.5.4  File: $Revision: 1.13 $
    8787 * @link       http://pear.php.net/package/Auth
    8888 * @since      Class available since Release 1.2.0
     
    171171    function fetchData($username, $password)
    172172    {
     173        $this->log('Auth_Container_SOAP::fetchData() called.', AUTH_LOG_DEBUG);
    173174        // check if all required options are set
    174175        if (array_intersect($this->_requiredOptions, array_keys($this->_options)) != $this->_requiredOptions) {
  • OpenPNE/trunk/lib/include/Auth/Container/vpopmail.php

    r2 r4883  
    1515 * @category   Authentication
    1616 * @package    Auth
    17  * @author     Stanislav Grozev <tacho@orbitel.bg> 
     17 * @author     Stanislav Grozev <tacho@orbitel.bg>
    1818 * @author     Adam Ashley <aashley@php.net>
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: vpopmail.php,v 1.7 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: vpopmail.php,v 1.10 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.2.0
     
    4242 * @copyright  2001-2006 The PHP Group
    4343 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    44  * @version    Release: 1.3.0  File: $Revision: 1.7 $
     44 * @version    Release: 1.5.4  File: $Revision: 1.10 $
    4545 * @link       http://pear.php.net/package/Auth
    4646 * @since      Class available since Release 1.2.0
     
    7575    function fetchData($username, $password)
    7676    {
     77        $this->log('Auth_Container_vpopmail::fetchData() called.', AUTH_LOG_DEBUG);
    7778        $userdata = array();
    7879        $userdata = preg_split("/@/", $username, 2);
  • OpenPNE/trunk/lib/include/Auth/Controller.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: Controller.php,v 1.10 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: Controller.php,v 1.11 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.3.0
     
    2525
    2626/**
    27  * Controlls access to a group of php access 
    28  * and redirects to a predefined login page as 
     27 * Controlls access to a group of php access
     28 * and redirects to a predefined login page as
    2929 * needed
    3030 *
     
    4747 * if( $authController->isAuthorised() ){
    4848 *   $authController->redirectBack();
    49  * } 
     49 * }
    5050 * </code>
    5151 *
     
    5555 * @copyright  2001-2006 The PHP Group
    5656 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    57  * @version    Release: 1.3.0  File: $Revision: 1.10 $
     57 * @version    Release: 1.5.4  File: $Revision: 1.11 $
    5858 * @link       http://pear.php.net/package/Auth
    5959 * @since      Class available since Release 1.3.0
     
    6464    // {{{ properties
    6565
    66     /** 
     66    /**
    6767     * The Auth instance this controller is managing
    6868     *
     
    7070     */
    7171    var $auth = null;
    72    
     72
    7373    /**
    7474     * The login URL
     
    7676     * */
    7777    var $login = null;
    78    
     78
    7979    /**
    8080     * The default index page to use when the caller page is not set
    8181     *
    82      * @var string 
     82     * @var string
    8383     */
    8484    var $default = null;
    85    
    86     /** 
    87      * If this is set to true after a succesfull login the 
    88      * Auth_Controller::redirectBack() is invoked automatically 
     85
     86    /**
     87     * If this is set to true after a succesfull login the
     88     * Auth_Controller::redirectBack() is invoked automatically
    8989     *
    9090     * @var boolean
     
    9494    // }}}
    9595    // {{{ Auth_Controller() [constructor]
    96    
     96
    9797    /**
    9898     * Constructor
     
    122122    // }}}
    123123    // {{{ setAutoRedirectBack()
    124    
    125     /** 
     124
     125    /**
    126126     * Enables auto redirection when login is done
    127      * 
     127     *
    128128     * @param bool Sets the autoRedirectBack flag to this
    129129     * @see Auth_Controller::autoRedirectBack
     
    137137    // }}}
    138138    // {{{ redirectBack()
    139    
     139
    140140    /**
    141141     * Redirects Back to the calling page
     
    147147        // If redirectback go there
    148148        // else go to the default page
    149        
     149
    150150        $returnUrl = $this->auth->getAuthData('returnUrl');
    151151        if(!$returnUrl) {
    152152            $returnUrl = $this->_defaultPage;
    153153        }
    154        
     154
    155155        // Add some entropy to the return to make it unique
    156156        // avoind problems with cached pages and proxies
     
    163163        if($this->auth->status != '') {
    164164            $url .= '&authstatus='.$this->auth->status;
    165         }       
     165        }
    166166        header('Location:'.$returnUrl);
    167167        print("You could not be redirected to <a href=\"$returnUrl\">$returnUrl</a>");
     
    170170    // }}}
    171171    // {{{ redirectLogin()
    172    
     172
    173173    /**
    174174      * Redirects to the login Page if not authorised
    175       * 
     175      *
    176176      * put return page on the query or in auth
    177177      *
     
    181181    {
    182182        // Go to the login Page
    183        
     183
    184184        // For Auth, put some check to avoid infinite redirects, this should at least exclude
    185185        // the login page
    186        
     186
    187187        $url = $this->_loginPage;
    188188        if(strpos($url, '?') === false) {
     
    205205    // }}}
    206206    // {{{ start()
    207    
     207
    208208    /**
    209209      * Starts the Auth Procedure
     
    227227            // Logged on and on login page
    228228            if(strstr($_SERVER['PHP_SELF'], $this->_loginPage) && $this->auth->checkAuth()){
    229                 $this->autoRedirectBack ? 
     229                $this->autoRedirectBack ?
    230230                    $this->redirectBack() :
    231231                    null ;
    232232            }
    233233        }
    234        
    235        
     234
     235
    236236    }
    237237
    238238    // }}}
    239239    // {{{ isAuthorised()
    240  
     240
    241241    /**
    242242      * Checks is the user is logged on
  • OpenPNE/trunk/lib/include/Auth/Frontend/Html.php

    r2 r4883  
    1919 * @copyright  2001-2006 The PHP Group
    2020 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    21  * @version    CVS: $Id: Html.php,v 1.9 2006/03/02 06:53:08 aashley Exp $
     21 * @version    CVS: $Id: Html.php,v 1.11 2007/06/12 03:11:26 aashley Exp $
    2222 * @link       http://pear.php.net/package/Auth
    2323 * @since      File available since Release 1.3.0
     
    2626/**
    2727 * Standard Html Login form
    28  * 
     28 *
    2929 * @category   Authentication
    3030 * @package    Auth
     
    3333 * @copyright  2001-2006 The PHP Group
    3434 * @license    http://www.php.net/license/3_01.txt  PHP License 3.01
    35  * @version    Release: 1.3.0  File: $Revision: 1.9 $
     35 * @version    Release: 1.5.4  File: $Revision: 1.11 $
    3636 * @link       http://pear.php.net/package/Auth
    3737 * @since      Class available since Release 1.3.0
    3838 */
    3939class Auth_Frontend_Html {
    40    
     40
    4141    // {{{ render()
    4242
     
    5050    function render(&$caller, $username = '') {
    5151        $loginOnClick = 'return true;';
    52        
     52
    5353        // Try To Use Challene response
    5454        // TODO javascript might need some improvement for work on other browsers
     
    6969            //print '   alert(pass);alert(secret); '."\n";
    7070
    71             // If using md5 for password storage md5 the password before 
     71            // If using md5 for password storage md5 the password before
    7272            // we hash it with the secret
    7373            // print '   alert(pass.value);';
     
    102102            $status = '<i>Security problem detected. </i>'."\n";
    103103        }
    104        
     104
    105105        print '<form method="post" action="'.$caller->server['PHP_SELF'].'" '
    106106            .'onSubmit="'.$loginOnClick.'">'."\n";
     
    114114        print '    <td>Username:</td>'."\n";
    115115        print '    <td><input type="text" id="'.$caller->getPostUsernameField()
    116             .'" name="'.$caller->getPostUsernameField().'" value="' . $username 
     116            .'" name="'.$caller->getPostUsernameField().'" value="' . $username
    117117            .'" /></td>'."\n";
    118118        print '</tr>'."\n";
     
    123123        print '</tr>'."\n";
    124124        print '<tr>'."\n";
    125        
     125
    126126        //onClick=" '.$loginOnClick.' "
    127127        print '    <td colspan="2" bgcolor="#eeeeee"><input value="Login" '
     
    130130        print '</table>'."\n";
    131131
    132         // Might be a good idea to make the variable name variable 
     132        // Might be a good idea to make the variable name variable
    133133        print '<input type="hidden" id="authsecret" name="authsecret" value="" />';
    134134        print '</form>'."\n";
     135        print '</center>'."\n";
    135136    }
    136137
    137138    // }}}
    138    
     139
    139140}
    140141
  • OpenPNE/trunk/webapp/lib/OpenPNE/Auth.php

    r4035 r4883  
    5656    function &factory($login = false)
    5757    {
     58        @session_start();
    5859        if ($login) {
    5960            $auth = new Auth($this->storage, $this->options, '', false);
Note: See TracChangeset for help on using the changeset viewer.