[Summary view] [Print] [Text view]

   1  <?php
   2      /**

   3       *    Base include file for SimpleTest

   4       *    @package    SimpleTest

   5       *    @subpackage    WebTester

   6       *    @version    $Id: authentication.php 5999 2007-06-18 13:13:08Z pachanga $

   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  ?>