home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / File / Passwd / Smb.php < prev    next >
Encoding:
PHP Script  |  2004-10-01  |  13.0 KB  |  418 lines
  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PEAR :: File :: Passwd :: Smb                                        |
  4. // +----------------------------------------------------------------------+
  5. // | This source file is subject to version 3.0 of the PHP license,       |
  6. // | that is available at http://www.php.net/license/3_0.txt              |
  7. // | If you did not receive a copy of the PHP license and are unable      |
  8. // | to obtain it through the world-wide-web, please send a note to       |
  9. // | license@php.net so we can mail you a copy immediately.               |
  10. // +----------------------------------------------------------------------+
  11. // | Copyright (c) 2003-2004 Michael Wallner <mike@iworks.at>             |
  12. // +----------------------------------------------------------------------+
  13. //
  14. // $Id: Smb.php,v 1.15 2004/06/07 19:19:47 mike Exp $
  15.  
  16. /**
  17. * Manipulate SMB server passwd files.
  18. *
  19. * @author   Michael Bretterklieber <michael@bretterklieber.com>
  20. * @author   Michael Wallner <mike@php.net>
  21. * @package  File_Passwd
  22. */
  23.  
  24. /**
  25. * Requires File::Passwd::Common
  26. */
  27. require_once 'File/Passwd/Common.php';
  28.  
  29. /**
  30. * Requires Crypt::CHAP
  31. */
  32. require_once 'Crypt/CHAP.php';
  33.  
  34. /**
  35. * Manipulate SMB server passwd files.
  36. *
  37. * # Usage Example 1 (modifying existing file):
  38. * <code>
  39. * $f = &File_Passwd::factory('SMB');
  40. * $f->setFile('./smbpasswd');
  41. * $f->load();
  42. * $f->addUser('sepp3', 'MyPw', array('userid' => 12));
  43. * $f->changePasswd('sepp', 'MyPw');
  44. * $f->delUser('karli');
  45. * foreach($f->listUser() as $user => $data) {
  46. *   echo $user . ':' . implode(':', $data) ."\n";
  47. * }
  48. * $f->save();
  49. * </code>
  50. * 
  51. * # Usage Example 2 (creating a new file):
  52. * <code>
  53. * $f = &File_Passwd::factory('SMB');
  54. * $f->setFile('./smbpasswd');
  55. * $f->addUser('sepp1', 'MyPw', array('userid'=> 12));
  56. * $f->addUser('sepp3', 'MyPw', array('userid' => 1000));
  57. * $f->save();
  58. * </code>
  59. * 
  60. * # Usage Example 3 (authentication):
  61. * <code>
  62. * $f = &File_Passwd::factory('SMB');
  63. * $f->setFile('./smbpasswd');
  64. * $f->load();
  65. * if (true === $f->verifyPasswd('sepp', 'MyPw')) {
  66. *     echo "User valid";
  67. * } else {
  68. *     echo "User invalid or disabled";
  69. * }
  70. * </code>
  71. * 
  72. * @author   Michael Bretterklieber <michael@bretterklieber.com>
  73. * @author   Michael Wallner <mike@php.net>
  74. * @package  File_Passwd
  75. * @version  $Revision: 1.15 $
  76. * @access   public
  77. */
  78. class File_Passwd_Smb extends File_Passwd_Common
  79. {
  80.     /**
  81.     * Object which generates the NT-Hash and LAN-Manager-Hash passwds
  82.     * 
  83.     * @access protected
  84.     * @var object
  85.     */
  86.     var $msc;
  87.  
  88.     /**
  89.     * Constructor
  90.     *
  91.     * @access public
  92.     * @param  string $file  SMB passwd file
  93.     */
  94.     function File_Passwd_Smb($file = 'smbpasswd')
  95.     {
  96.         File_Passwd_Smb::__construct($file);
  97.     }
  98.     
  99.     /**
  100.     * Constructor (ZE2)
  101.     * 
  102.     * Rewritten because we want to init our crypt engine.
  103.     *
  104.     * @access public
  105.     * @param  string $file  SMB passwd file
  106.     */
  107.     function __construct($file = 'smbpasswd')
  108.     {
  109.         $this->setFile($file);
  110.         $this->msc = &new Crypt_CHAP_MSv1;
  111.     }     
  112.     
  113.     /**
  114.     * Fast authentication of a certain user
  115.     * 
  116.     * Returns a PEAR_Error if:
  117.     *   o file doesn't exist
  118.     *   o file couldn't be opened in read mode
  119.     *   o file couldn't be locked exclusively
  120.     *   o file couldn't be unlocked (only if auth fails)
  121.     *   o file couldn't be closed (only if auth fails)
  122.     *   o invalid encryption method <var>$nt_or_lm</var> was provided
  123.     *
  124.     * @static   call this method statically for a reasonable fast authentication
  125.     * @access   public
  126.     * @return   mixed   true if authenticated, false if not or PEAR_Error
  127.     * @param    string  $file       path to passwd file
  128.     * @param    string  $user       user to authenticate
  129.     * @param    string  $pass       plaintext password
  130.     * @param    string  $nt_or_lm   encryption mode to use (NT or LM hash)
  131.     */
  132.     function staticAuth($file, $user, $pass, $nt_or_lm = 'nt')
  133.     {
  134.         $line = File_Passwd_Common::_auth($file, $user);
  135.         if (!$line || PEAR::isError($line)) {
  136.             return $line;
  137.         }
  138.         @list(,,$lm,$nt) = explode(':', $line);
  139.         $chap            = &new Crypt_CHAP_MSv1;
  140.         
  141.         switch(strToLower($nt_or_lm)){
  142.             case FILE_PASSWD_NT: 
  143.                 $real       = $nt; 
  144.                 $crypted    = $chap->ntPasswordHash($pass); 
  145.                 break;
  146.             case FILE_PASSWD_LM: 
  147.                 $real       = $lm;
  148.                 $crypted    = $chap->lmPasswordHash($pass); 
  149.                 break;
  150.             default:
  151.                 return PEAR::raiseError(
  152.                     sprintf(FILE_PASSWD_E_INVALID_ENC_MODE_STR, $nt_or_lm),
  153.                     FILE_PASSWD_E_INVALID_ENC_MODE
  154.                 );
  155.         }
  156.         return (strToUpper(bin2hex($crypted)) === $real);
  157.     }
  158.     
  159.     /**
  160.     * Parse smbpasswd file
  161.     *
  162.     * Returns a PEAR_Error if passwd file has invalid format.
  163.     * 
  164.     * @access public
  165.     * @return mixed   true on success or PEAR_Error
  166.     */    
  167.     function parse()
  168.     {
  169.         foreach ($this->_contents as $line){
  170.             $info = explode(':', $line);
  171.             if (count($info) < 4) {
  172.                 return PEAR::raiseError(
  173.                     FILE_PASSWD_E_INVALID_FORMAT_STR,
  174.                     FILE_PASSWD_E_INVALID_FORMAT
  175.                 );
  176.             }
  177.             $user = array_shift($info);
  178.             if (!empty($user)) {
  179.                 array_walk($info, 'trim');
  180.                 $this->_users[$user] = @array(
  181.                     'userid'    => $info[0],
  182.                     'lmhash'    => $info[1],
  183.                     'nthash'    => $info[2],
  184.                     'flags'     => $info[3],
  185.                     'lct'       => $info[4],
  186.                     'comment'   => $info[5]
  187.                 );
  188.             }
  189.         }
  190.         $this->_contents = array();
  191.         return true; 
  192.     }
  193.     
  194.     /**
  195.     * Add a user
  196.     *
  197.     * Returns a PEAR_Error if:
  198.     *   o user already exists
  199.     *   o user contains illegal characters
  200.     *
  201.     * @throws PEAR_Error
  202.     * @return mixed true on success or PEAR_Error
  203.     * @access public
  204.     * @param  string    $user       the user to add
  205.     * @param  string    $pass       the new plaintext password
  206.     * @param  array     $params     additional properties of user
  207.     *                                + userid
  208.     *                                + comment
  209.     * @param  boolean   $isMachine  whether to add an machine account
  210.     */
  211.     function addUser($user, $pass, $params, $isMachine = false)
  212.     {
  213.         if ($this->userExists($user)) {
  214.             return PEAR::raiseError(
  215.                 sprintf(FILE_PASSWD_E_EXISTS_ALREADY_STR, 'User ', $user),
  216.                 FILE_PASSWD_E_EXISTS_ALREADY
  217.             );
  218.         }
  219.         if (!preg_match($this->_pcre, $user)) {
  220.             return PEAR::raiseError(
  221.                 sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
  222.                 FILE_PASSWD_E_INVALID_CHARS
  223.             );
  224.         }
  225.         if ($isMachine) {
  226.             $flags = '[W           ]';
  227.             $user .= '$';
  228.         } else {
  229.             $flags = '[U           ]';
  230.         }
  231.         $this->_users[$user] = array(
  232.             'flags'     => $flags,
  233.             'userid'    => (int)@$params['userid'],
  234.             'comment'   => trim(@$params['comment']),
  235.             'lct'       => 'LCT-' . strToUpper(dechex(time()))
  236.         );
  237.         return $this->changePasswd($user, $pass);
  238.     }
  239.  
  240.     /**
  241.     * Modify a certain user
  242.     * 
  243.     * <b>You should not modify the password with this method 
  244.     * unless it is already encrypted as nthash and lmhash!</b>
  245.     *
  246.     * Returns a PEAR_Error if:
  247.     *   o user doesn't exist
  248.     *   o an invalid property was supplied
  249.     * 
  250.     * @throws PEAR_Error
  251.     * @access public
  252.     * @return mixed true on success or PEAR_Error
  253.     * @param  string    $user   the user to modify
  254.     * @param  array     $params an associative array of properties to change
  255.     */
  256.     function modUser($user, $params)
  257.     {
  258.         if (!$this->userExists($user)) {
  259.             return PEAR::raiseError(
  260.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  261.                 FILE_PASSWD_E_EXISTS_NOT
  262.             );
  263.         }
  264.         if (!preg_match($this->_pcre, $user)) {
  265.             return PEAR::raiseError(
  266.                 sprintf(FILE_PASSWD_E_INVALID_CHARS_STR, 'User ', $user),
  267.                 FILE_PASSWD_E_INVALID_CHARS
  268.             );
  269.         }
  270.         foreach ($params as $key => $value){
  271.             $key = strToLower($key);
  272.             if (!isset($this->_users[$user][$key])) {
  273.                 return PEAR::raiseError(
  274.                     sprintf(FILE_PASSWD_E_INVALID_PROPERTY_STR, $key),
  275.                     FILE_PASSWD_E_INVALID_PROPERTY
  276.                 );
  277.             }
  278.             $this->_users[$user][$key] = trim($value);
  279.             $this->_users[$user]['lct']= 'LCT-' . strToUpper(dechex(time()));
  280.         }
  281.         return true;
  282.     }
  283.  
  284.     /**
  285.     * Change the passwd of a certain user
  286.     *
  287.     * Returns a PEAR_Error if <var>$user</var> doesn't exist.
  288.     * 
  289.     * @throws PEAR_Error
  290.     * @access public
  291.     * @return mixed true on success or PEAR_Error
  292.     * @param  string    $user   the user whose passwd should be changed
  293.     * @param  string    $pass   the new plaintext passwd
  294.     */
  295.     function changePasswd($user, $pass)
  296.     {
  297.         if (!$this->userExists($user)) {
  298.             return PEAR::raiseError(
  299.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  300.                 FILE_PASSWD_E_EXISTS_NOT
  301.             );
  302.         }
  303.         if (empty($pass)) {
  304.             $nthash = $lmhash = 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
  305.         } else {
  306.             $nthash = strToUpper(bin2hex($this->msc->ntPasswordHash($pass)));
  307.             $lmhash = strToUpper(bin2hex($this->msc->lmPasswordHash($pass)));
  308.         }
  309.         $this->_users[$user]['nthash'] = $nthash;
  310.         $this->_users[$user]['lmhash'] = $lmhash;
  311.         return true;
  312.     }
  313.     
  314.     /**
  315.     * Verifies a user's password
  316.     * 
  317.     * Prefer NT-Hash instead of weak LAN-Manager-Hash
  318.     *
  319.     * Returns a PEAR_Error if:
  320.     *   o user doesn't exist
  321.     *   o user is disabled
  322.     *
  323.     * @return mixed true if passwds equal, false if they don't or PEAR_Error
  324.     * @access public        
  325.     * @param string $user       username
  326.     * @param string $nthash     NT-Hash in hex
  327.     * @param string $lmhash     LAN-Manager-Hash in hex
  328.     */
  329.     function verifyEncryptedPasswd($user, $nthash, $lmhash = '')
  330.     {
  331.         if (!$this->userExists($user)) {
  332.             return PEAR::raiseError(
  333.                 sprintf(FILE_PASSWD_E_EXISTS_NOT_STR, 'User ', $user),
  334.                 FILE_PASSWD_E_EXISTS_NOT
  335.             );
  336.         }
  337.         if (strstr($this->_users[$user]['flags'], 'D')) {
  338.             return PEAR::raiseError("User '$user' is disabled.", 0);
  339.         }
  340.         if (!empty($nthash)) {
  341.             return $this->_users[$user]['nthash'] === strToUpper($nthash);
  342.         }
  343.         if (!empty($lmhash)) {
  344.             return $this->_users[$user]['lm'] === strToUpper($lmhash);
  345.         }
  346.         return false;
  347.     }
  348.  
  349.     /**
  350.     * Verifies an account with the given plaintext password
  351.     *
  352.     * Returns a PEAR_Error if:
  353.     *   o user doesn't exist
  354.     *   o user is disabled
  355.     *
  356.     * @throws PEAR_Error
  357.     * @return mixed     true if passwds equal, false if they don't or PEAR_Error
  358.     * @access public        
  359.     * @param  string    $user username
  360.     * @param  string    $pass the plaintext password
  361.     */
  362.     function verifyPasswd($user, $pass)
  363.     {
  364.         $nthash = bin2hex($this->msc->ntPasswordHash($pass));
  365.         $lmhash = bin2hex($this->msc->lmPasswordHash($pass));
  366.         return $this->verifyEncryptedPasswd($user, $nthash, $lmhash);
  367.     }
  368.  
  369.     /**
  370.     * Apply changes and rewrite CVS passwd file
  371.     *
  372.     * Returns a PEAR_Error if:
  373.     *   o directory in which the file should reside couldn't be created
  374.     *   o file couldn't be opened in write mode
  375.     *   o file couldn't be locked exclusively
  376.     *   o file couldn't be unlocked
  377.     *   o file couldn't be closed
  378.     * 
  379.     * @throws PEAR_Error
  380.     * @access public
  381.     * @return mixed true on success or PEAR_Error
  382.     */
  383.     function save()
  384.     {
  385.         $content = '';
  386.         foreach ($this->_users as $user => $userdata) {
  387.             $content .= $user . ':' .
  388.                         $userdata['userid'] . ':' .
  389.                         $userdata['lmhash'] . ':' .
  390.                         $userdata['nthash'] . ':' .
  391.                         $userdata['flags']  . ':' .
  392.                         $userdata['lct']    . ':' .
  393.                         $userdata['comment']. "\n";
  394.         }
  395.         return $this->_save($content);
  396.     }
  397.     
  398.     /**
  399.     * Generate Password
  400.     *
  401.     * @static
  402.     * @access   public
  403.     * @return   string  The crypted password.
  404.     * @param    string  $pass The plaintext password.
  405.     * @param    string  $mode The encryption mode to use (nt|lm).
  406.     */
  407.     function generatePassword($pass, $mode = 'nt')
  408.     {
  409.         $chap = &new Crypt_CHAP_MSv1;
  410.         $hash = strToLower($mode) == 'nt' ? 
  411.             $chap->ntPasswordHash($pass) :
  412.             $chap->lmPasswordHash($pass);
  413.         return strToUpper(bin2hex($hash));
  414.     }
  415.     
  416. }
  417. ?>
  418.