git.roojs.org Git - web.mtrack/blob - Auth/OpenID/FileStore.php

   1 <?php
   2
   3 /**
   4  * This file supplies a Memcached store backend for OpenID servers and
   5  * consumers.
   6  *
   7  * PHP versions 4 and 5
   8  *
   9  * LICENSE: See the COPYING file included in this distribution.
  10  *
  11  * @package OpenID
  12  * @author JanRain, Inc. <openid@janrain.com>
  13  * @copyright 2005-2008 Janrain, Inc.
  14  * @license http://www.apache.org/licenses/LICENSE-2.0 Apache
  15  */
  16
  17 /**
  18  * Require base class for creating a new interface.
  19  */
  20 require_once 'Auth/OpenID.php';
  21 require_once 'Auth/OpenID/Interface.php';
  22 require_once 'Auth/OpenID/HMAC.php';
  23 require_once 'Auth/OpenID/Nonce.php';
  24
  25 /**
  26  * This is a filesystem-based store for OpenID associations and
  27  * nonces.  This store should be safe for use in concurrent systems on
  28  * both windows and unix (excluding NFS filesystems).  There are a
  29  * couple race conditions in the system, but those failure cases have
  30  * been set up in such a way that the worst-case behavior is someone
  31  * having to try to log in a second time.
  32  *
  33  * Most of the methods of this class are implementation details.
  34  * People wishing to just use this store need only pay attention to
  35  * the constructor.
  36  *
  37  * @package OpenID
  38  */
  39 class Auth_OpenID_FileStore extends Auth_OpenID_OpenIDStore {
  40
  41     /**
  42      * Initializes a new {@link Auth_OpenID_FileStore}.  This
  43      * initializes the nonce and association directories, which are
  44      * subdirectories of the directory passed in.
  45      *
  46      * @param string $directory This is the directory to put the store
  47      * directories in.
  48      */
  49     function Auth_OpenID_FileStore($directory)
  50     {
  51         if (!Auth_OpenID::ensureDir($directory)) {
  52             trigger_error('Not a directory and failed to create: '
  53                           . $directory, E_USER_ERROR);
  54         }
  55         $directory = realpath($directory);
  56
  57         $this->directory = $directory;
  58         $this->active = true;
  59
  60         $this->nonce_dir = $directory . DIRECTORY_SEPARATOR . 'nonces';
  61
  62         $this->association_dir = $directory . DIRECTORY_SEPARATOR .
  63             'associations';
  64
  65         // Temp dir must be on the same filesystem as the assciations
  66         // $directory.
  67         $this->temp_dir = $directory . DIRECTORY_SEPARATOR . 'temp';
  68
  69         $this->max_nonce_age = 6 * 60 * 60; // Six hours, in seconds
  70
  71         if (!$this->_setup()) {
  72             trigger_error('Failed to initialize OpenID file store in ' .
  73                           $directory, E_USER_ERROR);
  74         }
  75     }
  76
  77     function destroy()
  78     {
  79         Auth_OpenID_FileStore::_rmtree($this->directory);
  80         $this->active = false;
  81     }
  82
  83     /**
  84      * Make sure that the directories in which we store our data
  85      * exist.
  86      *
  87      * @access private
  88      */
  89     function _setup()
  90     {
  91         return (Auth_OpenID::ensureDir($this->nonce_dir) &&
  92                 Auth_OpenID::ensureDir($this->association_dir) &&
  93                 Auth_OpenID::ensureDir($this->temp_dir));
  94     }
  95
  96     /**
  97      * Create a temporary file on the same filesystem as
  98      * $this->association_dir.
  99      *
 100      * The temporary directory should not be cleaned if there are any
 101      * processes using the store. If there is no active process using
 102      * the store, it is safe to remove all of the files in the
 103      * temporary directory.
 104      *
 105      * @return array ($fd, $filename)
 106      * @access private
 107      */
 108     function _mktemp()
 109     {
 110         $name = Auth_OpenID_FileStore::_mkstemp($dir = $this->temp_dir);
 111         $file_obj = @fopen($name, 'wb');
 112         if ($file_obj !== false) {
 113             return array($file_obj, $name);
 114         } else {
 115             Auth_OpenID_FileStore::_removeIfPresent($name);
 116         }
 117     }
 118
 119     function cleanupNonces()
 120     {
 121         global $Auth_OpenID_SKEW;
 122
 123         $nonces = Auth_OpenID_FileStore::_listdir($this->nonce_dir);
 124         $now = time();
 125
 126         $removed = 0;
 127         // Check all nonces for expiry
 128         foreach ($nonces as $nonce_fname) {
 129             $base = basename($nonce_fname);
 130             $parts = explode('-', $base, 2);
 131             $timestamp = $parts[0];
 132             $timestamp = intval($timestamp, 16);
 133             if (abs($timestamp - $now) > $Auth_OpenID_SKEW) {
 134                 Auth_OpenID_FileStore::_removeIfPresent($nonce_fname);
 135                 $removed += 1;
 136             }
 137         }
 138         return $removed;
 139     }
 140
 141     /**
 142      * Create a unique filename for a given server url and
 143      * handle. This implementation does not assume anything about the
 144      * format of the handle. The filename that is returned will
 145      * contain the domain name from the server URL for ease of human
 146      * inspection of the data directory.
 147      *
 148      * @return string $filename
 149      */
 150     function getAssociationFilename($server_url, $handle)
 151     {
 152         if (!$this->active) {
 153             trigger_error("FileStore no longer active", E_USER_ERROR);
 154             return null;
 155         }
 156
 157         if (strpos($server_url, '://') === false) {
 158             trigger_error(sprintf("Bad server URL: %s", $server_url),
 159                           E_USER_WARNING);
 160             return null;
 161         }
 162
 163         list($proto, $rest) = explode('://', $server_url, 2);
 164         $parts = explode('/', $rest);
 165         $domain = Auth_OpenID_FileStore::_filenameEscape($parts[0]);
 166         $url_hash = Auth_OpenID_FileStore::_safe64($server_url);
 167         if ($handle) {
 168             $handle_hash = Auth_OpenID_FileStore::_safe64($handle);
 169         } else {
 170             $handle_hash = '';
 171         }
 172
 173         $filename = sprintf('%s-%s-%s-%s', $proto, $domain, $url_hash,
 174                             $handle_hash);
 175
 176         return $this->association_dir. DIRECTORY_SEPARATOR . $filename;
 177     }
 178
 179     /**
 180      * Store an association in the association directory.
 181      */
 182     function storeAssociation($server_url, $association)
 183     {
 184         if (!$this->active) {
 185             trigger_error("FileStore no longer active", E_USER_ERROR);
 186             return false;
 187         }
 188
 189         $association_s = $association->serialize();
 190         $filename = $this->getAssociationFilename($server_url,
 191                                                   $association->handle);
 192         list($tmp_file, $tmp) = $this->_mktemp();
 193
 194         if (!$tmp_file) {
 195             trigger_error("_mktemp didn't return a valid file descriptor",
 196                           E_USER_WARNING);
 197             return false;
 198         }
 199
 200         fwrite($tmp_file, $association_s);
 201
 202         fflush($tmp_file);
 203
 204         fclose($tmp_file);
 205
 206         if (@rename($tmp, $filename)) {
 207             return true;
 208         } else {
 209             // In case we are running on Windows, try unlinking the
 210             // file in case it exists.
 211             @unlink($filename);
 212
 213             // Now the target should not exist. Try renaming again,
 214             // giving up if it fails.
 215             if (@rename($tmp, $filename)) {
 216                 return true;
 217             }
 218         }
 219
 220         // If there was an error, don't leave the temporary file
 221         // around.
 222         Auth_OpenID_FileStore::_removeIfPresent($tmp);
 223         return false;
 224     }
 225
 226     /**
 227      * Retrieve an association. If no handle is specified, return the
 228      * association with the most recent issue time.
 229      *
 230      * @return mixed $association
 231      */
 232     function getAssociation($server_url, $handle = null)
 233     {
 234         if (!$this->active) {
 235             trigger_error("FileStore no longer active", E_USER_ERROR);
 236             return null;
 237         }
 238
 239         if ($handle === null) {
 240             $handle = '';
 241         }
 242
 243         // The filename with the empty handle is a prefix of all other
 244         // associations for the given server URL.
 245         $filename = $this->getAssociationFilename($server_url, $handle);
 246
 247         if ($handle) {
 248             return $this->_getAssociation($filename);
 249         } else {
 250             $association_files =
 251                 Auth_OpenID_FileStore::_listdir($this->association_dir);
 252             $matching_files = array();
 253
 254             // strip off the path to do the comparison
 255             $name = basename($filename);
 256             foreach ($association_files as $association_file) {
 257                 $base = basename($association_file);
 258                 if (strpos($base, $name) === 0) {
 259                     $matching_files[] = $association_file;
 260                 }
 261             }
 262
 263             $matching_associations = array();
 264             // read the matching files and sort by time issued
 265             foreach ($matching_files as $full_name) {
 266                 $association = $this->_getAssociation($full_name);
 267                 if ($association !== null) {
 268                     $matching_associations[] = array($association->issued,
 269                                                      $association);
 270                 }
 271             }
 272
 273             $issued = array();
 274             $assocs = array();
 275             foreach ($matching_associations as $key => $assoc) {
 276                 $issued[$key] = $assoc[0];
 277                 $assocs[$key] = $assoc[1];
 278             }
 279
 280             array_multisort($issued, SORT_DESC, $assocs, SORT_DESC,
 281                             $matching_associations);
 282
 283             // return the most recently issued one.
 284             if ($matching_associations) {
 285                 list($issued, $assoc) = $matching_associations[0];
 286                 return $assoc;
 287             } else {
 288                 return null;
 289             }
 290         }
 291     }
 292
 293     /**
 294      * @access private
 295      */
 296     function _getAssociation($filename)
 297     {
 298         if (!$this->active) {
 299             trigger_error("FileStore no longer active", E_USER_ERROR);
 300             return null;
 301         }
 302
 303         $assoc_file = @fopen($filename, 'rb');
 304
 305         if ($assoc_file === false) {
 306             return null;
 307         }
 308
 309         $assoc_s = fread($assoc_file, filesize($filename));
 310         fclose($assoc_file);
 311
 312         if (!$assoc_s) {
 313             return null;
 314         }
 315
 316         $association =
 317             Auth_OpenID_Association::deserialize('Auth_OpenID_Association',
 318                                                 $assoc_s);
 319
 320         if (!$association) {
 321             Auth_OpenID_FileStore::_removeIfPresent($filename);
 322             return null;
 323         }
 324
 325         if ($association->getExpiresIn() == 0) {
 326             Auth_OpenID_FileStore::_removeIfPresent($filename);
 327             return null;
 328         } else {
 329             return $association;
 330         }
 331     }
 332
 333     /**
 334      * Remove an association if it exists. Do nothing if it does not.
 335      *
 336      * @return bool $success
 337      */
 338     function removeAssociation($server_url, $handle)
 339     {
 340         if (!$this->active) {
 341             trigger_error("FileStore no longer active", E_USER_ERROR);
 342             return null;
 343         }
 344
 345         $assoc = $this->getAssociation($server_url, $handle);
 346         if ($assoc === null) {
 347             return false;
 348         } else {
 349             $filename = $this->getAssociationFilename($server_url, $handle);
 350             return Auth_OpenID_FileStore::_removeIfPresent($filename);
 351         }
 352     }
 353
 354     /**
 355      * Return whether this nonce is present. As a side effect, mark it
 356      * as no longer present.
 357      *
 358      * @return bool $present
 359      */
 360     function useNonce($server_url, $timestamp, $salt)
 361     {
 362         global $Auth_OpenID_SKEW;
 363
 364         if (!$this->active) {
 365             trigger_error("FileStore no longer active", E_USER_ERROR);
 366             return null;
 367         }
 368
 369         if ( abs($timestamp - time()) > $Auth_OpenID_SKEW ) {
 370             return False;
 371         }
 372
 373         if ($server_url) {
 374             list($proto, $rest) = explode('://', $server_url, 2);
 375         } else {
 376             $proto = '';
 377             $rest = '';
 378         }
 379
 380         $parts = explode('/', $rest, 2);
 381         $domain = $this->_filenameEscape($parts[0]);
 382         $url_hash = $this->_safe64($server_url);
 383         $salt_hash = $this->_safe64($salt);
 384
 385         $filename = sprintf('%08x-%s-%s-%s-%s', $timestamp, $proto,
 386                             $domain, $url_hash, $salt_hash);
 387         $filename = $this->nonce_dir . DIRECTORY_SEPARATOR . $filename;
 388
 389         $result = @fopen($filename, 'x');
 390
 391         if ($result === false) {
 392             return false;
 393         } else {
 394             fclose($result);
 395             return true;
 396         }
 397     }
 398
 399     /**
 400      * Remove expired entries from the database. This is potentially
 401      * expensive, so only run when it is acceptable to take time.
 402      *
 403      * @access private
 404      */
 405     function _allAssocs()
 406     {
 407         $all_associations = array();
 408
 409         $association_filenames =
 410             Auth_OpenID_FileStore::_listdir($this->association_dir);
 411
 412         foreach ($association_filenames as $association_filename) {
 413             $association_file = fopen($association_filename, 'rb');
 414
 415             if ($association_file !== false) {
 416                 $assoc_s = fread($association_file,
 417                                  filesize($association_filename));
 418                 fclose($association_file);
 419
 420                 // Remove expired or corrupted associations
 421                 $association =
 422                   Auth_OpenID_Association::deserialize(
 423                          'Auth_OpenID_Association', $assoc_s);
 424
 425                 if ($association === null) {
 426                     Auth_OpenID_FileStore::_removeIfPresent(
 427                                                  $association_filename);
 428                 } else {
 429                     if ($association->getExpiresIn() == 0) {
 430                         $all_associations[] = array($association_filename,
 431                                                     $association);
 432                     }
 433                 }
 434             }
 435         }
 436
 437         return $all_associations;
 438     }
 439
 440     function clean()
 441     {
 442         if (!$this->active) {
 443             trigger_error("FileStore no longer active", E_USER_ERROR);
 444             return null;
 445         }
 446
 447         $nonces = Auth_OpenID_FileStore::_listdir($this->nonce_dir);
 448         $now = time();
 449
 450         // Check all nonces for expiry
 451         foreach ($nonces as $nonce) {
 452             if (!Auth_OpenID_checkTimestamp($nonce, $now)) {
 453                 $filename = $this->nonce_dir . DIRECTORY_SEPARATOR . $nonce;
 454                 Auth_OpenID_FileStore::_removeIfPresent($filename);
 455             }
 456         }
 457
 458         foreach ($this->_allAssocs() as $pair) {
 459             list($assoc_filename, $assoc) = $pair;
 460             if ($assoc->getExpiresIn() == 0) {
 461                 Auth_OpenID_FileStore::_removeIfPresent($assoc_filename);
 462             }
 463         }
 464     }
 465
 466     /**
 467      * @access private
 468      */
 469     function _rmtree($dir)
 470     {
 471         if ($dir[strlen($dir) - 1] != DIRECTORY_SEPARATOR) {
 472             $dir .= DIRECTORY_SEPARATOR;
 473         }
 474
 475         if ($handle = opendir($dir)) {
 476             while ($item = readdir($handle)) {
 477                 if (!in_array($item, array('.', '..'))) {
 478                     if (is_dir($dir . $item)) {
 479
 480                         if (!Auth_OpenID_FileStore::_rmtree($dir . $item)) {
 481                             return false;
 482                         }
 483                     } else if (is_file($dir . $item)) {
 484                         if (!unlink($dir . $item)) {
 485                             return false;
 486                         }
 487                     }
 488                 }
 489             }
 490
 491             closedir($handle);
 492
 493             if (!@rmdir($dir)) {
 494                 return false;
 495             }
 496
 497             return true;
 498         } else {
 499             // Couldn't open directory.
 500             return false;
 501         }
 502     }
 503
 504     /**
 505      * @access private
 506      */
 507     function _mkstemp($dir)
 508     {
 509         foreach (range(0, 4) as $i) {
 510             $name = tempnam($dir, "php_openid_filestore_");
 511
 512             if ($name !== false) {
 513                 return $name;
 514             }
 515         }
 516         return false;
 517     }
 518
 519     /**
 520      * @access private
 521      */
 522     function _mkdtemp($dir)
 523     {
 524         foreach (range(0, 4) as $i) {
 525             $name = $dir . strval(DIRECTORY_SEPARATOR) . strval(getmypid()) .
 526                 "-" . strval(rand(1, time()));
 527             if (!mkdir($name, 0700)) {
 528                 return false;
 529             } else {
 530                 return $name;
 531             }
 532         }
 533         return false;
 534     }
 535
 536     /**
 537      * @access private
 538      */
 539     function _listdir($dir)
 540     {
 541         $handle = opendir($dir);
 542         $files = array();
 543         while (false !== ($filename = readdir($handle))) {
 544             if (!in_array($filename, array('.', '..'))) {
 545                 $files[] = $dir . DIRECTORY_SEPARATOR . $filename;
 546             }
 547         }
 548         return $files;
 549     }
 550
 551     /**
 552      * @access private
 553      */
 554     function _isFilenameSafe($char)
 555     {
 556         $_Auth_OpenID_filename_allowed = Auth_OpenID_letters .
 557             Auth_OpenID_digits . ".";
 558         return (strpos($_Auth_OpenID_filename_allowed, $char) !== false);
 559     }
 560
 561     /**
 562      * @access private
 563      */
 564     function _safe64($str)
 565     {
 566         $h64 = base64_encode(Auth_OpenID_SHA1($str));
 567         $h64 = str_replace('+', '_', $h64);
 568         $h64 = str_replace('/', '.', $h64);
 569         $h64 = str_replace('=', '', $h64);
 570         return $h64;
 571     }
 572
 573     /**
 574      * @access private
 575      */
 576     function _filenameEscape($str)
 577     {
 578         $filename = "";
 579         $b = Auth_OpenID::toBytes($str);
 580
 581         for ($i = 0; $i < count($b); $i++) {
 582             $c = $b[$i];
 583             if (Auth_OpenID_FileStore::_isFilenameSafe($c)) {
 584                 $filename .= $c;
 585             } else {
 586                 $filename .= sprintf("_%02X", ord($c));
 587             }
 588         }
 589         return $filename;
 590     }
 591
 592     /**
 593      * Attempt to remove a file, returning whether the file existed at
 594      * the time of the call.
 595      *
 596      * @access private
 597      * @return bool $result True if the file was present, false if not.
 598      */
 599     function _removeIfPresent($filename)
 600     {
 601         return @unlink($filename);
 602     }
 603
 604     function cleanupAssociations()
 605     {
 606         $removed = 0;
 607         foreach ($this->_allAssocs() as $pair) {
 608             list($assoc_filename, $assoc) = $pair;
 609             if ($assoc->getExpiresIn() == 0) {
 610                 $this->_removeIfPresent($assoc_filename);
 611                 $removed += 1;
 612             }
 613         }
 614         return $removed;
 615     }
 616 }
 617
 618 ?>