593 lines
18 KiB
PHP
593 lines
18 KiB
PHP
<?php
|
|
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
|
|
|
|
/**
|
|
* File::Passwd::Custom
|
|
*
|
|
* PHP versions 4 and 5
|
|
*
|
|
* LICENSE: This source file is subject to version 3.0 of the PHP license
|
|
* that is available through the world-wide-web at the following URI:
|
|
* http://www.php.net/license/3_0.txt. If you did not receive a copy of
|
|
* the PHP License and are unable to obtain it through the web, please
|
|
* send a note to license@php.net so we can mail you a copy immediately.
|
|
*
|
|
* @category FileFormats
|
|
* @package File_Passwd
|
|
* @author Michael Wallner <mike@php.net>
|
|
* @copyright 2003-2005 Michael Wallner
|
|
* @license http://www.php.net/license/3_0.txt PHP License 3.0
|
|
* @version CVS: $Id: Custom.php,v 1.10 2005/03/30 18:33:33 mike Exp $
|
|
* @link http://pear.php.net/package/File_Passwd
|
|
*/
|
|
|
|
/**
|
|
* Requires File::Passwd::Common
|
|
*/
|
|
require_once 'File/Passwd/Common.php';
|
|
|
|
/**
|
|
* Manipulate custom formatted passwd files
|
|
*
|
|
* Usage Example:
|
|
* <code>
|
|
* $cust = &File_Passwd::factory('Custom');
|
|
* $cust->setDelim('|');
|
|
* $cust->load();
|
|
* $cust->setEncFunc(array('File_Passwd', 'crypt_apr_md5'));
|
|
* $cust->addUser('mike', 'pass');
|
|
* $cust->save();
|
|
* </code>
|
|
*
|
|
* @author Michael Wallner <mike@php.net>
|
|
* @version $Revision: 1.10 $
|
|
* @access public
|
|
*/
|
|
class File_Passwd_Custom extends File_Passwd_Common
|
|
{
|
|
/**
|
|
* Delimiter
|
|
*
|
|
* @access private
|
|
* @var string
|
|
*/
|
|
var $_delim = ':';
|
|
|
|
/**
|
|
* Encryption function
|
|
*
|
|
* @access private
|
|
* @var string
|
|
*/
|
|
var $_enc = array('File_Passwd', 'crypt_md5');
|
|
|
|
/**
|
|
* 'name map'
|
|
*
|
|
* @access private
|
|
* @var array
|
|
*/
|
|
var $_map = array();
|
|
|
|
/**
|
|
* Whether to use the 'name map' or not
|
|
*
|
|
* @var boolean
|
|
* @access private
|
|
*/
|
|
var $_usemap = false;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @access protected
|
|
* @return object
|
|
*/
|
|
function File_Passwd_Custom($file = 'passwd')
|
|
{
|
|
$this->__construct($file);
|
|
}
|
|
|
|
/**
|
|
* Fast authentication of a certain user
|
|
*
|
|
* Returns a PEAR_Error if:
|
|
* o file doesn't exist
|
|
* o file couldn't be opened in read mode
|
|
* o file couldn't be locked exclusively
|
|
* o file couldn't be unlocked (only if auth fails)
|
|
* o file couldn't be closed (only if auth fails)
|
|
* o invalid encryption function <var>$opts[0]</var>,
|
|
* or no delimiter character <var>$opts[1]</var> was provided
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_UNDEFINED |
|
|
* FILE_PASSWD_E_FILE_NOT_OPENED |
|
|
* FILE_PASSWD_E_FILE_NOT_LOCKED |
|
|
* FILE_PASSWD_E_FILE_NOT_UNLOCKED |
|
|
* FILE_PASSWD_E_FILE_NOT_CLOSED |
|
|
* FILE_PASSWD_E_INVALID_ENC_MODE
|
|
* @static call this method statically for a reasonable fast authentication
|
|
* @access public
|
|
* @return mixed Returns &true; if authenticated, &false; if not or
|
|
* <classname>PEAR_Error</classname> on failure.
|
|
* @param string $file path to passwd file
|
|
* @param string $user user to authenticate
|
|
* @param string $pass plaintext password
|
|
* @param array $otps encryption function and delimiter charachter
|
|
* (in this order)
|
|
*/
|
|
function staticAuth($file, $user, $pass, $opts)
|
|
{
|
|
setType($opts, 'array');
|
|
if (count($opts) != 2 || empty($opts[1])) {
|
|
return PEAR::raiseError('Insufficient options.', 0);
|
|
}
|
|
|
|
$line = File_Passwd_Common::_auth($file, $user, $opts[1]);
|
|
|
|
if (!$line || PEAR::isError($line)) {
|
|
return $line;
|
|
}
|
|
|
|
list(,$real)= explode($opts[1], $line);
|
|
$crypted = File_Passwd_Custom::_genPass($pass, $real, $opts[0]);
|
|
|
|
if (PEAR::isError($crypted)) {
|
|
return $crypted;
|
|
}
|
|
|
|
return ($crypted === $real);
|
|
}
|
|
|
|
/**
|
|
* Set delimiter
|
|
*
|
|
* You can set a custom char to delimit the columns of a data set.
|
|
* Defaults to a colon (':'). Be aware that this char mustn't be
|
|
* in the values of your data sets.
|
|
*
|
|
* @access public
|
|
* @return void
|
|
* @param string $delim custom delimiting character
|
|
*/
|
|
function setDelim($delim = ':')
|
|
{
|
|
@setType($delim, 'string');
|
|
if (empty($delim)) {
|
|
$this->_delim = ':';
|
|
} else {
|
|
$this->_delim = $delim{0};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get custom delimiter
|
|
*
|
|
* @access public
|
|
* @return string
|
|
*/
|
|
function getDelim()
|
|
{
|
|
return $this->_delim;
|
|
}
|
|
|
|
/**
|
|
* Set encryption function
|
|
*
|
|
* You can set a custom encryption function to use.
|
|
* The supplied function will be called by php's call_user_function(),
|
|
* so you can supply an array with a method of a class/object, too
|
|
* (i.e. array('File_Passwd', 'crypt_apr_md5').
|
|
*
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_INVALID_ENC_MODE
|
|
* @access public
|
|
* @return mixed Returns &true; on success or
|
|
* <classname>PEAR_Error</classname> on failure.
|
|
* @param mixed $function callable encryption function
|
|
*/
|
|
function setEncFunc($function = array('File_Passwd', 'crypt_md5'))
|
|
{
|
|
if (!is_callable($function)) {
|
|
if (is_array($function)) {
|
|
$function = implode('::', $function);
|
|
}
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $function),
|
|
FILE_PASSWD_E_INVALID_ENC_MODE
|
|
);
|
|
}
|
|
|
|
$this->_enc = $function;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get current custom encryption method
|
|
*
|
|
* Possible return values (examples):
|
|
* o 'md5'
|
|
* o 'File_Passwd::crypt_md5'
|
|
*
|
|
* @access public
|
|
* @return string
|
|
*/
|
|
function getEncFunc()
|
|
{
|
|
if (is_array($this->_enc)) {
|
|
return implode('::', $this->_enc);
|
|
}
|
|
return $this->_enc;
|
|
}
|
|
|
|
/**
|
|
* Whether to use the 'name map' of the extra properties or not
|
|
*
|
|
* @see File_Passwd_Custom::useMap()
|
|
* @see setMap()
|
|
* @see getMap()
|
|
*
|
|
* @access public
|
|
* @return boolean always true if you set a value (true/false) OR
|
|
* the actual value if called without param
|
|
*
|
|
* @param boolean $bool whether to use the 'name map' or not
|
|
*/
|
|
function useMap($bool = null)
|
|
{
|
|
if (is_null($bool)) {
|
|
return $this->_usemap;
|
|
}
|
|
$this->_usemap = (bool) $bool;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Set the 'name map' to use with the extra properties of the user
|
|
*
|
|
* This map is used for naming the associative array of the extra properties.
|
|
*
|
|
* Returns a PEAR_Error if <var>$map</var> was not of type array.
|
|
*
|
|
* @see getMap()
|
|
* @see useMap()
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_PARAM_MUST_BE_ARRAY
|
|
* @access public
|
|
* @return mixed true on success or PEAR_Error
|
|
*/
|
|
function setMap($map = array())
|
|
{
|
|
if (!is_array($map)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_PARAM_MUST_BE_ARRAY_STR, '$map'),
|
|
FILE_PASSWD_E_PARAM_MUST_BE_ARRAY
|
|
);
|
|
}
|
|
$this->_map = $map;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get the 'name map' which is used for the extra properties of the user
|
|
*
|
|
* @see setMap()
|
|
* @see useMap()
|
|
*
|
|
* @access public
|
|
* @return array
|
|
*/
|
|
function getMap()
|
|
{
|
|
return $this->_map;
|
|
}
|
|
|
|
/**
|
|
* Apply changes an rewrite passwd file
|
|
*
|
|
* Returns a PEAR_Error if:
|
|
* o directory in which the file should reside couldn't be created
|
|
* o file couldn't be opened in write mode
|
|
* o file couldn't be locked exclusively
|
|
* o file couldn't be unlocked
|
|
* o file couldn't be closed
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_FILE_NOT_OPENED |
|
|
* FILE_PASSWD_E_FILE_NOT_LOCKED |
|
|
* FILE_PASSWD_E_FILE_NOT_UNLOCKED |
|
|
* FILE_PASSWD_E_FILE_NOT_CLOSED
|
|
* @access public
|
|
* @return mixed Returns &true; on success or
|
|
* <classname>PEAR_Error</classname> on failure.
|
|
*/
|
|
function save()
|
|
{
|
|
$content = '';
|
|
foreach ($this->_users as $user => $array){
|
|
$pass = array_shift($array);
|
|
$extra = implode($this->_delim, $array);
|
|
$content .= $user . $this->_delim . $pass;
|
|
if (!empty($extra)) {
|
|
$content .= $this->_delim . $extra;
|
|
}
|
|
$content .= "\n";
|
|
}
|
|
return $this->_save($content);
|
|
}
|
|
|
|
/**
|
|
* Parse the Custom password file
|
|
*
|
|
* Returns a PEAR_Error if passwd file has invalid format.
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_INVALID_FORMAT
|
|
* @access public
|
|
* @return mixed Returns &true; on success or
|
|
* <classname>PEAR_Error</classname> on failure.
|
|
*/
|
|
function parse()
|
|
{
|
|
$this->_users = array();
|
|
foreach ($this->_contents as $line){
|
|
$parts = explode($this->_delim, $line);
|
|
if (count($parts) < 2) {
|
|
return PEAR::raiseError(
|
|
FILE_PASSWD_E_INVALID_FORMAT_STR,
|
|
FILE_PASSWD_E_INVALID_FORMAT
|
|
);
|
|
}
|
|
$user = array_shift($parts);
|
|
$pass = array_shift($parts);
|
|
$values = array();
|
|
if ($this->_usemap) {
|
|
$values['pass'] = $pass;
|
|
foreach ($parts as $i => $value){
|
|
if (isset($this->_map[$i])) {
|
|
$values[$this->_map[$i]] = $value;
|
|
} else {
|
|
$values[$i+1] = $value;
|
|
}
|
|
}
|
|
} else {
|
|
$values = array_merge(array($pass), $parts);
|
|
}
|
|
$this->_users[$user] = $values;
|
|
|
|
}
|
|
$this->_contents = array();
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Add an user
|
|
*
|
|
* The username must start with an alphabetical character and must NOT
|
|
* contain any other characters than alphanumerics, the underline and dash.
|
|
*
|
|
* If you use the 'name map' you should also use these naming in
|
|
* the supplied extra array, because your values would get mixed up
|
|
* if they are in the wrong order, which is always true if you
|
|
* DON'T use the 'name map'!
|
|
*
|
|
* So be warned and USE the 'name map'!
|
|
*
|
|
* Returns a PEAR_Error if:
|
|
* o user already exists
|
|
* o user contains illegal characters
|
|
* o encryption mode is not supported
|
|
* o any element of the <var>$extra</var> array contains the delimiter char
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_EXISTS_ALREADY |
|
|
* FILE_PASSWD_E_INVALID_ENC_MODE |
|
|
* FILE_PASSWD_E_INVALID_CHARS
|
|
* @access public
|
|
* @return mixed Returns &true; on success or
|
|
* <classname>PEAR_Error</classname> on failure.
|
|
* @param string $user the name of the user to add
|
|
* @param string $pass the password of the user to add
|
|
* @param array $extra extra properties of user to add
|
|
*/
|
|
function addUser($user, $pass, $extra = array())
|
|
{
|
|
if ($this->userExists($user)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_EXISTS_ALREADY_STR, 'User ', $user),
|
|
FILE_PASSWD_E_EXISTS_ALREADY
|
|
);
|
|
}
|
|
if (!preg_match($this->_pcre, $user) || strstr($user, $this->_delim)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
|
|
FILE_PASSWD_E_INVALID_CHARS
|
|
);
|
|
}
|
|
if (!is_array($extra)) {
|
|
setType($extra, 'array');
|
|
}
|
|
foreach ($extra as $e){
|
|
if (strstr($e, $this->_delim)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'Property ', $e),
|
|
FILE_PASSWD_E_INVALID_CHARS
|
|
);
|
|
}
|
|
}
|
|
|
|
$pass = $this->_genPass($pass);
|
|
if (PEAR::isError($pass)) {
|
|
return $pass;
|
|
}
|
|
|
|
/**
|
|
* If you don't use the 'name map' the user array will be numeric.
|
|
*/
|
|
if (!$this->_usemap) {
|
|
array_unshift($extra, $pass);
|
|
$this->_users[$user] = $extra;
|
|
} else {
|
|
$map = $this->_map;
|
|
array_unshift($map, 'pass');
|
|
$extra['pass'] = $pass;
|
|
foreach ($map as $key){
|
|
$this->_users[$user][$key] = @$extra[$key];
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Modify properties of a certain user
|
|
*
|
|
* # DON'T MODIFY THE PASSWORD WITH THIS METHOD!
|
|
*
|
|
* You should use this method only if the 'name map' is used, too.
|
|
*
|
|
* Returns a PEAR_Error if:
|
|
* o user doesn't exist
|
|
* o any property contains the custom delimiter character
|
|
*
|
|
* @see changePasswd()
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_EXISTS_NOT |
|
|
* FILE_PASSWD_E_INVALID_CHARS
|
|
* @access public
|
|
* @return mixed true on success or PEAR_Error
|
|
* @param string $user the user to modify
|
|
* @param array $properties an associative array of
|
|
* properties to modify
|
|
*/
|
|
function modUser($user, $properties = array())
|
|
{
|
|
if (!$this->userExists($user)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
|
|
FILE_PASSWD_E_EXISTS_NOT
|
|
);
|
|
}
|
|
|
|
if (!is_array($properties)) {
|
|
setType($properties, 'array');
|
|
}
|
|
|
|
foreach ($properties as $key => $value){
|
|
if (strstr($value, $this->_delim)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
|
|
FILE_PASSWD_E_INVALID_CHARS
|
|
);
|
|
}
|
|
$this->_users[$user][$key] = $value;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Change the password of a certain user
|
|
*
|
|
* Returns a PEAR_Error if:
|
|
* o user doesn't exists
|
|
* o encryption mode is not supported
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_EXISTS_NOT |
|
|
* FILE_PASSWD_E_INVALID_ENC_MODE
|
|
* @access public
|
|
* @return mixed Returns &true; on success or
|
|
* <classname>PEAR_Error</classname> on failure.
|
|
* @param string $user the user whose password should be changed
|
|
* @param string $pass the new plaintext password
|
|
*/
|
|
function changePasswd($user, $pass)
|
|
{
|
|
if (!$this->userExists($user)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
|
|
FILE_PASSWD_E_EXISTS_NOT
|
|
);
|
|
}
|
|
|
|
$pass = $this->_genPass($pass);
|
|
if (PEAR::isError($pass)) {
|
|
return $pass;
|
|
}
|
|
|
|
if ($this->_usemap) {
|
|
$this->_users[$user]['pass'] = $pass;
|
|
} else {
|
|
$this->_users[$user][0] = $pass;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Verify the password of a certain user
|
|
*
|
|
* Returns a PEAR_Error if:
|
|
* o user doesn't exist
|
|
* o encryption mode is not supported
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_EXISTS_NOT |
|
|
* FILE_PASSWD_E_INVALID_ENC_MODE
|
|
* @access public
|
|
* @return mixed Returns &true; if passwors equal, &false; if they don't
|
|
* or <classname>PEAR_Error</classname> on fialure.
|
|
* @param string $user the user whose password should be verified
|
|
* @param string $pass the password to verify
|
|
*/
|
|
function verifyPasswd($user, $pass)
|
|
{
|
|
if (!$this->userExists($user)) {
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
|
|
FILE_PASSWD_E_EXISTS_NOT
|
|
);
|
|
}
|
|
$real =
|
|
$this->_usemap ?
|
|
$this->_users[$user]['pass'] :
|
|
$this->_users[$user][0]
|
|
;
|
|
return ($real === $this->_genPass($pass, $real));
|
|
}
|
|
|
|
/**
|
|
* Generate crypted password from the plaintext password
|
|
*
|
|
* Returns a PEAR_Error if actual encryption mode is not supported.
|
|
*
|
|
* @throws PEAR_Error FILE_PASSWD_E_INVALID_ENC_MODE
|
|
* @access private
|
|
* @return mixed Returns the crypted password or
|
|
* <classname>PEAR_Error</classname>
|
|
* @param string $pass the plaintext password
|
|
* @param string $salt the crypted password from which to gain the salt
|
|
* @param string $func the encryption function to use
|
|
*/
|
|
function _genPass($pass, $salt = null, $func = null)
|
|
{
|
|
if (is_null($func)) {
|
|
$func = $this->_enc;
|
|
}
|
|
|
|
if (!is_callable($func)) {
|
|
if (is_array($func)) {
|
|
$func = implode('::', $func);
|
|
}
|
|
return PEAR::raiseError(
|
|
sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $func),
|
|
FILE_PASSWD_E_INVALID_ENC_MODE
|
|
);
|
|
}
|
|
|
|
$return = @call_user_func($func, $pass, $salt);
|
|
|
|
if (is_null($return) || $return === false) {
|
|
$return = @call_user_func($func, $pass);
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
}
|
|
?>
|