includes/functions-auth.php

   1 <?php
   2 /**
   3  * Check for valid user via login form or stored cookie. Returns true or an error message
   4  *
   5  */
   6 function yourls_is_valid_user() {
   7         static $valid = false;
   8
   9         if( $valid )
  10                 return true;
  11
  12         // Allow plugins to short-circuit the whole function
  13         $pre = yourls_apply_filter( 'shunt_is_valid_user', null );
  14         if ( null !== $pre ) {
  15                 $valid = ( $pre === true ) ;
  16                 return $pre;
  17         }
  18
  19         // $unfiltered_valid : are credentials valid? Boolean value. It's "unfiltered" to allow plugins to eventually filter it.
  20         $unfiltered_valid = false;
  21
  22         // Logout request
  23         if( isset( $_GET['action'] ) && $_GET['action'] == 'logout' ) {
  24                 yourls_do_action( 'logout' );
  25                 yourls_store_cookie( null );
  26                 return yourls__( 'Logged out successfully' );
  27         }
  28
  29         // Check cookies or login request. Login form has precedence.
  30
  31         yourls_do_action( 'pre_login' );
  32
  33         // Determine auth method and check credentials
  34         if
  35                 // API only: Secure (no login or pwd) and time limited token
  36                 // ?timestamp=12345678&signature=md5(totoblah12345678)
  37                 ( yourls_is_API() &&
  38                   isset( $_REQUEST['timestamp'] ) && !empty($_REQUEST['timestamp'] ) &&
  39                   isset( $_REQUEST['signature'] ) && !empty($_REQUEST['signature'] )
  40                 )
  41                 {
  42                         yourls_do_action( 'pre_login_signature_timestamp' );
  43                         $unfiltered_valid = yourls_check_signature_timestamp();
  44                 }
  45
  46         elseif
  47                 // API only: Secure (no login or pwd)
  48                 // ?signature=md5(totoblah)
  49                 ( yourls_is_API() &&
  50                   !isset( $_REQUEST['timestamp'] ) &&
  51                   isset( $_REQUEST['signature'] ) && !empty( $_REQUEST['signature'] )
  52                 )
  53                 {
  54                         yourls_do_action( 'pre_login_signature' );
  55                         $unfiltered_valid = yourls_check_signature();
  56                 }
  57
  58         elseif
  59                 // API or normal: login with username & pwd
  60                 ( isset( $_REQUEST['username'] ) && isset( $_REQUEST['password'] )
  61                   && !empty( $_REQUEST['username'] ) && !empty( $_REQUEST['password']  ) )
  62                 {
  63                         yourls_do_action( 'pre_login_username_password' );
  64                         $unfiltered_valid = yourls_check_username_password();
  65                 }
  66
  67         elseif
  68                 // Normal only: cookies
  69                 ( !yourls_is_API() &&
  70                   isset( $_COOKIE['yourls_username'] ) )
  71                 {
  72                         yourls_do_action( 'pre_login_cookie' );
  73                         $unfiltered_valid = yourls_check_auth_cookie();
  74                 }
  75
  76         // Regardless of validity, allow plugins to filter the boolean and have final word
  77         $valid = yourls_apply_filter( 'is_valid_user', $unfiltered_valid );
  78
  79         // Login for the win!
  80         if ( $valid ) {
  81                 yourls_do_action( 'login' );
  82
  83                 // (Re)store encrypted cookie if needed
  84                 if ( !yourls_is_API() ) {
  85                         yourls_store_cookie( YOURLS_USER );
  86
  87                         // Login form : redirect to requested URL to avoid re-submitting the login form on page reload
  88                         if( isset( $_REQUEST['username'] ) && isset( $_REQUEST['password'] ) && isset( $_SERVER['REQUEST_URI'] ) ) {
  89                                 $url = $_SERVER['REQUEST_URI'];
  90                                 yourls_redirect( $url );
  91                         }
  92                 }
  93
  94                 // Login successful
  95                 return true;
  96         }
  97
  98         // Login failed
  99         yourls_do_action( 'login_failed' );
 100
 101         if ( isset( $_REQUEST['username'] ) || isset( $_REQUEST['password'] ) ) {
 102                 return yourls__( 'Invalid username or password' );
 103         } else {
 104                 return yourls__( 'Please log in' );
 105         }
 106 }
 107
 108 /**
 109  * Check auth against list of login=>pwd. Sets user if applicable, returns bool
 110  *
 111  */
 112 function yourls_check_username_password() {
 113         global $yourls_user_passwords;
 114         if( isset( $yourls_user_passwords[ $_REQUEST['username'] ] ) && yourls_check_password_hash( $_REQUEST['username'], $_REQUEST['password'] ) ) {
 115                 yourls_set_user( $_REQUEST['username'] );
 116                 return true;
 117         }
 118         return false;
 119 }
 120
 121 /**
 122  * Check a submitted password sent in plain text against stored password which can be a salted hash
 123  *
 124  */
 125 function yourls_check_password_hash( $user, $submitted_password ) {
 126         global $yourls_user_passwords;
 127
 128         if( !isset( $yourls_user_passwords[ $user ] ) )
 129                 return false;
 130
 131         if ( yourls_has_phpass_password( $user ) ) {
 132                 // Stored password is hashed with phpass
 133                 list( , $hash ) = explode( ':', $yourls_user_passwords[ $user ] );
 134                 $hash = str_replace( '!', '$', $hash );
 135                 return ( yourls_phpass_check( $submitted_password, $hash ) );
 136         } else if( yourls_has_md5_password( $user ) ) {
 137                 // Stored password is a salted md5 hash: "md5:<$r = rand(10000,99999)>:<md5($r.'thepassword')>"
 138                 list( , $salt, ) = explode( ':', $yourls_user_passwords[ $user ] );
 139                 return( $yourls_user_passwords[ $user ] == 'md5:'.$salt.':'.md5( $salt . $submitted_password ) );
 140         } else {
 141                 // Password stored in clear text
 142                 return( $yourls_user_passwords[ $user ] == $submitted_password );
 143         }
 144 }
 145
 146 /**
 147  * Overwrite plaintext passwords in config file with phpassed versions.
 148  *
 149  * @since 1.7
 150  * @param string $config_file Full path to file
 151  * @return true if overwrite was successful, an error message otherwise
 152  */
 153 function yourls_hash_passwords_now( $config_file ) {
 154         if( !is_readable( $config_file ) )
 155                 return 'cannot read file'; // not sure that can actually happen...
 156
 157         if( !is_writable( $config_file ) )
 158                 return 'cannot write file';
 159
 160         // Include file to read value of $yourls_user_passwords
 161         // Temporary suppress error reporting to avoid notices about redeclared constants
 162         $errlevel = error_reporting();
 163         error_reporting( 0 );
 164         require $config_file;
 165         error_reporting( $errlevel );
 166
 167         $configdata = file_get_contents( $config_file );
 168         if( $configdata == false )
 169                 return 'could not read file';
 170
 171         $to_hash = 0; // keep track of number of passwords that need hashing
 172         foreach ( $yourls_user_passwords as $user => $password ) {
 173                 if ( !yourls_has_phpass_password( $user ) && !yourls_has_md5_password( $user ) ) {
 174                         $to_hash++;
 175                         $hash = yourls_phpass_hash( $password );
 176                         // PHP would interpret $ as a variable, so replace it in storage.
 177                         $hash = str_replace( '$', '!', $hash );
 178                         $quotes = "'" . '"';
 179                         $pattern = "/[$quotes]${user}[$quotes]\s*=>\s*[$quotes]" . preg_quote( $password, '-' ) . "[$quotes]/";
 180                         $replace = "'$user' => 'phpass:$hash' /* Password encrypted by YOURLS */ ";
 181                         $count = 0;
 182                         $configdata = preg_replace( $pattern, $replace, $configdata, -1, $count );
 183                         // There should be exactly one replacement. Otherwise, fast fail.
 184                         if ( $count != 1 ) {
 185                                 yourls_debug_log( "Problem with preg_replace for password hash of user $user" );
 186                                 return 'preg_replace problem';
 187                         }
 188                 }
 189         }
 190
 191         if( $to_hash == 0 )
 192                 return 0; // There was no password to encrypt
 193
 194         $success = file_put_contents( $config_file, $configdata );
 195         if ( $success === FALSE ) {
 196                 yourls_debug_log( 'Failed writing to ' . $config_file );
 197                 return 'could not write file';
 198         }
 199         return true;
 200 }
 201
 202 /**
 203  * Hash a password using phpass
 204  *
 205  * @since 1.7
 206  * @param string $password password to hash
 207  * @return string hashed password
 208  */
 209 function yourls_phpass_hash( $password ) {
 210         $hasher = yourls_phpass_instance();
 211         return $hasher->HashPassword( $password );
 212 }
 213
 214 /**
 215  * Check a clear password against a phpass hash
 216  *
 217  * @since 1.7
 218  * @param string $password clear (eg submitted in a form) password
 219  * @param string $hash hash supposedly generated by phpass
 220  * @return bool true if the hash matches the password once hashed by phpass, false otherwise
 221  */
 222 function yourls_phpass_check( $password, $hash ) {
 223         $hasher = yourls_phpass_instance();
 224         return $hasher->CheckPassword( $password, $hash );
 225 }
 226
 227 /**
 228  * Helper function: create new instance or return existing instance of phpass class
 229  *
 230  * @since 1.7
 231  * @param int $iteration iteration count - 8 is default in phpass
 232  * @param bool $portable flag to force portable (cross platform and system independant) hashes - false to use whatever the system can do best
 233  * @return object a PasswordHash instance
 234  */
 235 function yourls_phpass_instance( $iteration = 8, $portable = false ) {
 236         $iteration = yourls_apply_filter( 'phpass_new_instance_iteration', $iteration );
 237         $portable  = yourls_apply_filter( 'phpass_new_instance_portable', $portable );
 238
 239         if( !class_exists( 'PasswordHash' ) ) {
 240                 require_once( YOURLS_INC.'/phpass/PasswordHash.php' );
 241         }
 242
 243         static $instance = false;
 244         if( $instance == false ) {
 245                 $instance = new PasswordHash( $iteration, $portable );
 246         }
 247
 248         return $instance;
 249 }
 250
 251
 252 /**
 253  * Check to see if any passwords are stored as cleartext.
 254  *
 255  * @since 1.7
 256  * @return bool true if any passwords are cleartext
 257  */
 258 function yourls_has_cleartext_passwords() {
 259         global $yourls_user_passwords;
 260         foreach ( $yourls_user_passwords as $user => $pwdata ) {
 261                 if ( !yourls_has_md5_password( $user ) && !yourls_has_phpass_password( $user ) ) {
 262                         return true;
 263                 }
 264         }
 265         return false;
 266 }
 267
 268 /**
 269  * Check if a user has a hashed password
 270  *
 271  * Check if a user password is 'md5:[38 chars]'.
 272  * TODO: deprecate this when/if we have proper user management with password hashes stored in the DB
 273  *
 274  * @since 1.7
 275  * @param string $user user login
 276  * @return bool true if password hashed, false otherwise
 277  */
 278 function yourls_has_md5_password( $user ) {
 279         global $yourls_user_passwords;
 280         return(    isset( $yourls_user_passwords[ $user ] )
 281                 && substr( $yourls_user_passwords[ $user ], 0, 4 ) == 'md5:'
 282                     && strlen( $yourls_user_passwords[ $user ] ) == 42 // http://www.google.com/search?q=the+answer+to+life+the+universe+and+everything
 283                    );
 284 }
 285
 286 /**
 287  * Check if a user's password is hashed with PHPASS.
 288  *
 289  * Check if a user password is 'phpass:[lots of chars]'.
 290  * TODO: deprecate this when/if we have proper user management with password hashes stored in the DB
 291  *
 292  * @since 1.7
 293  * @param string $user user login
 294  * @return bool true if password hashed with PHPASS, otherwise false
 295  */
 296 function yourls_has_phpass_password( $user ) {
 297         global $yourls_user_passwords;
 298         return( isset( $yourls_user_passwords[ $user ] )
 299                 && substr( $yourls_user_passwords[ $user ], 0, 7 ) == 'phpass:'
 300         );
 301 }
 302
 303 /**
 304  * Check auth against encrypted COOKIE data. Sets user if applicable, returns bool
 305  *
 306  */
 307 function yourls_check_auth_cookie() {
 308         global $yourls_user_passwords;
 309         foreach( $yourls_user_passwords as $valid_user => $valid_password ) {
 310                 if ( yourls_salt( $valid_user ) == $_COOKIE['yourls_username'] ) {
 311                         yourls_set_user( $valid_user );
 312                         return true;
 313                 }
 314         }
 315         return false;
 316 }
 317
 318 /**
 319  * Check auth against signature and timestamp. Sets user if applicable, returns bool
 320  *
 321  */
 322 function yourls_check_signature_timestamp() {
 323         // Timestamp in PHP : time()
 324         // Timestamp in JS: parseInt(new Date().getTime() / 1000)
 325         global $yourls_user_passwords;
 326         foreach( $yourls_user_passwords as $valid_user => $valid_password ) {
 327                 if (
 328                         (
 329                                 md5( $_REQUEST['timestamp'].yourls_auth_signature( $valid_user ) ) == $_REQUEST['signature']
 330                                 or
 331                                 md5( yourls_auth_signature( $valid_user ).$_REQUEST['timestamp'] ) == $_REQUEST['signature']
 332                         )
 333                         &&
 334                         yourls_check_timestamp( $_REQUEST['timestamp'] )
 335                         ) {
 336                         yourls_set_user( $valid_user );
 337                         return true;
 338                 }
 339         }
 340         return false;
 341 }
 342
 343 /**
 344  * Check auth against signature. Sets user if applicable, returns bool
 345  *
 346  */
 347 function yourls_check_signature() {
 348         global $yourls_user_passwords;
 349         foreach( $yourls_user_passwords as $valid_user => $valid_password ) {
 350                 if ( yourls_auth_signature( $valid_user ) == $_REQUEST['signature'] ) {
 351                         yourls_set_user( $valid_user );
 352                         return true;
 353                 }
 354         }
 355         return false;
 356 }
 357
 358 /**
 359  * Generate secret signature hash
 360  *
 361  */
 362 function yourls_auth_signature( $username = false ) {
 363         if( !$username && defined('YOURLS_USER') ) {
 364                 $username = YOURLS_USER;
 365         }
 366         return ( $username ? substr( yourls_salt( $username ), 0, 10 ) : 'Cannot generate auth signature: no username' );
 367 }
 368
 369 /**
 370  * Check if timestamp is not too old
 371  *
 372  */
 373 function yourls_check_timestamp( $time ) {
 374         $now = time();
 375         // Allow timestamp to be a little in the future or the past -- see Issue 766
 376         return yourls_apply_filter( 'check_timestamp', abs( $now - $time ) < YOURLS_NONCE_LIFE, $time );
 377 }
 378
 379 /**
 380  * Store new cookie. No $user will delete the cookie.
 381  *
 382  */
 383 function yourls_store_cookie( $user = null ) {
 384         if( !$user ) {
 385                 $pass = null;
 386                 $time = time() - 3600;
 387         } else {
 388                 global $yourls_user_passwords;
 389                 if( isset($yourls_user_passwords[$user]) ) {
 390                         $pass = $yourls_user_passwords[$user];
 391                 } else {
 392                         die( 'Stealing cookies?' ); // This should never happen
 393                 }
 394                 $time = time() + YOURLS_COOKIE_LIFE;
 395         }
 396
 397         $domain   = yourls_apply_filter( 'setcookie_domain',   parse_url( YOURLS_SITE, 1 ) );
 398         $secure   = yourls_apply_filter( 'setcookie_secure',   yourls_is_ssl() );
 399         $httponly = yourls_apply_filter( 'setcookie_httponly', true );
 400
 401         // Some browser refuse to store localhost cookie
 402         if ( $domain == 'localhost' )
 403                 $domain = '';
 404
 405         if ( !headers_sent( $filename, $linenum ) ) {
 406                 // Set httponly if the php version is >= 5.2.0
 407                 if( version_compare( phpversion(), '5.2.0', 'ge' ) ) {
 408                         setcookie('yourls_username', yourls_salt( $user ), $time, '/', $domain, $secure, $httponly );
 409                 } else {
 410                         setcookie('yourls_username', yourls_salt( $user ), $time, '/', $domain, $secure );
 411                 }
 412         } else {
 413                 // For some reason cookies were not stored: action to be able to debug that
 414                 yourls_do_action( 'setcookie_failed', $user );
 415         yourls_debug_log( "Could not store cookie: headers already sent in $filename on line $linenum" );
 416         }
 417 }
 418
 419 /**
 420  * Set user name
 421  *
 422  */
 423 function yourls_set_user( $user ) {
 424         if( !defined( 'YOURLS_USER' ) )
 425                 define( 'YOURLS_USER', $user );
 426 }
 427