Support Joomla!

Joomla! 1.5 Documentation

Packages

Package: Joomla-Framework

Developer Network License

The Joomla! Developer Network content is © copyright 2006 by the individual contributors and can be used in accordance with the Creative Commons License, Attribution- NonCommercial- ShareAlike 2.5
Source code for file /joomla/user/helper.php

Documentation is available at helper.php

  1. <?php
  2. /**
  3. * @version        $Id: authenticate.php 6257 2007-01-11 22:03:46Z friesengeist $
  4. * @package        Joomla.Framework
  5. * @subpackage    User
  6. * @copyright    Copyright (C) 2005 - 2007 Open Source Matters. All rights reserved.
  7. * @license        GNU/GPL, see LICENSE.php
  8. *  Joomla! is free software. This version may have been modified pursuant
  9. *  to the GNU General Public License, and as distributed it includes or
  10. *  is derivative of works licensed under the GNU General Public License or
  11. *  other free or open source software licenses.
  12. *  See COPYRIGHT.php for copyright notices and details.
  13. */
  14.  
  15. /**
  16.  * Authorization helper class, provides static methods to perform various tasks relevant
  17.  * to the Joomla user and authorization classes
  18.  *
  19.  * This class has influences and some method logic from the Horde Auth package
  20.  *
  21.  * @static
  22.  * @author         Louis Landry <[email protected]>
  23.  * @package     Joomla.Framework
  24.  * @subpackage    User
  25.  * @since        1.5
  26.  */
  27. class JUserHelper
  28. {
  29.     /**
  30.      * Method to activate a user
  31.      *
  32.      * @param    string    $activation    Activation string
  33.      * @return     boolean             True on success
  34.      * @since    1.5
  35.      */
  36.     function activateUser($activation)
  37.     {
  38.         //Initialize some variables
  39.         $db = & JFactory::getDBO();
  40.  
  41.         // Lets get the id of the user we want to activate
  42.         $query = 'SELECT id'
  43.         . ' FROM #__users'
  44.         . ' WHERE activation = "'.$activation.'"'
  45.         . ' AND block = 1'
  46.         ;
  47.         $db->setQuery( $query );
  48.         $id = intval( $db->loadResult() );
  49.  
  50.         // Is it a valid user to activate?
  51.         if ($id)
  52.         {
  53.             $user =& JUser::getInstance( (int) $id );
  54.  
  55.             $user->set('block', '0');
  56.             $user->set('activation', '');
  57.  
  58.             // Time to take care of business.... store the user.
  59.             if (!$user->save())
  60.             {
  61.                 JError::raiseWarning( "SOME_ERROR_CODE", $user->getError() );
  62.                 return false;
  63.             }
  64.         }
  65.         else
  66.         {
  67.             JError::raiseWarning( "SOME_ERROR_CODE", JText::_('Unable to find a user with given activation string.') );
  68.             return false;
  69.         }
  70.  
  71.         return true;
  72.     }
  73.  
  74.     /**
  75.      * Returns userid if a user exists
  76.      *
  77.      * @param string The username to search on
  78.      * @return int The user id or 0 if not found
  79.      */
  80.     function getUserId($username)
  81.     {
  82.         // Initialize some variables
  83.         $db = & JFactory::getDBO();
  84.  
  85.         $query = 'SELECT id FROM #__users WHERE username = ' . $db->Quote( $username );
  86.         $db->setQuery($query, 0, 1);
  87.         return $db->loadResult();
  88.     }
  89.  
  90.     /**
  91.      * Formats a password using the current encryption.
  92.      *
  93.      * @access    public
  94.      * @param    string    $plaintext    The plaintext password to encrypt.
  95.      * @param    string    $salt        The salt to use to encrypt the password. []
  96.      *                                 If not present, a new salt will be
  97.      *                                 generated.
  98.      * @param    string    $encryption    The kind of pasword encryption to use.
  99.      *                                 Defaults to md5-hex.
  100.      * @param    boolean    $show_encrypt  Some password systems prepend the kind of
  101.      *                                 encryption to the crypted password ({SHA},
  102.      *                                 etc). Defaults to false.
  103.      *
  104.      * @return string  The encrypted password.
  105.      */
  106.     function getCryptedPassword($plaintext, $salt = '', $encryption = 'md5-hex', $show_encrypt = false)
  107.     {
  108.         // Get the salt to use.
  109.         $salt = JUserHelper::getSalt($encryption, $salt, $plaintext);
  110.  
  111.         // Encrypt the password.
  112.         switch ($encryption)
  113.         {
  114.             case 'plain' :
  115.                 return $plaintext;
  116.  
  117.             case 'sha' :
  118.                 $encrypted = base64_encode(mhash(MHASH_SHA1, $plaintext));
  119.                 return ($show_encrypt) ? '{SHA}'.$encrypted : $encrypted;
  120.  
  121.             case 'crypt' :
  122.             case 'crypt-des' :
  123.             case 'crypt-md5' :
  124.             case 'crypt-blowfish' :
  125.                 return ($show_encrypt ? '{crypt}' : '').crypt($plaintext, $salt);
  126.  
  127.             case 'md5-base64' :
  128.                 $encrypted = base64_encode(mhash(MHASH_MD5, $plaintext));
  129.                 return ($show_encrypt) ? '{MD5}'.$encrypted : $encrypted;
  130.  
  131.             case 'ssha' :
  132.                 $encrypted = base64_encode(mhash(MHASH_SHA1, $plaintext.$salt).$salt);
  133.                 return ($show_encrypt) ? '{SSHA}'.$encrypted : $encrypted;
  134.  
  135.             case 'smd5' :
  136.                 $encrypted = base64_encode(mhash(MHASH_MD5, $plaintext.$salt).$salt);
  137.                 return ($show_encrypt) ? '{SMD5}'.$encrypted : $encrypted;
  138.  
  139.             case 'aprmd5' :
  140.                 $length = strlen($plaintext);
  141.                 $context = $plaintext.'$apr1$'.$salt;
  142.                 $binary = JUserHelper::_bin(md5($plaintext.$salt.$plaintext));
  143.  
  144.                 for ($i = $length; $i > 0; $i -= 16) {
  145.                     $context .= substr($binary, 0, ($i > 16 ? 16 : $i));
  146.                 }
  147.                 for ($i = $length; $i > 0; $i >>= 1) {
  148.                     $context .= ($i & 1) ? chr(0) : $plaintext[0];
  149.                 }
  150.  
  151.                 $binary = JUserHelper::_bin(md5($context));
  152.  
  153.                 for ($i = 0; $i < 1000; $i ++) {
  154.                     $new = ($i & 1) ? $plaintext : substr($binary, 0, 16);
  155.                     if ($i % 3) {
  156.                         $new .= $salt;
  157.                     }
  158.                     if ($i % 7) {
  159.                         $new .= $plaintext;
  160.                     }
  161.                     $new .= ($i & 1) ? substr($binary, 0, 16) : $plaintext;
  162.                     $binary = JUserHelper::_bin(md5($new));
  163.                 }
  164.  
  165.                 $p = array ();
  166.                 for ($i = 0; $i < 5; $i ++) {
  167.                     $k = $i +6;
  168.                     $j = $i +12;
  169.                     if ($j == 16) {
  170.                         $j = 5;
  171.                     }
  172.                     $p[] = JUserHelper::_toAPRMD5((ord($binary[$i]) << 16) | (ord($binary[$k]) << 8) | (ord($binary[$j])), 5);
  173.                 }
  174.  
  175.                 return '$apr1$'.$salt.'$'.implode('', $p).JUserHelper::_toAPRMD5(ord($binary[11]), 3);
  176.  
  177.             case 'md5-hex' :
  178.             default :
  179.                 return ($show_encrypt) ? '{MD5}'.md5($plaintext) : md5($plaintext);
  180.         }
  181.     }
  182.  
  183.     /**
  184.      * Returns a salt for the appropriate kind of password encryption.
  185.      * Optionally takes a seed and a plaintext password, to extract the seed
  186.      * of an existing password, or for encryption types that use the plaintext
  187.      * in the generation of the salt.
  188.      *
  189.      * @access public
  190.      * @param string $encryption  The kind of pasword encryption to use.
  191.      *                             Defaults to md5-hex.
  192.      * @param string $seed        The seed to get the salt from (probably a
  193.      *                             previously generated password). Defaults to
  194.      *                             generating a new seed.
  195.      * @param string $plaintext   The plaintext password that we're generating
  196.      *                             a salt for. Defaults to none.
  197.      *
  198.      * @return string  The generated or extracted salt.
  199.      */
  200.     function getSalt($encryption = 'md5-hex', $seed = '', $plaintext = '')
  201.     {
  202.         // Encrypt the password.
  203.         switch ($encryption)
  204.         {
  205.             case 'crypt' :
  206.             case 'crypt-des' :
  207.                 if ($seed) {
  208.                     return substr(preg_replace('|^{crypt}|i', '', $seed), 0, 2);
  209.                 } else {
  210.                     return substr(md5(mt_rand()), 0, 2);
  211.                 }
  212.  
  213.             case 'crypt-md5' :
  214.                 if ($seed) {
  215.                     return substr(preg_replace('|^{crypt}|i', '', $seed), 0, 12);
  216.                 } else {
  217.                     return '$1$'.substr(md5(mt_rand()), 0, 8).'$';
  218.                 }
  219.  
  220.             case 'crypt-blowfish' :
  221.                 if ($seed) {
  222.                     return substr(preg_replace('|^{crypt}|i', '', $seed), 0, 16);
  223.                 } else {
  224.                     return '$2$'.substr(md5(mt_rand()), 0, 12).'$';
  225.                 }
  226.  
  227.             case 'ssha' :
  228.                 if ($seed) {
  229.                     return substr(preg_replace('|^{SSHA}|', '', $seed), -20);
  230.                 } else {
  231.                     return mhash_keygen_s2k(MHASH_SHA1, $plaintext, substr(pack('h*', md5(mt_rand())), 0, 8), 4);
  232.                 }
  233.  
  234.             case 'smd5' :
  235.                 if ($seed) {
  236.                     return substr(preg_replace('|^{SMD5}|', '', $seed), -16);
  237.                 } else {
  238.                     return mhash_keygen_s2k(MHASH_MD5, $plaintext, substr(pack('h*', md5(mt_rand())), 0, 8), 4);
  239.                 }
  240.  
  241.             case 'aprmd5' :
  242.                 /* 64 characters that are valid for APRMD5 passwords. */
  243.                 $APRMD5 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
  244.  
  245.                 if ($seed) {
  246.                     return substr(preg_replace('/^\$apr1\$(.{8}).*/', '\\1', $seed), 0, 8);
  247.                 } else {
  248.                     $salt = '';
  249.                     for ($i = 0; $i < 8; $i ++) {
  250.                         $salt .= $APRMD5 {
  251.                             rand(0, 63)
  252.                             };
  253.                     }
  254.                     return $salt;
  255.                 }
  256.  
  257.             default :
  258.                 return '';
  259.         }
  260.     }
  261.  
  262.     /**
  263.      * Generate a random password
  264.      *
  265.      * @static
  266.      * @param    int        $length    Length of the password to generate
  267.      * @return    string            Random Password
  268.      * @since    1.5
  269.      */
  270.     function genRandomPassword($length = 8)
  271.     {
  272.         $salt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  273.         $len = strlen($salt);
  274.         $makepass = '';
  275.         mt_srand(10000000 * (double) microtime());
  276.  
  277.         for ($i = 0; $i < $length; $i ++) {
  278.             $makepass .= $salt[mt_rand(0, $len -1)];
  279.         }
  280.  
  281.         return $makepass;
  282.     }
  283.  
  284.     /**
  285.      * Converts to allowed 64 characters for APRMD5 passwords.
  286.      *
  287.      * @access private
  288.      * @param string  $value 
  289.      * @param integer $count 
  290.      * @return string  $value converted to the 64 MD5 characters.
  291.      * @since 1.5
  292.      */
  293.     function _toAPRMD5($value, $count)
  294.     {
  295.         /* 64 characters that are valid for APRMD5 passwords. */
  296.         $APRMD5 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
  297.  
  298.         $aprmd5 = '';
  299.         $count = abs($count);
  300.         while (-- $count) {
  301.             $aprmd5 .= $APRMD5[$value & 0x3f];
  302.             $value >>= 6;
  303.         }
  304.         return $aprmd5;
  305.     }
  306.  
  307.     /**
  308.      * Converts hexadecimal string to binary data.
  309.      *
  310.      * @access private
  311.      * @param string $hex  Hex data.
  312.      * @return string  Binary data.
  313.      * @since 1.5
  314.      */
  315.     function _bin($hex)
  316.     {
  317.         $bin = '';
  318.         $length = strlen($hex);
  319.         for ($i = 0; $i < $length; $i += 2) {
  320.             $tmp = sscanf(substr($hex, $i, 2), '%x');
  321.             $bin .= chr(array_shift($tmp));
  322.         }
  323.         return $bin;
  324.     }
  325. }
  326.  
  327. ?>
Documentation generated on Mon, 05 Mar 2007 21:05:44 +0000 by phpDocumentor 1.3.1