Source for file authentication.php

Documentation is available at authentication.php

  1. <?php
  2. /**
  3.  *  Base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage WebTester
  6.  *  @version    $Id: authentication.php 1720 2008-04-07 02:32:43Z lastcraft $
  7.  */
  8. /**
  9.  *  include http class
  10.  */
  11. require_once(dirname(__FILE__) . '/http.php');
  12.  
  13. /**
  14.  *    Represents a single security realm's identity.
  15.  *    @package SimpleTest
  16.  *    @subpackage WebTester
  17.  */
  18. class SimpleRealm {
  19.     var $_type;
  20.     var $_root;
  21.     var $_username;
  22.     var $_password;
  23.     
  24.     /**
  25.      *    Starts with the initial entry directory.
  26.      *    @param string $type      Authentication type for this
  27.      *                              realm. Only Basic authentication
  28.      *                              is currently supported.
  29.      *    @param SimpleUrl $url    Somewhere in realm.
  30.      *    @access public
  31.      */
  32.     function SimpleRealm($type, $url) {
  33.         $this->_type = $type;
  34.         $this->_root = $url->getBasePath();
  35.         $this->_username = false;
  36.         $this->_password = false;
  37.     }
  38.     
  39.     /**
  40.      *    Adds another location to the realm.
  41.      *    @param SimpleUrl $url    Somewhere in realm.
  42.      *    @access public
  43.      */
  44.     function stretch($url) {
  45.         $this->_root = $this->_getCommonPath($this->_root, $url->getPath());
  46.     }
  47.     
  48.     /**
  49.      *    Finds the common starting path.
  50.      *    @param string $first        Path to compare.
  51.      *    @param string $second       Path to compare.
  52.      *    @return string              Common directories.
  53.      *    @access private
  54.      */
  55.     function _getCommonPath($first, $second) {
  56.         $first = explode('/', $first);
  57.         $second = explode('/', $second);
  58.         for ($i = 0; $i < min(count($first), count($second)); $i++) {
  59.             if ($first[$i] != $second[$i]) {
  60.                 return implode('/', array_slice($first, 0, $i)) . '/';
  61.             }
  62.         }
  63.         return implode('/', $first) . '/';
  64.     }
  65.     
  66.     /**
  67.      *    Sets the identity to try within this realm.
  68.      *    @param string $username    Username in authentication dialog.
  69.      *    @param string $username    Password in authentication dialog.
  70.      *    @access public
  71.      */
  72.     function setIdentity($username, $password) {
  73.         $this->_username = $username;
  74.         $this->_password = $password;
  75.     }
  76.     
  77.     /**
  78.      *    Accessor for current identity.
  79.      *    @return string        Last succesful username.
  80.      *    @access public
  81.      */
  82.     function getUsername() {
  83.         return $this->_username;
  84.     }
  85.     
  86.     /**
  87.      *    Accessor for current identity.
  88.      *    @return string        Last succesful password.
  89.      *    @access public
  90.      */
  91.     function getPassword() {
  92.         return $this->_password;
  93.     }
  94.     
  95.     /**
  96.      *    Test to see if the URL is within the directory
  97.      *    tree of the realm.
  98.      *    @param SimpleUrl $url    URL to test.
  99.      *    @return boolean          True if subpath.
  100.      *    @access public
  101.      */
  102.     function isWithin($url) {
  103.         if ($this->_isIn($this->_root, $url->getBasePath())) {
  104.             return true;
  105.         }
  106.         if ($this->_isIn($this->_root, $url->getBasePath() . $url->getPage() . '/')) {
  107.             return true;
  108.         }
  109.         return false;
  110.     }
  111.     
  112.     /**
  113.      *    Tests to see if one string is a substring of
  114.      *    another.
  115.      *    @param string $part        Small bit.
  116.      *    @param string $whole       Big bit.
  117.      *    @return boolean            True if the small bit is
  118.      *                                in the big bit.
  119.      *    @access private
  120.      */
  121.     function _isIn($part, $whole) {
  122.         return strpos($whole, $part) === 0;
  123.     }
  124. }
  125.  
  126. /**
  127.  *    Manages security realms.
  128.  *    @package SimpleTest
  129.  *    @subpackage WebTester
  130.  */
  131. class SimpleAuthenticator {
  132.     var $_realms;
  133.     
  134.     /**
  135.      *    Clears the realms.
  136.      *    @access public
  137.      */
  138.     function SimpleAuthenticator() {
  139.         $this->restartSession();
  140.     }
  141.     
  142.     /**
  143.      *    Starts with no realms set up.
  144.      *    @access public
  145.      */
  146.     function restartSession() {
  147.         $this->_realms = array();
  148.     }
  149.     
  150.     /**
  151.      *    Adds a new realm centered the current URL.
  152.      *    Browsers vary wildly on their behaviour in this
  153.      *    regard. Mozilla ignores the realm and presents
  154.      *    only when challenged, wasting bandwidth. IE
  155.      *    just carries on presenting until a new challenge
  156.      *    occours. SimpleTest tries to follow the spirit of
  157.      *    the original standards committee and treats the
  158.      *    base URL as the root of a file tree shaped realm.
  159.      *    @param SimpleUrl $url    Base of realm.
  160.      *    @param string $type      Authentication type for this
  161.      *                              realm. Only Basic authentication
  162.      *                              is currently supported.
  163.      *    @param string $realm     Name of realm.
  164.      *    @access public
  165.      */
  166.     function addRealm($url, $type, $realm) {
  167.         $this->_realms[$url->getHost()][$realm] = new SimpleRealm($type, $url);
  168.     }
  169.     
  170.     /**
  171.      *    Sets the current identity to be presented
  172.      *    against that realm.
  173.      *    @param string $host        Server hosting realm.
  174.      *    @param string $realm       Name of realm.
  175.      *    @param string $username    Username for realm.
  176.      *    @param string $password    Password for realm.
  177.      *    @access public
  178.      */
  179.     function setIdentityForRealm($host, $realm, $username, $password) {
  180.         if (isset($this->_realms[$host][$realm])) {
  181.             $this->_realms[$host][$realm]->setIdentity($username, $password);
  182.         }
  183.     }
  184.     
  185.     /**
  186.      *    Finds the name of the realm by comparing URLs.
  187.      *    @param SimpleUrl $url        URL to test.
  188.      *    @return SimpleRealm          Name of realm.
  189.      *    @access private
  190.      */
  191.     function _findRealmFromUrl($url) {
  192.         if (! isset($this->_realms[$url->getHost()])) {
  193.             return false;
  194.         }
  195.         foreach ($this->_realms[$url->getHost()] as $name => $realm) {
  196.             if ($realm->isWithin($url)) {
  197.                 return $realm;
  198.             }
  199.         }
  200.         return false;
  201.     }
  202.     
  203.     /**
  204.      *    Presents the appropriate headers for this location.
  205.      *    @param SimpleHttpRequest $request  Request to modify.
  206.      *    @param SimpleUrl $url              Base of realm.
  207.      *    @access public
  208.      */
  209.     function addHeaders(&$request, $url) {
  210.         if ($url->getUsername() && $url->getPassword()) {
  211.             $username = $url->getUsername();
  212.             $password = $url->getPassword();
  213.         } elseif ($realm = $this->_findRealmFromUrl($url)) {
  214.             $username = $realm->getUsername();
  215.             $password = $realm->getPassword();
  216.         } else {
  217.             return;
  218.         }
  219.         $this->addBasicHeaders($request, $username, $password);
  220.     }
  221.     
  222.     /**
  223.      *    Presents the appropriate headers for this
  224.      *    location for basic authentication.
  225.      *    @param SimpleHttpRequest $request  Request to modify.
  226.      *    @param string $username            Username for realm.
  227.      *    @param string $password            Password for realm.
  228.      *    @access public
  229.      *    @static
  230.      */
  231.     function addBasicHeaders(&$request, $username, $password) {
  232.         if ($username && $password) {
  233.             $request->addHeaderLine(
  234.                     'Authorization: Basic ' . base64_encode("$username:$password"));
  235.         }
  236.     }
  237. }
  238. ?>

Documentation generated on Sun, 04 May 2008 09:21:15 -0500 by phpDocumentor 1.3.0