[TASK] Clean up phpDoc comments in typo3/sysext/saltedpasswords
authorWouter Wolters <typo3@wouterwolters.nl>
Fri, 22 Jun 2012 18:41:51 +0000 (20:41 +0200)
committerChristian Kuhn <lolli@schwarzbu.ch>
Fri, 22 Jun 2012 19:27:53 +0000 (21:27 +0200)
Clean up provides:

* Provide correct parameter names in phpDoc
* Provide correct data types in phpDoc
* CGLify phpDoc (remove tabs)

Change-Id: If173ab6ad75f17f41826ec5dc4f32ca378909193
Resolves: #38318
Releases: 6.0
Reviewed-on: http://review.typo3.org/12300
Reviewed-by: Christian Kuhn
Tested-by: Christian Kuhn
21 files changed:
typo3/sysext/saltedpasswords/classes/class.tx_saltedpasswords_autoloader.php
typo3/sysext/saltedpasswords/classes/class.tx_saltedpasswords_div.php
typo3/sysext/saltedpasswords/classes/class.tx_saltedpasswords_emconfhelper.php
typo3/sysext/saltedpasswords/classes/eval/class.tx_saltedpasswords_eval.php
typo3/sysext/saltedpasswords/classes/eval/class.tx_saltedpasswords_eval_be.php
typo3/sysext/saltedpasswords/classes/eval/class.tx_saltedpasswords_eval_fe.php
typo3/sysext/saltedpasswords/classes/salts/class.tx_saltedpasswords_abstract_salts.php
typo3/sysext/saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_blowfish.php
typo3/sysext/saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_factory.php
typo3/sysext/saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_md5.php
typo3/sysext/saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_phpass.php
typo3/sysext/saltedpasswords/classes/salts/interfaces/interface.tx_saltedpasswords_salts.php
typo3/sysext/saltedpasswords/classes/tasks/class.tx_saltedpasswords_tasks_bulkupdate.php
typo3/sysext/saltedpasswords/ext_localconf.php
typo3/sysext/saltedpasswords/ext_tables.php
typo3/sysext/saltedpasswords/sv1/class.tx_saltedpasswords_sv1.php
typo3/sysext/saltedpasswords/tests/tx_saltedpasswords_divTest.php
typo3/sysext/saltedpasswords/tests/tx_saltedpasswords_salts_blowfishTest.php
typo3/sysext/saltedpasswords/tests/tx_saltedpasswords_salts_factoryTest.php
typo3/sysext/saltedpasswords/tests/tx_saltedpasswords_salts_md5Test.php
typo3/sysext/saltedpasswords/tests/tx_saltedpasswords_salts_phpassTest.php

index 18bb3f3..b681c88 100644 (file)
@@ -134,7 +134,7 @@ class tx_saltedpasswords_autoloader {
 
 }
 
-// Make instance:
+       // Make instance:
 $SOBE = t3lib_div::makeInstance('tx_saltedpasswords_autoloader');
 $SOBE->execute($this);
 ?>
\ No newline at end of file
index e94fd9c..2e31e51 100644 (file)
 /**
  * General library class.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
- * @author             Steffen Ritter <info@rs-websystems.de>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since       2009-06-14
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-06-14
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_div {
-               /**
-                * Keeps this extension's key.
-                */
-               const EXTKEY = 'saltedpasswords';
+       /**
+        * Keeps this extension's key.
+        */
+       const EXTKEY = 'saltedpasswords';
 
-               /**
-                * Calculates number of backend users, who have no saltedpasswords
-                * protection.
-                *
-                * @static
-                * @return int
-                */
-               public static function getNumberOfBackendUsersWithInsecurePassword() {
-                       $userCount = $GLOBALS['TYPO3_DB']->exec_SELECTcountRows(
-                               '*',
-                               'be_users',
-                               'password NOT LIKE ' . $GLOBALS['TYPO3_DB']->fullQuoteStr('$%', 'be_users')
-                                       . ' AND password NOT LIKE ' . $GLOBALS['TYPO3_DB']->fullQuoteStr('M$%', 'be_users')
-                       );
-                       return $userCount;
-               }
+       /**
+        * Calculates number of backend users, who have no saltedpasswords
+        * protection.
+        *
+        * @return integer
+        */
+       public static function getNumberOfBackendUsersWithInsecurePassword() {
+               $userCount = $GLOBALS['TYPO3_DB']->exec_SELECTcountRows(
+                       '*',
+                       'be_users',
+                       'password NOT LIKE ' . $GLOBALS['TYPO3_DB']->fullQuoteStr('$%', 'be_users')
+                               . ' AND password NOT LIKE ' . $GLOBALS['TYPO3_DB']->fullQuoteStr('M$%', 'be_users')
+               );
+               return $userCount;
+       }
 
-               /**
-                * Returns extension configuration data from $TYPO3_CONF_VARS (configurable in Extension Manager)
-                *
-                * @author  Rainer Kuhn <kuhn@punkt.de>
-                * @author  Marcus Krause <marcus#exp2009@t3sec.info>
-                *
-                * @param       string          TYPO3_MODE, wether Configuration for Frontend or Backend should be delivered
-                * @return      array           extension configuration data
-                */
-               public static function returnExtConf($mode = TYPO3_MODE) {
-                       $currentConfiguration = self::returnExtConfDefaults();
+       /**
+        * Returns extension configuration data from $TYPO3_CONF_VARS (configurable in Extension Manager)
+        *
+        * @author Rainer Kuhn <kuhn@punkt.de>
+        * @author Marcus Krause <marcus#exp2009@t3sec.info>
+        *
+        * @param string $mode TYPO3_MODE, wether Configuration for Frontend or Backend should be delivered
+        * @return array Extension configuration data
+        */
+       public static function returnExtConf($mode = TYPO3_MODE) {
+               $currentConfiguration = self::returnExtConfDefaults();
 
-                       if (isset($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['saltedpasswords'])) {
-                               $extensionConfiguration = unserialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['saltedpasswords']);
+               if (isset($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['saltedpasswords'])) {
+                       $extensionConfiguration = unserialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['saltedpasswords']);
 
-                                       // Merge default configuration with modified configuration:
-                               if (isset($extensionConfiguration[$mode . '.'])) {
-                                       $currentConfiguration = array_merge(
-                                               $currentConfiguration,
-                                               $extensionConfiguration[$mode . '.']
-                                       );
-                               }
+                               // Merge default configuration with modified configuration:
+                       if (isset($extensionConfiguration[$mode . '.'])) {
+                               $currentConfiguration = array_merge(
+                                       $currentConfiguration,
+                                       $extensionConfiguration[$mode . '.']
+                               );
                        }
-
-                       return $currentConfiguration;
                }
 
-               /**
-                * Hook function for felogin "forgotPassword" functionality
-                * encrypts the new password before storing in database
-                *
-                * @param       array                   $params: Parameter the hook delivers
-                * @param       tx_felogin_pi1  $pObj: Parent Object from which the hook is called
-                * @return      void
-                *
-                */
-               public function feloginForgotPasswordHook(array &$params, tx_felogin_pi1 $pObj) {
-                       if (self::isUsageEnabled('FE')) {
-                               $this->objInstanceSaltedPW = tx_saltedpasswords_salts_factory::getSaltingInstance();
-                               $params['newPassword'] = $this->objInstanceSaltedPW->getHashedPassword($params['newPassword']);
-                       }
-               }
+               return $currentConfiguration;
+       }
 
-               /**
-                * Returns default configuration of this extension.
-                *
-                * @return      array           default extension configuration data for localconf.php
-                */
-               public static function returnExtConfDefaults() {
-                       return array(
-                               'onlyAuthService' => '0',
-                               'forceSalted' => '0',
-                               'updatePasswd' => '1',
-                               'saltedPWHashingMethod' => 'tx_saltedpasswords_salts_phpass',
-                               'enabled' => '1',
-                       );
+       /**
+        * Hook function for felogin "forgotPassword" functionality
+        * encrypts the new password before storing in database
+        *
+        * @param array $params Parameter the hook delivers
+        * @param tx_felogin_pi1 $pObj Parent Object from which the hook is called
+        * @return void
+        *
+        */
+       public function feloginForgotPasswordHook(array &$params, tx_felogin_pi1 $pObj) {
+               if (self::isUsageEnabled('FE')) {
+                       $this->objInstanceSaltedPW = tx_saltedpasswords_salts_factory::getSaltingInstance();
+                       $params['newPassword'] = $this->objInstanceSaltedPW->getHashedPassword($params['newPassword']);
                }
+       }
 
-               /**
-                * Function determines the default(=configured) type of
-                * salted hashing method to be used.
-                *
-                * @param       string          $mode: (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
-                * @return      string          classname of object to be used
-                */
-               public static function getDefaultSaltingHashingMethod($mode = TYPO3_MODE) {
+       /**
+        * Returns default configuration of this extension.
+        *
+        * @return array Default extension configuration data for localconf.php
+        */
+       public static function returnExtConfDefaults() {
+               return array(
+                       'onlyAuthService' => '0',
+                       'forceSalted' => '0',
+                       'updatePasswd' => '1',
+                       'saltedPWHashingMethod' => 'tx_saltedpasswords_salts_phpass',
+                       'enabled' => '1',
+               );
+       }
 
-                       $extConf = self::returnExtConf($mode);
-                       $classNameToUse = 'tx_saltedpasswords_salts_md5';
-                       if (in_array($extConf['saltedPWHashingMethod'], array_keys($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/saltedpasswords']['saltMethods']))) {
-                               $classNameToUse = $extConf['saltedPWHashingMethod'];
-                       }
+       /**
+        * Function determines the default(=configured) type of
+        * salted hashing method to be used.
+        *
+        * @param string $mode (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
+        * @return string Classname of object to be used
+        */
+       public static function getDefaultSaltingHashingMethod($mode = TYPO3_MODE) {
 
-                       return $classNameToUse;
+               $extConf = self::returnExtConf($mode);
+               $classNameToUse = 'tx_saltedpasswords_salts_md5';
+               if (in_array($extConf['saltedPWHashingMethod'], array_keys($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/saltedpasswords']['saltMethods']))) {
+                       $classNameToUse = $extConf['saltedPWHashingMethod'];
                }
 
-               /**
-                * Returns information if salted password hashes are
-                * indeed used in the TYPO3_MODE.
-                *
-                * @param       string          $mode: (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
-                * @return      boolean         TRUE, if salted password hashes are used in the TYPO3_MODE, otherwise FALSE
-                */
-               public static function isUsageEnabled($mode = TYPO3_MODE) {
-                               // Login Security Level Recognition
-                       $extConf = self::returnExtConf($mode);
-                       $securityLevel = $GLOBALS['TYPO3_CONF_VARS'][$mode]['loginSecurityLevel'];
-                       if ($mode == 'BE' && $extConf['enabled']) {
-                               return (($securityLevel =='normal' && $GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] > 0) || $securityLevel == 'rsa');
-                       } elseif ($mode =='FE' && $extConf['enabled']) {
-                               return t3lib_div::inList('normal,rsa', $securityLevel);
-                       }
+               return $classNameToUse;
+       }
 
-                       return FALSE;
+       /**
+        * Returns information if salted password hashes are
+        * indeed used in the TYPO3_MODE.
+        *
+        * @param string $mode (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
+        * @return boolean TRUE, if salted password hashes are used in the TYPO3_MODE, otherwise FALSE
+        */
+       public static function isUsageEnabled($mode = TYPO3_MODE) {
+                       // Login Security Level Recognition
+               $extConf = self::returnExtConf($mode);
+               $securityLevel = $GLOBALS['TYPO3_CONF_VARS'][$mode]['loginSecurityLevel'];
+               if ($mode == 'BE' && $extConf['enabled']) {
+                       return (($securityLevel =='normal' && $GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] > 0) || $securityLevel == 'rsa');
+               } elseif ($mode =='FE' && $extConf['enabled']) {
+                       return t3lib_div::inList('normal,rsa', $securityLevel);
                }
+
+               return FALSE;
+       }
 }
 
 ?>
\ No newline at end of file
index ff1cb43..d414282 100644 (file)
 *  This copyright notice MUST APPEAR in all copies of the script!
 ***************************************************************/
        // Make sure that we are executed only in TYPO3 context
-if (!defined ('TYPO3_MODE')) die ('Access denied.');
-
+if (!defined('TYPO3_MODE')) {
+       die('Access denied.');
+}
 
 /**
  * class providing configuration checks for saltedpasswords.
  *
- * @author     Steffen Ritter <info@rs-websystems.de>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since      2009-09-04
- * @package    TYPO3
- * @subpackage tx_saltedpasswords
+ * @since 2009-09-04
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_emconfhelper {
        /**
-        * @var integer
+        * @var integer
         */
        protected $errorType = t3lib_FlashMessage::OK;
 
        /**
-        * @var string
+        * @var string
         */
        protected $header;
 
        /**
-        * @var string
+        * @var string
         */
        protected $preText;
 
-       /*
-        * @var array
+       /**
+        * @var array
         */
        protected $problems = array();
 
@@ -62,8 +63,8 @@ class tx_saltedpasswords_emconfhelper {
         * Set the error level if no higher level
         * is set already
         *
-        * @param       string          $level: one out of error, ok, warning, info
-        * @return      void
+        * @param string $level One out of error, ok, warning, info
+        * @return void
         */
        private function setErrorLevel($level) {
 
@@ -101,11 +102,11 @@ class tx_saltedpasswords_emconfhelper {
        /**
         * Renders the flash messages if problems have been found.
         *
-        * @return      string          The flash message as HTML.
+        * @return string The flash message as HTML.
         */
        private function renderFlashMessage() {
                $message = '';
-                       // if there are problems, render them into an unordered list
+                       // If there are problems, render them into an unordered list
                if (count($this->problems) > 0) {
                        $message = <<< EOT
 <ul>
@@ -149,15 +150,15 @@ EOT;
        /**
         * Checks the backend configuration and shows a message if necessary.
         *
-        * @param       array                           $params: Field information to be rendered
-        * @param       t3lib_tsStyleConfig     $pObj: The calling parent object.
-        * @return      string                          Messages as HTML if something needs to be reported
+        * @param array $params Field information to be rendered
+        * @param t3lib_tsStyleConfig $pObj The calling parent object.
+        * @return string Messages as HTML if something needs to be reported
         */
        public function checkConfigurationBackend(array $params, t3lib_tsStyleConfig $pObj) {
                $this->init();
                $extConf = $this->extConf['BE'];
 
-                       // the backend is called over SSL
+                       // The backend is called over SSL
                $SSL = (($GLOBALS['TYPO3_CONF_VARS']['BE']['lockSSL'] > 0 ? TRUE : FALSE) && ($GLOBALS['TYPO3_CONF_VARS']['BE']['loginSecurityLevel'] != 'superchallenged'));
                $rsaAuthLoaded = t3lib_extMgm::isLoaded('rsaauth');
 
@@ -172,14 +173,14 @@ EOT;
                                                $this->setErrorLevel('ok');
                                                $problems[] = 'The backend is configured to use SaltedPasswords with RSA authentication.';
                                        } else {
-                                                       // this means that login would fail because rsaauth is not working properly
+                                                       // This means that login would fail because rsaauth is not working properly
                                                $this->setErrorLevel('error');
                                                $problems[] = '<strong>Using the extension "rsaauth" is not possible, as no encryption backend ' .
                                                                        'is available. Please install and configure the PHP extension "openssl". '.
                                                                        'See <a href="http://php.net/manual/en/openssl.installation.php" target="_blank">PHP.net</a></strong>.';
                                        }
                                } else {
-                                               // this means that we are not using saltedpasswords
+                                               // This means that we are not using saltedpasswords
                                        $this->setErrorLevel('error');
                                        $problems[] = 'The "rsaauth" extension is installed, but TYPO3 is not configured to use it during login.
                                                Use the Install Tool to set the Login Security Level for the backend to "rsa"
@@ -187,7 +188,7 @@ EOT;
 
                                }
                        } else {
-                                       // this means that we are not using saltedpasswords
+                                       // This means that we are not using saltedpasswords
                                $this->setErrorLevel('error');
                                $problems[] = <<< EOT
 Backend requirements for SaltedPasswords are not met, therefore the
@@ -211,9 +212,9 @@ time.
 EOT;
                        }
 
-                               // only saltedpasswords as authsservice
+                               // Only saltedpasswords as authsservice
                        if ($extConf['onlyAuthService']) {
-                                       // warn user that the combination with "forceSalted" may lock him out from Backend
+                                       // Warn user that the combination with "forceSalted" may lock him out from Backend
                                if ($extConf['forceSalted']) {
                                        $this->setErrorLevel('warning');
                                        $problems[] = <<< EOT
@@ -224,7 +225,7 @@ password hash.<br />
 <strong><i>WARNING:</i></strong> This may lock you out of the backend!
 EOT;
                                } else {
-                                               // inform the user that things like openid won't work anymore
+                                               // Inform the user that things like openid won't work anymore
                                        $this->setErrorLevel('info');
                                        $problems[] = <<< EOT
 SaltedPasswords has been configured to be the only authentication service for
@@ -254,7 +255,7 @@ It is not possible to set "updatePasswd" and "forceSalted" at the same time.
 Please disable either one of them.
 EOT;
                        }
-                               // check if the configured hash-method is available on system
+                               // Check if the configured hash-method is available on system
                        if (!$instance = tx_saltedpasswords_salts_factory::getSaltingInstance(NULL, 'BE') || !$instance->isAvailable()) {
                                $this->setErrorLevel('error');
                                $problems[] = <<< EOT
@@ -264,7 +265,7 @@ EOT;
                        }
 
                } else {
-                       // not enabled warning
+                               // Not enabled warning
                        $this->setErrorLevel('error');
                        $problems[] = 'SaltedPasswords has been disabled for backend users.';
                }
@@ -277,7 +278,7 @@ EOT;
        /**
         * Checks if rsaauth is able to obtain a backend
         *
-        * @return bool
+        * @return boolean
         */
        protected function isRsaAuthBackendAvailable() {
                /**
@@ -292,16 +293,16 @@ EOT;
        /**
         * Checks the frontend configuration and shows a message if necessary.
         *
-        * @param       array                           $params: Field information to be rendered
-        * @param       t3lib_tsStyleConfig     $pObj: The calling parent object.
-        * @return      string                          Messages as HTML if something needs to be reported
+        * @param array $params Field information to be rendered
+        * @param t3lib_tsStyleConfig $pObj The calling parent object.
+        * @return string Messages as HTML if something needs to be reported
         */
        public function checkConfigurationFrontend(array $params, t3lib_tsStyleConfig $pObj) {
                $this->init();
                $extConf = $this->extConf['FE'];
 
                if ($extConf['enabled']) {
-                               // inform the user if securityLevel in FE is challenged or blank --> extension won't work
+                               // Inform the user if securityLevel in FE is challenged or blank --> extension won't work
                        if (!t3lib_div::inList('normal,rsa', $GLOBALS['TYPO3_CONF_VARS']['FE']['loginSecurityLevel'])) {
                                $this->setErrorLevel('info');
                                $problems[] = <<< EOT
@@ -326,16 +327,16 @@ EOT;
                                        $this->setErrorLevel('ok');
                                        $problems[] = 'The frontend is configured to use SaltedPasswords with RSA authentication.';
                                } else {
-                                               // this means that login would fail because rsaauth is not working properly
+                                               // This means that login would fail because rsaauth is not working properly
                                        $this->setErrorLevel('error');
                                        $problems[] = '<strong>Using the extension "rsaauth" is not possible, as no encryption backend ' .
                                                                'is available. Please install and configure the PHP extension "openssl". '.
                                                                'See <a href="http://php.net/manual/en/openssl.installation.php" target="_blank">PHP.net</a></strong>.';
                                }
                        }
-                               // only saltedpasswords as authsservice
+                               // Only saltedpasswords as authsservice
                        if ($extConf['onlyAuthService']) {
-                                       // warn user taht the combination with "forceSalted" may lock him out from frontend
+                                       // Warn user taht the combination with "forceSalted" may lock him out from frontend
                                if ($extConf['forceSalted']) {
                                        $this->setErrorLevel('warning');
                                        $problems[] = <<< EOT
@@ -347,7 +348,7 @@ login.<br />
 users not having a salted password hash (e.g. existing frontend users).
 EOT;
                                } else {
-                                               // inform the user that things like openid won't work anymore
+                                               // Inform the user that things like openid won't work anymore
                                        $this->setErrorLevel('info');
                                        $problems[] = <<< EOT
 SaltedPasswords has been configured to be the only authentication service for
@@ -380,7 +381,7 @@ EOT;
                        }
 
                } else {
-                       // not enabled warning
+                               // Not enabled warning
                        $this->setErrorLevel('info');
                        $problems[] = 'SaltedPasswords has been disabled for frontend users.';
                }
@@ -393,10 +394,10 @@ EOT;
        /**
         * Renders a selector element that allows to select the hash method to be used.
         *
-        * @param       array                           $params: Field information to be rendered
-        * @param       t3lib_tsStyleConfig     $pObj: The calling parent object.
-        * @param       string                          $disposal: The configuration disposal ('FE' or 'BE')
-        * @return      string                          The HTML selector
+        * @param array $params Field information to be rendered
+        * @param t3lib_tsStyleConfig $pObj The calling parent object.
+        * @param string $disposal The configuration disposal ('FE' or 'BE')
+        * @return string The HTML selector
         */
        protected function buildHashMethodSelector(array $params, t3lib_tsStyleConfig $pObj, $disposal) {
                $this->init();
@@ -423,9 +424,9 @@ EOT;
        /**
         * Renders a selector element that allows to select the hash method to be used (frontend disposal).
         *
-        * @param       array                           $params: Field information to be rendered
-        * @param       t3lib_tsStyleConfig     $pObj: The calling parent object.
-        * @return      string                          The HTML selector
+        * @param array $params Field information to be rendered
+        * @param t3lib_tsStyleConfig $pObj The calling parent object.
+        * @return string The HTML selector
         */
        public function buildHashMethodSelectorFE(array $params, t3lib_tsStyleConfig $pObj) {
                return $this->buildHashMethodSelector($params, $pObj, 'FE');
@@ -434,9 +435,9 @@ EOT;
        /**
         * Renders a selector element that allows to select the hash method to be used (backend disposal)
         *
-        * @param       array                           $params: Field information to be rendered
-        * @param       t3lib_tsStyleConfig     $pObj: The calling parent object.
-        * @return      string                          The HTML selector
+        * @param array $params Field information to be rendered
+        * @param t3lib_tsStyleConfig $pObj The calling parent object.
+        * @return string The HTML selector
         */
        public function buildHashMethodSelectorBE(array $params, t3lib_tsStyleConfig $pObj) {
                return $this->buildHashMethodSelector($params, $pObj, 'BE');
@@ -446,20 +447,20 @@ EOT;
         * Processes the information submitted by the user using a POST request and
         * transforms it to a TypoScript node notation.
         *
-        * @param       array           $postArray: Incoming POST information
-        * @return      array           Processed and transformed POST information
+        * @param array $postArray Incoming POST information
+        * @return array Processed and transformed POST information
         */
        private function processPostData(array $postArray = array()) {
                foreach ($postArray as $key => $value) {
-                       // TODO: Explain
+                               // TODO: Explain
                        $parts = explode('.', $key, 2);
 
                        if (count($parts)==2) {
-                               // TODO: Explain
+                                       // TODO: Explain
                                $value = $this->processPostData(array($parts[1] => $value));
                                $postArray[$parts[0].'.'] = array_merge((array)$postArray[$parts[0].'.'], $value);
                        } else {
-                               // TODO: Explain
+                                       // TODO: Explain
                                $postArray[$parts[0]] = $value;
                        }
                }
index 8b3fa9f..6870c24 100644 (file)
 /**
  * Class implementing salted evaluation methods.
  *
- * @author     Marcus Krause <marcus#exp2009@t3sec.info>
- * @author     Steffen Ritter <info@rs-websystems.de>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since      2009-06-14
- * @package    TYPO3
- * @subpackage tx_saltedpasswords
+ * @since 2009-06-14
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_eval {
        /**
@@ -50,7 +50,7 @@ class tx_saltedpasswords_eval {
         * This function just return the field value as it is. No transforming,
         * hashing will be done on server-side.
         *
-        * @return      JavaScript code for evaluating the
+        * @return string JavaScript code for evaluating the
         */
        function returnFieldJS() {
                return 'return value;';
@@ -59,10 +59,10 @@ class tx_saltedpasswords_eval {
        /**
         * Function uses Portable PHP Hashing Framework to create a proper password string if needed
         *
-        * @param       mixed           $value: The value that has to be checked.
-        * @param       string          $is_in: Is-In String
-        * @param       integer         $set: Determines if the field can be set (value correct) or not, e.g. if input is required but the value is empty, then $set should be set to FALSE. (PASSED BY REFERENCE!)
-        * @return      The new value of the field
+        * @param mixed $value The value that has to be checked.
+        * @param string $is_in Is-In String
+        * @param integer $set Determines if the field can be set (value correct) or not, e.g. if input is required but the value is empty, then $set should be set to FALSE. (PASSED BY REFERENCE!)
+        * @return The new value of the field
         */
        function evaluateFieldValue($value, $is_in, &$set) {
                $isEnabled = $this->mode ? tx_saltedpasswords_div::isUsageEnabled($this->mode) : tx_saltedpasswords_div::isUsageEnabled();
index 6c0a7c4..3eaa3a3 100644 (file)
 /**
  * Class implementing salted evaluation methods for BE users.
  *
- * @author     Marcus Krause <marcus#exp2009@t3sec.info>
- * @author     Steffen Ritter <info@rs-websystems.de>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since      2009-06-14
- * @package    TYPO3
- * @subpackage tx_saltedpasswords
+ * @since 2009-06-14
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_eval_be extends tx_saltedpasswords_eval {
        /**
         * Class constructor.
-        *
-        * @return      tx_saltedpasswords_eval_fe      instance of object
         */
        public function __construct() {
                $this->mode = 'BE';
index 9a06e37..a6138ae 100644 (file)
 /**
  * Class implementing salted evaluation methods for FE users.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
- * @author             Steffen Ritter <info@rs-websystems.de>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since       2009-06-14
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-06-14
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_eval_fe extends tx_saltedpasswords_eval {
        /**
         * Class constructor.
-        *
-        * @return      tx_saltedpasswords_eval_fe      instance of object
         */
        public function __construct() {
                $this->mode = 'FE';
index e4f491b..523cf3f 100644 (file)
  * to be used in classes that provide salted hashing.
  */
 
-
 /**
  * Abtract class with methods needed to be extended
  * in a salted hashing class.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
  *
- * @abstract
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 abstract class tx_saltedpasswords_abstract_salts {
        /**
         * Method applies settings (prefix, optional hash count, optional suffix)
         * to a salt.
         *
-        * @param       string          $salt:  a salt to apply setting to
-        * @return      string          salt with setting
+        * @param string $salt A salt to apply setting to
+        * @return string Salt with setting
         */
        abstract protected function applySettingsToSalt($salt);
 
        /**
         * Generates a random base salt settings for the hash.
         *
-        * @return      string          a string containing settings and a random salt
+        * @return string A string containing settings and a random salt
         */
        abstract protected function getGeneratedSalt();
 
        /**
         * Returns a string for mapping an int to the corresponding base 64 character.
         *
-        * @return      string          string for mapping an int to the corresponding base 64 character
+        * @return string String for mapping an int to the corresponding base 64 character
         */
        abstract protected function getItoa64();
 
        /**
         * Returns setting string to indicate type of hashing method.
         *
-        * @return      string          setting string of hashing method
+        * @return string Setting string of hashing method
         */
        abstract protected function getSetting();
 
        /**
         * Encodes bytes into printable base 64 using the *nix standard from crypt().
         *
-        * @param       string          $input: the string containing bytes to encode.
-        * @param       integer         $count: the number of characters (bytes) to encode.
-        * @return      string          encoded string
+        * @param string $input The string containing bytes to encode.
+        * @param integer $count The number of characters (bytes) to encode.
+        * @return string Encoded string
         */
        public function base64Encode($input, $count) {
                $output = '';
@@ -109,11 +107,11 @@ abstract class tx_saltedpasswords_abstract_salts {
         * Method determines required length of base64 characters for a given
         * length of a byte string.
         *
-        * @param       integer         $byteLength: length of bytes to calculate in base64 chars
-        * @return      integer         required length of base64 characters
+        * @param integer $byteLength Length of bytes to calculate in base64 chars
+        * @return integer Required length of base64 characters
         */
        protected function getLengthBase64FromBytes($byteLength) {
-                       // calculates bytes in bits in base64
+                       // Calculates bytes in bits in base64
                return intval(ceil(($byteLength * 8) / 6));
        }
 }
index b3b9559..7e213e0 100644 (file)
@@ -29,7 +29,6 @@
  * that provides Blowfish salted hashing.
  */
 
-
 /**
  * Class that implements Blowfish salted hashing based on PHP's
  * crypt() function.
  * Warning: Blowfish salted hashing with PHP's crypt() is not available
  * on every system.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
  *
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
@@ -66,7 +65,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Keeps log2 number
         * of iterations for password stretching.
         *
-        * @var integer
+        * @var integer
         */
        static protected $hashCount;
 
@@ -74,7 +73,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Keeps maximum allowed log2 number
         * of iterations for password stretching.
         *
-        * @var integer
+        * @var integer
         */
        static protected $maxHashCount;
 
@@ -82,21 +81,21 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Keeps minimum allowed log2 number
         * of iterations for password stretching.
         *
-        * @var integer
+        * @var integer
         */
        static protected $minHashCount;
 
        /**
         * Keeps length of a Blowfish salt in bytes.
         *
-        * @var integer
+        * @var integer
         */
        static protected $saltLengthBlowfish = 16;
 
        /**
         * Setting string to indicate type of hashing method (blowfish).
         *
-        * @var string
+        * @var string
         */
        static protected $settingBlowfish = '$2a$';
 
@@ -107,15 +106,15 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Overwrites {@link tx_saltedpasswords_salts_md5::applySettingsToSalt()}
         * with Blowfish specifics.
         *
-        * @param       string          $salt:  a salt to apply setting to
-        * @return      string          salt with setting
+        * @param string $salt A salt to apply setting to
+        * @return string Salt with setting
         */
        protected function applySettingsToSalt($salt) {
                $saltWithSettings = $salt;
 
                $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
 
-                                       // salt without setting
+                       // salt without setting
                if (strlen($salt) == $reqLenBase64) {
                        $saltWithSettings = $this->getSetting()
                                . sprintf('%02u', $this->getHashCount()) . '$'
@@ -128,15 +127,15 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Parses the log2 iteration count from a stored hash or setting string.
         *
-        * @param       string          $setting: complete hash or a hash's setting string or to get log2 iteration count from
-        * @return      integer         used hashcount for given hash string
+        * @param string $setting Complete hash or a hash's setting string or to get log2 iteration count from
+        * @return integer Used hashcount for given hash string
         */
        protected function getCountLog2($setting) {
                $countLog2 = NULL;
                $setting = substr($setting, strlen($this->getSetting()));
                $firstSplitPos = strpos($setting, '$');
 
-                       // hashcount existing
+                       // Hashcount existing
                if (($firstSplitPos !== FALSE)
                        && ($firstSplitPos <= 2) && is_numeric(substr($setting, 0, $firstSplitPos))) {
                        $countLog2 = intval(substr($setting, 0, $firstSplitPos));
@@ -148,10 +147,10 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method returns log2 number of iterations for password stretching.
         *
-        * @return      integer         log2 number of iterations for password stretching
-        * @see         HASH_COUNT
-        * @see         $hashCount
-        * @see         setHashCount()
+        * @return integer log2 number of iterations for password stretching
+        * @see HASH_COUNT
+        * @see $hashCount
+        * @see setHashCount()
         */
        public function getHashCount() {
                return isset(self::$hashCount) ? self::$hashCount : self::HASH_COUNT;
@@ -160,10 +159,10 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method returns maximum allowed log2 number of iterations for password stretching.
         *
-        * @return      integer         maximum allowed log2 number of iterations for password stretching
-        * @see         MAX_HASH_COUNT
-        * @see         $maxHashCount
-        * @see         setMaxHashCount()
+        * @return integer Maximum allowed log2 number of iterations for password stretching
+        * @see MAX_HASH_COUNT
+        * @see $maxHashCount
+        * @see setMaxHashCount()
         */
        public function getMaxHashCount() {
                return isset(self::$maxHashCount) ? self::$maxHashCount : self::MAX_HASH_COUNT;
@@ -172,7 +171,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Returns wether all prequesites for the hashing methods are matched
         *
-        * @return      boolean         method available
+        * @return boolean Method available
         */
        public function isAvailable() {
                return CRYPT_BLOWFISH;
@@ -181,10 +180,10 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method returns minimum allowed log2 number of iterations for password stretching.
         *
-        * @return      integer         minimum allowed log2 number of iterations for password stretching
-        * @see         MIN_HASH_COUNT
-        * @see         $minHashCount
-        * @see         setMinHashCount()
+        * @return integer Minimum allowed log2 number of iterations for password stretching
+        * @see MIN_HASH_COUNT
+        * @see $minHashCount
+        * @see setMinHashCount()
         */
        public function getMinHashCount() {
                return isset(self::$minHashCount) ? self::$minHashCount : self::MIN_HASH_COUNT;
@@ -196,7 +195,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Overwrites {@link tx_saltedpasswords_salts_md5::getSaltLength()}
         * with Blowfish specifics.
         *
-        * @return      integer         length of a Blowfish salt in bytes
+        * @return integer Length of a Blowfish salt in bytes
         */
        public function getSaltLength() {
                return self::$saltLengthBlowfish;
@@ -208,7 +207,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Overwrites {@link tx_saltedpasswords_salts_md5::getSetting()}
         * with Blowfish specifics.
         *
-        * @return      string          setting string of Blowfish salted hashes
+        * @return string Setting string of Blowfish salted hashes
         */
        public function getSetting() {
                return self::$settingBlowfish;
@@ -222,8 +221,8 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * count has changed through a change in the variable $hashCount or
         * HASH_COUNT.
         *
-        * @param       string          $saltedPW: salted hash to check if it needs an update
-        * @return      boolean         TRUE if salted hash needs an update, otherwise FALSE
+        * @param string $saltedPW Salted hash to check if it needs an update
+        * @return boolean TRUE if salted hash needs an update, otherwise FALSE
         */
        public function isHashUpdateNeeded($saltedPW) {
                        // Check whether this was an updated password.
@@ -242,8 +241,8 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
         * Overwrites {@link tx_saltedpasswords_salts_md5::isValidSalt()} with
         * Blowfish specifics.
         *
-        * @param       string          $salt: string to check
-        * @return      boolean         TRUE if it's valid salt, otherwise FALSE
+        * @param string $salt String to check
+        * @return boolean TRUE if it's valid salt, otherwise FALSE
         */
        public function isValidSalt($salt) {
                $isValid = $skip = FALSE;
@@ -251,7 +250,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
                $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
 
                if (strlen($salt) >= $reqLenBase64) {
-                               // salt with prefixed setting
+                               // Salt with prefixed setting
                        if (!strncmp('$', $salt, 1)) {
                                if (!strncmp($this->getSetting(), $salt, strlen($this->getSetting()))) {
                                        $isValid = TRUE;
@@ -261,7 +260,7 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
                                }
                        }
 
-                               // checking base64 characters
+                               // Checking base64 characters
                        if (!$skip && (strlen($salt) >= $reqLenBase64)) {
                                if (preg_match('/^[' . preg_quote($this->getItoa64(), '/') . ']{' . $reqLenBase64 . ',' . $reqLenBase64 . '}$/', substr($salt, 0, $reqLenBase64))) {
                                        $isValid = TRUE;
@@ -275,8 +274,8 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method determines if a given string is a valid salted hashed password.
         *
-        * @param       string          $saltedPW: string to check
-        * @return      boolean         TRUE if it's valid salted hashed password, otherwise FALSE
+        * @param string $saltedPW String to check
+        * @return boolean TRUE if it's valid salted hashed password, otherwise FALSE
         */
        public function isValidSaltedPW($saltedPW) {
                $isValid = FALSE;
@@ -293,10 +292,10 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method sets log2 number of iterations for password stretching.
         *
-        * @param       integer         $hashCount: log2 number of iterations for password stretching to set
-        * @see         HASH_COUNT
-        * @see         $hashCount
-        * @see         getHashCount()
+        * @param integer $hashCount log2 number of iterations for password stretching to set
+        * @see HASH_COUNT
+        * @see $hashCount
+        * @see getHashCount()
         */
        public function setHashCount($hashCount = NULL) {
                self::$hashCount = !is_NULL($hashCount) && is_int($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
@@ -305,10 +304,10 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method sets maximum allowed log2 number of iterations for password stretching.
         *
-        * @param       integer         $maxHashCount: maximum allowed log2 number of iterations for password stretching to set
-        * @see         MAX_HASH_COUNT
-        * @see         $maxHashCount
-        * @see         getMaxHashCount()
+        * @param integer $maxHashCount Maximum allowed log2 number of iterations for password stretching to set
+        * @see MAX_HASH_COUNT
+        * @see $maxHashCount
+        * @see getMaxHashCount()
         */
        public function setMaxHashCount($maxHashCount = NULL) {
                self::$maxHashCount = !is_NULL($maxHashCount) && is_int($maxHashCount) ? $maxHashCount : self::MAX_HASH_COUNT;
@@ -317,10 +316,10 @@ class tx_saltedpasswords_salts_blowfish extends tx_saltedpasswords_salts_md5 {
        /**
         * Method sets minimum allowed log2 number of iterations for password stretching.
         *
-        * @param       integer         $minHashCount: minimum allowed log2 number of iterations for password stretching to set
-        * @see         MIN_HASH_COUNT
-        * @see         $minHashCount
-        * @see         getMinHashCount()
+        * @param integer $minHashCount Minimum allowed log2 number of iterations for password stretching to set
+        * @see MIN_HASH_COUNT
+        * @see $minHashCount
+        * @see getMinHashCount()
         */
        public function setMinHashCount($minHashCount = NULL) {
                self::$minHashCount = !is_NULL($minHashCount) && is_int($minHashCount) ? $minHashCount : self::MIN_HASH_COUNT;
index 81870ab..b25880c 100644 (file)
  * that provides a salted hashing method factory.
  */
 
-
 /**
  * Class that implements Blowfish salted hashing based on PHP's
  * crypt() function.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
  *
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_factory {
        /**
         * An instance of the salted hashing method.
         * This member is set in the getSaltingInstance() function.
         *
-        * @var tx_saltedpasswords_abstract_salts
+        * @var tx_saltedpasswords_abstract_salts
         */
        static protected $instance = NULL;
 
-
        /**
         * Obtains a salting hashing method instance.
         *
@@ -58,18 +56,18 @@ class tx_saltedpasswords_salts_factory {
         *
         * Use parameter NULL to reset the factory!
         *
-        * @param       string          $saltedHash: (optional) salted hashed password to determine the type of used method from or NULL to reset the factory
-        * @param       string          $mode: (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
-        * @return      tx_saltedpasswords_abstract_salts       an instance of salting hashing method object
+        * @param string $saltedHash (optional) Salted hashed password to determine the type of used method from or NULL to reset the factory
+        * @param string $mode (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
+        * @return tx_saltedpasswords_abstract_salts    an instance of salting hashing method object
         */
        static public function getSaltingInstance($saltedHash = '', $mode = TYPO3_MODE) {
-                       // creating new instance when
+                       // Creating new instance when
                        // * no instance existing
                        // * a salted hash given to determine salted hashing method from
                        // * a NULL parameter given to reset instance back to default method
                if (!is_object(self::$instance) || !empty($saltedHash) || is_NULL($saltedHash)) {
 
-                               // determine method by checking the given hash
+                               // Determine method by checking the given hash
                        if (!empty($saltedHash)) {
                                $result = self::determineSaltingHashingMethod($saltedHash);
                                if(!$result) {
@@ -90,8 +88,8 @@ class tx_saltedpasswords_salts_factory {
         *
         * Method implicitly sets the instance of the found method object in the class property when found.
         *
-        * @param       string          $saltedHash
-        * @return      boolean         TRUE, if salting hashing method has been found, otherwise FALSE
+        * @param string $saltedHash
+        * @return boolean TRUE, if salting hashing method has been found, otherwise FALSE
         */
        static public function determineSaltingHashingMethod($saltedHash) {
                $methodFound = FALSE;
@@ -113,8 +111,8 @@ class tx_saltedpasswords_salts_factory {
        /**
         * Method sets a custom salting hashing method class.
         *
-        * @param       string          $resource: object resource to use (e.g. 'EXT:saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_blowfish.php:tx_saltedpasswords_salts_blowfish')
-        * @return      tx_saltedpasswords_abstract_salts       an instance of salting hashing method object
+        * @param string $resource Object resource to use (e.g. 'EXT:saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_blowfish.php:tx_saltedpasswords_salts_blowfish')
+        * @return tx_saltedpasswords_abstract_salts    an instance of salting hashing method object
         */
        static public function setPreferredHashingMethod($resource) {
                self::$instance = NULL;
index 4e3e1a9..df455a5 100644 (file)
@@ -29,7 +29,6 @@
  * that provides MD5 salted hashing.
  */
 
-
 /**
  * Class that implements MD5 salted hashing based on PHP's
  * crypt() function.
  * MD5 salted hashing with PHP's crypt() should be available
  * on most of the systems.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
  *
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts implements tx_saltedpasswords_salts {
        /**
@@ -53,37 +52,36 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Keeps length of a MD5 salt in bytes.
         *
-        * @var integer
+        * @var integer
         */
        static protected $saltLengthMD5 = 6;
 
        /**
         * Keeps suffix to be appended to a salt.
         *
-        * @var string
+        * @var string
         */
        static protected $saltSuffixMD5 = '$';
 
        /**
         * Setting string to indicate type of hashing method (md5).
         *
-        * @var string
+        * @var string
         */
        static protected $settingMD5 = '$1$';
 
-
        /**
         * Method applies settings (prefix, suffix) to a salt.
         *
-        * @param       string          $salt: a salt to apply setting to
-        * @return      string          salt with setting
+        * @param string $salt A salt to apply setting to
+        * @return string Salt with setting
         */
        protected function applySettingsToSalt($salt) {
                $saltWithSettings = $salt;
 
                $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
 
-                       // salt without setting
+                       // Salt without setting
                if (strlen($salt) == $reqLenBase64) {
                        $saltWithSettings = $this->getSetting() . $salt . $this->getSaltSuffix();
 
@@ -96,9 +94,9 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
         * Method checks if a given plaintext password is correct by comparing it with
         * a given salted hashed password.
         *
-        * @param       string          $plainPW: plain-text password to compare with salted hash
-        * @param       string          $saltedHashPW: salted hash to compare plain-text password with
-        * @return      boolean         TRUE, if plain-text password matches the salted hash, otherwise FALSE
+        * @param string $plainPW plain-text password to compare with salted hash
+        * @param string $saltedHashPW salted hash to compare plain-text password with
+        * @return boolean TRUE, if plain-text password matches the salted hash, otherwise FALSE
         */
        public function checkPassword($plainPW, $saltedHashPW) {
                $isCorrect = FALSE;
@@ -119,7 +117,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
         *  - The ability to determine whether two users have the same (or different)
         *    password without actually having to guess one of the passwords.
         *
-        * @return      string          a character string containing settings and a random salt
+        * @return string A character string containing settings and a random salt
         */
        protected function getGeneratedSalt() {
                $randomBytes = t3lib_div::generateRandomBytes($this->getSaltLength());
@@ -130,9 +128,9 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Method creates a salted hash for a given plaintext password
         *
-        * @param       string          $password: plaintext password to create a salted hash from
-        * @param       string          $salt: optional custom salt with setting to use
-        * @return      string          salted hashed password
+        * @param string $password plaintext password to create a salted hash from
+        * @param string $salt Optional custom salt with setting to use
+        * @return string Salted hashed password
         */
        public function getHashedPassword($password, $salt = NULL) {
                $saltedPW = NULL;
@@ -149,7 +147,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Returns a string for mapping an int to the corresponding base 64 character.
         *
-        * @return      string          string for mapping an int to the corresponding base 64 character
+        * @return string String for mapping an int to the corresponding base 64 character
         */
        protected function getItoa64() {
                return self::ITOA64;
@@ -158,7 +156,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Returns wether all prequesites for the hashing methods are matched
         *
-        * @return      boolean         method available
+        * @return boolean Method available
         */
        public function isAvailable() {
                return CRYPT_MD5;
@@ -167,7 +165,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Returns length of a MD5 salt in bytes.
         *
-        * @return      integer         length of a MD5 salt in bytes
+        * @return integer Length of a MD5 salt in bytes
         */
        public function getSaltLength() {
                return self::$saltLengthMD5;
@@ -176,7 +174,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Returns suffix to be appended to a salt.
         *
-        * @return      string          suffix of a salt
+        * @return string Suffix of a salt
         */
        protected function getSaltSuffix() {
                return self::$saltSuffixMD5;
@@ -185,7 +183,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Returns setting string of MD5 salted hashes.
         *
-        * @return      string          setting string of MD5 salted hashes
+        * @return string Setting string of MD5 salted hashes
         */
        public function getSetting() {
                return self::$settingMD5;
@@ -200,8 +198,8 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
         * HASH_COUNT or if the user's password hash was generated in an bulk update
         * with class ext_update.
         *
-        * @param       string          $passString: salted hash to check if it needs an update
-        * @return      boolean         TRUE if salted hash needs an update, otherwise FALSE
+        * @param string $passString Salted hash to check if it needs an update
+        * @return boolean TRUE if salted hash needs an update, otherwise FALSE
         */
        public function isHashUpdateNeeded($passString) {
                return FALSE;
@@ -210,8 +208,8 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Method determines if a given string is a valid salt
         *
-        * @param       string          $salt:  string to check
-        * @return      boolean         TRUE if it's valid salt, otherwise FALSE
+        * @param string $salt String to check
+        * @return boolean TRUE if it's valid salt, otherwise FALSE
         */
        public function isValidSalt($salt) {
                $isValid = $skip = FALSE;
@@ -219,7 +217,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
                $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
 
                if (strlen($salt) >= $reqLenBase64) {
-                                               // salt with prefixed setting
+                               // Salt with prefixed setting
                        if (!strncmp('$', $salt, 1)) {
                                if (!strncmp($this->getSetting(), $salt, strlen($this->getSetting()))) {
                                        $isValid = TRUE;
@@ -229,7 +227,7 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
                                }
                        }
 
-                               // checking base64 characters
+                               // Checking base64 characters
                        if (!$skip && (strlen($salt) >= $reqLenBase64)) {
                                if (preg_match('/^[' . preg_quote($this->getItoa64(), '/') . ']{' . $reqLenBase64 . ',' . $reqLenBase64 . '}$/', substr($salt, 0, $reqLenBase64))) {
                                        $isValid = TRUE;
@@ -243,8 +241,8 @@ class tx_saltedpasswords_salts_md5 extends tx_saltedpasswords_abstract_salts imp
        /**
         * Method determines if a given string is a valid salted hashed password.
         *
-        * @param       string          $saltedPW: string to check
-        * @return      boolean         TRUE if it's valid salted hashed password, otherwise FALSE
+        * @param string $saltedPW String to check
+        * @return boolean TRUE if it's valid salted hashed password, otherwise FALSE
         */
        public function isValidSaltedPW($saltedPW) {
                $isValid = FALSE;
index 9ad44ea..284f244 100644 (file)
  * @see http://www.openwall.com/phpass/
  */
 
-
 /**
  * Class that implements PHPass salted hashing based on Drupal's
  * modified Openwall implementation.
  *
  * PHPass should work on every system.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
  *
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts implements tx_saltedpasswords_salts {
        /**
@@ -79,7 +78,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         * Keeps log2 number
         * of iterations for password stretching.
         *
-        * @var integer
+        * @var integer
         */
        static protected $hashCount;
 
@@ -87,7 +86,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         * Keeps maximum allowed log2 number
         * of iterations for password stretching.
         *
-        * @var integer
+        * @var integer
         */
        static protected $maxHashCount;
 
@@ -95,40 +94,39 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         * Keeps minimum allowed log2 number
         * of iterations for password stretching.
         *
-        * @var integer
+        * @var integer
         */
        static protected $minHashCount;
 
        /**
         * Keeps length of a PHPass salt in bytes.
         *
-        * @var integer
+        * @var integer
         */
        static protected $saltLengthPhpass = 6;
 
        /**
         * Setting string to indicate type of hashing method (PHPass).
         *
-        * @var string
+        * @var string
         */
        static protected $settingPhpass = '$P$';
 
-
        /**
         * Method applies settings (prefix, hash count) to a salt.
         *
         * Overwrites {@link tx_saltedpasswords_salts_md5::applySettingsToSalt()}
         * with Blowfish specifics.
         *
-        * @param       string          $salt: a salt to apply setting to
-        * @return      string          salt with setting
+        * @param string $salt A salt to apply setting to
+        * @return string Salt with setting
         */
        protected function applySettingsToSalt($salt) {
                $saltWithSettings = $salt;
 
                $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
 
-                       // salt without setting
+                       // Salt without setting
                if (strlen($salt) == $reqLenBase64) {
                                // We encode the final log2 iteration count in base 64.
                        $itoa64 = $this->getItoa64();
@@ -144,9 +142,9 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         * Method checks if a given plaintext password is correct by comparing it with
         * a given salted hashed password.
         *
-        * @param       string          $plainPW: plain-text password to compare with salted hash
-        * @param       string          $saltedHashPW: salted hash to compare plain-text password with
-        * @return      boolean         TRUE, if plain-text password matches the salted hash, otherwise FALSE
+        * @param string $plainPW Plain-text password to compare with salted hash
+        * @param string $saltedHashPW Salted hash to compare plain-text password with
+        * @return boolean TRUE, if plain-text password matches the salted hash, otherwise FALSE
         */
        public function checkPassword($plainPW, $saltedHashPW) {
                $hash = $this->cryptPassword($plainPW, $saltedHashPW);
@@ -157,7 +155,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Returns wether all prequesites for the hashing methods are matched
         *
-        * @return      boolean         method available
+        * @return boolean Method available
         */
        public function isAvailable() {
                return TRUE;
@@ -171,9 +169,9 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         * for an attacker to try to break the hash by brute-force computation of the
         * hashes of a large number of plain-text words or strings to find a match.
         *
-        * @param       string          $password: plain-text password to hash
-        * @param       string          $setting: an existing hash or the output of getGeneratedSalt()
-        * @return      mixed           a string containing the hashed password (and salt)
+        * @param string $password Plain-text password to hash
+        * @param string $setting An existing hash or the output of getGeneratedSalt()
+        * @return mixed A string containing the hashed password (and salt)
         *                                              or boolean FALSE on failure.
         */
        protected function cryptPassword($password, $setting) {
@@ -215,8 +213,8 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Parses the log2 iteration count from a stored hash or setting string.
         *
-        * @param       string          $setting: complete hash or a hash's setting string or to get log2 iteration count from
-        * @return      int                     used hashcount for given hash string
+        * @param string $setting Complete hash or a hash's setting string or to get log2 iteration count from
+        * @return integer Used hashcount for given hash string
         */
        protected function getCountLog2($setting) {
                return strpos(
@@ -234,7 +232,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         *  - The ability to determine whether two users have the same (or different)
         *    password without actually having to guess one of the passwords.
         *
-        * @return      string          a character string containing settings and a random salt
+        * @return string A character string containing settings and a random salt
         */
        protected function getGeneratedSalt() {
                $randomBytes = t3lib_div::generateRandomBytes($this->getSaltLength());
@@ -245,10 +243,10 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method returns log2 number of iterations for password stretching.
         *
-        * @return      integer         log2 number of iterations for password stretching
-        * @see         HASH_COUNT
-        * @see         $hashCount
-        * @see         setHashCount()
+        * @return integer log2 number of iterations for password stretching
+        * @see HASH_COUNT
+        * @see $hashCount
+        * @see setHashCount()
         */
        public function getHashCount() {
                return isset(self::$hashCount) ? self::$hashCount : self::HASH_COUNT;
@@ -257,9 +255,9 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method creates a salted hash for a given plaintext password
         *
-        * @param       string          $password: plaintext password to create a salted hash from
-        * @param       string          $salt: optional custom salt with setting to use
-        * @return      string          salted hashed password
+        * @param string $password Plaintext password to create a salted hash from
+        * @param string $salt Optional custom salt with setting to use
+        * @return string salted hashed password
         */
        public function getHashedPassword($password, $salt = NULL) {
                $saltedPW = NULL;
@@ -277,7 +275,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Returns a string for mapping an int to the corresponding base 64 character.
         *
-        * @return      string          string for mapping an int to the corresponding base 64 character
+        * @return string String for mapping an int to the corresponding base 64 character
         */
        protected function getItoa64() {
                return self::ITOA64;
@@ -286,10 +284,10 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method returns maximum allowed log2 number of iterations for password stretching.
         *
-        * @return      integer         maximum allowed log2 number of iterations for password stretching
-        * @see         MAX_HASH_COUNT
-        * @see         $maxHashCount
-        * @see         setMaxHashCount()
+        * @return integer Maximum allowed log2 number of iterations for password stretching
+        * @see MAX_HASH_COUNT
+        * @see $maxHashCount
+        * @see setMaxHashCount()
         */
        public function getMaxHashCount() {
                return isset(self::$maxHashCount) ? self::$maxHashCount : self::MAX_HASH_COUNT;
@@ -298,10 +296,10 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method returns minimum allowed log2 number of iterations for password stretching.
         *
-        * @return      integer         minimum allowed log2 number of iterations for password stretching
-        * @see         MIN_HASH_COUNT
-        * @see         $minHashCount
-        * @see         setMinHashCount()
+        * @return integer Minimum allowed log2 number of iterations for password stretching
+        * @see MIN_HASH_COUNT
+        * @see $minHashCount
+        * @see setMinHashCount()
         */
        public function getMinHashCount() {
                return isset(self::$minHashCount) ? self::$minHashCount : self::MIN_HASH_COUNT;
@@ -310,7 +308,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Returns length of a Blowfish salt in bytes.
         *
-        * @return      integer         length of a Blowfish salt in bytes
+        * @return integer Length of a Blowfish salt in bytes
         */
        public function getSaltLength() {
                return self::$saltLengthPhpass;
@@ -319,7 +317,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Returns setting string of PHPass salted hashes.
         *
-        * @return      string          setting string of PHPass salted hashes
+        * @return string Setting string of PHPass salted hashes
         */
        public function getSetting() {
                return self::$settingPhpass;
@@ -329,13 +327,13 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
         * Checks whether a user's hashed password needs to be replaced with a new hash.
         *
         * This is typically called during the login process when the plain text
-        * password is available.  A new hash is needed when the desired iteration
+        * password is available. A new hash is needed when the desired iteration
         * count has changed through a change in the variable $hashCount or
         * HASH_COUNT or if the user's password hash was generated in an bulk update
         * with class ext_update.
         *
-        * @param       string          $passString  salted hash to check if it needs an update
-        * @return      boolean         TRUE if salted hash needs an update, otherwise FALSE
+        * @param string $passString Salted hash to check if it needs an update
+        * @return boolean TRUE if salted hash needs an update, otherwise FALSE
         */
        public function isHashUpdateNeeded($passString) {
                        // Check whether this was an updated password.
@@ -349,8 +347,8 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method determines if a given string is a valid salt.
         *
-        * @param       string          $salt:  string to check
-        * @return      boolean         TRUE if it's valid salt, otherwise FALSE
+        * @param string $salt String to check
+        * @return boolean TRUE if it's valid salt, otherwise FALSE
         */
        public function isValidSalt($salt) {
                $isValid = $skip = FALSE;
@@ -358,7 +356,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
                $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
 
                if (strlen($salt) >= $reqLenBase64) {
-                               // salt with prefixed setting
+                               // Salt with prefixed setting
                        if (!strncmp('$', $salt, 1)) {
                                if (!strncmp($this->getSetting(), $salt, strlen($this->getSetting()))) {
                                        $isValid = TRUE;
@@ -368,7 +366,7 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
                                }
                        }
 
-                               // checking base64 characters
+                               // Checking base64 characters
                        if (!$skip && (strlen($salt) >= $reqLenBase64)) {
                                if (preg_match('/^[' . preg_quote($this->getItoa64(), '/') . ']{' . $reqLenBase64 . ',' . $reqLenBase64 . '}$/', substr($salt, 0, $reqLenBase64))) {
                                        $isValid = TRUE;
@@ -382,8 +380,8 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method determines if a given string is a valid salted hashed password.
         *
-        * @param       string          $saltedPW: string to check
-        * @return      boolean         TRUE if it's valid salted hashed password, otherwise FALSE
+        * @param string $saltedPW String to check
+        * @return boolean TRUE if it's valid salted hashed password, otherwise FALSE
         */
        public function isValidSaltedPW($saltedPW) {
                $isValid = FALSE;
@@ -399,10 +397,10 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method sets log2 number of iterations for password stretching.
         *
-        * @param       integer         $hashCount: log2 number of iterations for password stretching to set
-        * @see         HASH_COUNT
-        * @see         $hashCount
-        * @see         getHashCount()
+        * @param integer $hashCount log2 number of iterations for password stretching to set
+        * @see HASH_COUNT
+        * @see $hashCount
+        * @see getHashCount()
         */
        public function setHashCount($hashCount = NULL) {
                self::$hashCount = !is_NULL($hashCount) && is_int($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
@@ -411,10 +409,10 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method sets maximum allowed log2 number of iterations for password stretching.
         *
-        * @param       integer         $maxHashCount: maximum allowed log2 number of iterations for password stretching to set
-        * @see         MAX_HASH_COUNT
-        * @see         $maxHashCount
-        * @see         getMaxHashCount()
+        * @param integer $maxHashCount Maximum allowed log2 number of iterations for password stretching to set
+        * @see MAX_HASH_COUNT
+        * @see $maxHashCount
+        * @see getMaxHashCount()
         */
        public function setMaxHashCount($maxHashCount = NULL) {
                self::$maxHashCount = !is_NULL($maxHashCount) && is_int($maxHashCount) ? $maxHashCount : self::MAX_HASH_COUNT;
@@ -423,10 +421,10 @@ class tx_saltedpasswords_salts_phpass extends tx_saltedpasswords_abstract_salts
        /**
         * Method sets minimum allowed log2 number of iterations for password stretching.
         *
-        * @param       integer         $minHashCount  minimum allowed log2 number of iterations for password stretching to set
-        * @see         MIN_HASH_COUNT
-        * @see         $minHashCount
-        * @see         getMinHashCount()
+        * @param integer $minHashCount Minimum allowed log2 number of iterations for password stretching to set
+        * @see MIN_HASH_COUNT
+        * @see $minHashCount
+        * @see getMinHashCount()
         */
        public function setMinHashCount($minHashCount = NULL) {
                self::$minHashCount = !is_NULL($minHashCount) && is_int($minHashCount) ? $minHashCount : self::MIN_HASH_COUNT;
index 37fe82f..3824f1d 100644 (file)
  * classes that provide salted hashing.
  */
 
-
 /**
  * Interface with public methods needed to be implemented
  * in a salting hashing class.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
- * @author      Steffen Ritter <info@rs-websystems.de>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 interface tx_saltedpasswords_salts {
        /**
         * Method checks if a given plaintext password is correct by comparing it with
         * a given salted hashed password.
         *
-        * @param       string          $plainPW:  plain-text password to compare with salted hash
-        * @param       string          $saltedHashPW:  salted hash to compare plain-text password with
-        * @return      boolean         TRUE, if plaintext password is correct, otherwise FALSE
+        * @param string $plainPW plain-text password to compare with salted hash
+        * @param string $saltedHashPW Salted hash to compare plain-text password with
+        * @return boolean TRUE, if plaintext password is correct, otherwise FALSE
         */
        public function checkPassword($plainPW, $saltedHashPW);
 
        /**
         * Returns length of required salt.
         *
-        * @return      integer         length of required salt
+        * @return integer Length of required salt
         */
        public function getSaltLength();
 
        /**
         * Returns wether all prequesites for the hashing methods are matched
         *
-        * @return      boolean         method available
+        * @return boolean Method available
         */
        public function isAvailable();
 
-
        /**
         * Method creates a salted hash for a given plaintext password
         *
-        * @param       string          $password:  plaintext password to create a salted hash from
-        * @param       string          $salt:  optional custom salt to use
-        * @return      string          salted hashed password
+        * @param string $password Plaintext password to create a salted hash from
+        * @param string $salt Optional custom salt to use
+        * @return string Salted hashed password
         */
        public function getHashedPassword($password, $salt = NULL);
 
@@ -86,24 +84,24 @@ interface tx_saltedpasswords_salts {
         * HASH_COUNT or if the user's password hash was generated in an bulk update
         * with class ext_update.
         *
-        * @param       string          $passString  salted hash to check if it needs an update
-        * @return      boolean         TRUE if salted hash needs an update, otherwise FALSE
+        * @param string $passString Salted hash to check if it needs an update
+        * @return boolean TRUE if salted hash needs an update, otherwise FALSE
         */
        public function isHashUpdateNeeded($passString);
 
        /**
         * Method determines if a given string is a valid salt
         *
-        * @param       string          $salt: string to check
-        * @return      boolean         TRUE if it's valid salt, otherwise FALSE
+        * @param string $salt String to check
+        * @return boolean TRUE if it's valid salt, otherwise FALSE
         */
        public function isValidSalt($salt);
 
        /**
         * Method determines if a given string is a valid salted hashed password.
         *
-        * @param       string          $saltedPW: string to check
-        * @return      boolean         TRUE if it's valid salted hashed password, otherwise FALSE
+        * @param string $saltedPW String to check
+        * @return boolean TRUE if it's valid salted hashed password, otherwise FALSE
         */
        public function isValidSaltedPW($saltedPW);
 }
index 3482ecd..123838e 100644 (file)
@@ -59,8 +59,6 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
 
        /**
         * Constructor initializes user record pointer
-        *
-        * @return void
         */
        public function __construct() {
                parent::__construct();
@@ -108,7 +106,7 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
        /**
         * Find next set of frontend or backend users to update.
         *
-        * @param string 'FE' for frontend, 'BE' for backend user records
+        * @param string $mode 'FE' for frontend, 'BE' for backend user records
         * @return array Rows with uid and password
         */
        protected function findUsersToUpdate($mode) {
@@ -128,8 +126,8 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
        /**
         * Iterate over given user records and update password if needed.
         *
-        * @param string 'FE' for frontend, 'BE' for backend user records
-        * @param array with user uids and passwords
+        * @param string $mode 'FE' for frontend, 'BE' for backend user records
+        * @param array $users With user uids and passwords
         * @return void
         */
        protected function convertPasswords($mode, $users) {
@@ -151,8 +149,8 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
        /**
         * Update password and persist salted hash.
         *
-        * @param string 'FE' for frontend, 'BE' for backend user records
-        * @param array with user uids and passwords
+        * @param string $mode 'FE' for frontend, 'BE' for backend user records
+        * @param array $users With user uids and passwords
         * @return void
         */
        protected function updatePasswords($mode, $users) {
@@ -189,7 +187,7 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
         *
         * If a password does not start with M or C determine if a password is already a usual salted hash.
         *
-        * @param string Password
+        * @param string $password Password
         * @return boolean TRUE if password is a salted hash
         */
        protected function isSaltedHash($password) {
@@ -210,6 +208,7 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
        /**
         * Check if a given password is a md5 hash, the default for be_user records before saltedpasswords.
         *
+        * @param string $password
         * @return boolean TRUE if password is md5
         */
        protected function isMd5Password($password) {
@@ -219,8 +218,8 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
        /**
         * Increment current user record counter by number of handled rows.
         *
-        * @param string 'FE' for frontend, 'BE' for backend user records
-        * @param integer Number of handled rows
+        * @param string $mode 'FE' for frontend, 'BE' for backend user records
+        * @param integer $number Number of handled rows
         * @return void
         */
        protected function incrementUserRecordPointer($mode, $number) {
@@ -236,5 +235,5 @@ class tx_saltedpasswords_Tasks_BulkUpdate extends tx_scheduler_Task {
        protected function deactivateSelf() {
                $this->setDisabled(TRUE);
        }
-} // End of class
+}
 ?>
\ No newline at end of file
index 58bc4c6..cde96fa 100644 (file)
@@ -1,18 +1,18 @@
 <?php
-if (!defined ('TYPO3_MODE')) {
-       die ('Access denied.');
+if (!defined('TYPO3_MODE')) {
+       die('Access denied.');
 }
 
-       // form evaluation function for fe_users
+       // Form evaluation function for fe_users
 $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tce']['formevals']['tx_saltedpasswords_eval_fe'] = 'EXT:saltedpasswords/classes/eval/class.tx_saltedpasswords_eval_fe.php';
 
-       // form evaluation function for be_users
+       // Form evaluation function for be_users
 $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['tce']['formevals']['tx_saltedpasswords_eval_be'] = 'EXT:saltedpasswords/classes/eval/class.tx_saltedpasswords_eval_be.php';
 
-       // hook for processing "forgotPassword" in felogin
+       // Hook for processing "forgotPassword" in felogin
 $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['felogin']['password_changed'][] = 'EXT:saltedpasswords/classes/class.tx_saltedpasswords_div.php:tx_saltedpasswords_div->feloginForgotPasswordHook';
 
-       // registering all available hashes to factory
+       // Registering all available hashes to factory
 $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/saltedpasswords']['saltMethods'] = array(
        'tx_saltedpasswords_salts_md5'          => 'EXT:saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_md5.php:tx_saltedpasswords_salts_md5',
        'tx_saltedpasswords_salts_blowfish'     => 'EXT:saltedpasswords/classes/salts/class.tx_saltedpasswords_salts_blowfish.php:tx_saltedpasswords_salts_blowfish',
@@ -37,7 +37,7 @@ t3lib_extMgm::addService(
        )
 );
 
-// Use popup window to refresh login instead of the AJAX relogin:
+       // Use popup window to refresh login instead of the AJAX relogin:
 $TYPO3_CONF_VARS['BE']['showRefreshLoginPopup'] = 1;
 
        // Register bulk update task
index df0ccc7..74cf18e 100644 (file)
@@ -1,9 +1,8 @@
 <?php
-if (!defined ('TYPO3_MODE')) {
-       die ('Access denied.');
+if (!defined('TYPO3_MODE')) {
+       die('Access denied.');
 }
 
-
 t3lib_div::loadTCA('fe_users');
 $GLOBALS['TCA']['fe_users']['columns']['password']['config']['max'] = 60;
 
@@ -47,5 +46,4 @@ if (tx_saltedpasswords_div::isUsageEnabled('BE')) {
        $GLOBALS['TYPO3_USER_SETTINGS']['columns']['password2']['eval'] = '';
 }
 
-
 ?>
\ No newline at end of file
index 5f56f7a..e115f97 100644 (file)
  * Contains authentication service class for salted hashed passwords.
  */
 
-
 /**
  * Class implements salted-password hashes authentication service.
  *
- * @author     Marcus Krause <marcus#exp2009@t3sec.info>
- * @author     Steffen Ritter <info@rs-websystems.de>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Steffen Ritter <info@rs-websystems.de>
  *
- * @since      2009-06-14
- * @package    TYPO3
- * @subpackage tx_saltedpasswords
+ * @since 2009-06-14
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_sv1 extends tx_sv_authbase {
        /**
         * Keeps class name.
         *
-        * @var string
+        * @var string
         */
        public $prefixId = 'tx_saltedpasswords_sv1';
 
        /**
         * Keeps path to this script relative to the extension directory.
         *
-        * @var string
+        * @var string
         */
        public $scriptRelPath = 'sv1/class.tx_saltedpasswords_sv1.php';
 
        /**
         * Keeps extension key.
         *
-        * @var string
+        * @var string
         */
        public $extKey = 'saltedpasswords';
 
        /**
         * Keeps extension configuration.
         *
-        * @var mixed
+        * @var mixed
         */
        protected $extConf;
 
@@ -73,7 +72,7 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
         * An instance of the salted hashing method.
         * This member is set in the getSaltingInstance() function.
         *
-        * @var tx_saltedpasswords_abstract_salts
+        * @var tx_saltedpasswords_abstract_salts
         */
        protected $objInstanceSaltedPW = NULL;
 
@@ -92,7 +91,7 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
         * following prerequesties are fulfilled:
         * - loginSecurityLevel of according TYPO3_MODE is set to normal
         *
-        * @return      boolean         TRUE if service is available
+        * @return boolean TRUE if service is available
         */
        public function init() {
                $available = FALSE;
@@ -115,29 +114,29 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
        /**
         * Checks the login data with the user record data for builtin login method.
         *
-        * @param       array           user data array
-        * @param       array           login data array
-        * @param       string          login security level (optional)
-        * @return      boolean         TRUE if login data matched
+        * @param array $user User data array
+        * @param array $loginData Login data array
+        * @param string $security_level Login security level (optional)
+        * @return boolean TRUE if login data matched
         */
        function compareUident(array $user, array $loginData, $security_level = 'normal') {
                $validPasswd = FALSE;
 
-                       // could be merged; still here to clarify
+                       // Could be merged; still here to clarify
                if (!strcmp(TYPO3_MODE, 'BE')) {
                        $password = $loginData['uident_text'];
                } elseif (!strcmp(TYPO3_MODE, 'FE')) {
                        $password = $loginData['uident_text'];
                }
 
-                       // determine method used for given salted hashed password
+                       // Determine method used for given salted hashed password
                $this->objInstanceSaltedPW = tx_saltedpasswords_salts_factory::getSaltingInstance($user['password']);
 
-                       // existing record is in format of Salted Hash password
+                       // Existing record is in format of Salted Hash password
                if (is_object($this->objInstanceSaltedPW)) {
                        $validPasswd = $this->objInstanceSaltedPW->checkPassword($password, $user['password']);
 
-                               // record is in format of Salted Hash password but authentication failed
+                               // Record is in format of Salted Hash password but authentication failed
                                // skip further authentication methods
                        if (!$validPasswd) {
                                $this->authenticationFailed = TRUE;
@@ -146,9 +145,9 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
                        $defaultHashingClassName = tx_saltedpasswords_div::getDefaultSaltingHashingMethod();
                        $skip = FALSE;
 
-                               // test for wrong salted hashing method
+                               // Test for wrong salted hashing method
                        if ($validPasswd && !(get_class($this->objInstanceSaltedPW) == $defaultHashingClassName) || (is_subclass_of($this->objInstanceSaltedPW, $defaultHashingClassName))) {
-                                       // instanciate default method class
+                                       // Instanciate default method class
                                $this->objInstanceSaltedPW = tx_saltedpasswords_salts_factory::getSaltingInstance(NULL);
                                $this->updatePassword(
                                        intval($user['uid']),
@@ -162,13 +161,13 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
                                        array('password' => $this->objInstanceSaltedPW->getHashedPassword($password))
                                );
                        }
-                       // we process also clear-text, md5 and passwords updated by Portable PHP password hashing framework
+                       // We process also clear-text, md5 and passwords updated by Portable PHP password hashing framework
                } elseif (!intval($this->extConf['forceSalted'])) {
 
-                               // stored password is in deprecated salted hashing method
+                               // Stored password is in deprecated salted hashing method
                        if (t3lib_div::inList('C$,M$', substr($user['password'], 0, 2))) {
 
-                                       // instanciate default method class
+                                       // Instanciate default method class
                                $this->objInstanceSaltedPW = tx_saltedpasswords_salts_factory::getSaltingInstance(substr($user['password'], 1));
 
                                        // md5
@@ -178,27 +177,27 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
                                        $validPasswd = $this->objInstanceSaltedPW->checkPassword($password, substr($user['password'], 1));
                                }
 
-                                       // skip further authentication methods
+                                       // Skip further authentication methods
                                if (!$validPasswd) {
                                        $this->authenticationFailed = TRUE;
                                }
 
-                               // password is stored as md5
+                               // Password is stored as md5
                        } elseif (preg_match('/[0-9abcdef]{32,32}/', $user['password'])) {
                                $validPasswd = (!strcmp(md5($password), $user['password']) ? TRUE : FALSE);
 
-                                       // skip further authentication methods
+                                       // Skip further authentication methods
                                if (!$validPasswd) {
                                        $this->authenticationFailed = TRUE;
                                }
 
-                               // password is stored plain or unrecognized format
+                               // Password is stored plain or unrecognized format
                        } else {
                                $validPasswd = (!strcmp($password, $user['password']) ? TRUE : FALSE);
                        }
-                               // should we store the new format value in DB?
+                               // Should we store the new format value in DB?
                        if ($validPasswd && intval($this->extConf['updatePasswd'])) {
-                                       // instanciate default method class
+                                       // Instanciate default method class
                                $this->objInstanceSaltedPW = tx_saltedpasswords_salts_factory::getSaltingInstance(NULL);
                                $this->updatePassword(
                                        intval($user['uid']),
@@ -218,8 +217,8 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
         *  - 100 - just go on. User is not authenticated but there is still no reason to stop
         *  - 200 - the service was able to authenticate the user
         *
-        * @param       array           Array containing FE user data of the logged user.
-        * @return      integer         authentication statuscode, one of 0,100 and 200
+        * @param array Array containing FE user data of the logged user.
+        * @return integer Authentication statuscode, one of 0,100 and 200
         */
        public function authUser(array $user) {
                $OK = 100;
@@ -236,7 +235,7 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
                        if (!$validPasswd) {
                                        // Failed login attempt (wrong password)
                                $errorMessage = 'Login-attempt from %s (%s), username \'%s\', password not accepted!';
-                                       // no delegation to further services
+                                       // No delegation to further services
                                if (intval($this->extConf['onlyAuthService']) || $this->authenticationFailed) {
                                        $this->writeLogMessage(
                                                TYPO3_MODE . ' Authentication failed - wrong password for username \'%s\'',
@@ -320,9 +319,9 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
        /**
         * Method updates a FE/BE user record - in this case a new password string will be set.
         *
-        * @param       integer         $uid: uid of user record that will be updated
-        * @param       mixed           $updateFields: Field values as key=>value pairs to be updated in database
-        * @return      void
+        * @param integer $uid uid of user record that will be updated
+        * @param mixed $updateFields Field values as key=>value pairs to be updated in database
+        * @return void
         */
        protected function updatePassword($uid, $updateFields) {
                $GLOBALS['TYPO3_DB']->exec_UPDATEquery($this->pObj->user_table, sprintf('uid = %u', $uid), $updateFields);
@@ -338,8 +337,8 @@ class tx_saltedpasswords_sv1 extends tx_sv_authbase {
         * This function accepts variable number of arguments and can format
         * parameters. The syntax is the same as for sprintf()
         *
-        * @param       string          $message: Message to output
-        * @return      void
+        * @param string $message Message to output
+        * @return void
         * @see sprintf()
         * @see t3lib::divLog()
         * @see t3lib_div::sysLog()
index 498f48b..0bd48a5 100644 (file)
@@ -32,9 +32,9 @@
 /**
  * Testcases for class tx_saltedpasswords_div.
  *
- * @author  Marcus Krause <marcus#exp2009@t3sec.info>
- * @package  TYPO3
- * @subpackage  tx_saltedpasswords
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_divTest extends tx_phpunit_testcase {
        protected $backupGlobals = TRUE;
index 6b9beb3..633a84b 100644 (file)
@@ -32,9 +32,9 @@
 /**
  * Testcases for class tx_saltedpasswords_salts_blowfish.
  *
- * @author  Marcus Krause <marcus#exp2009@t3sec.info>
- * @package  TYPO3
- * @subpackage  tx_saltedpasswords
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_blowfishTest extends tx_phpunit_testcase {
 
@@ -50,7 +50,7 @@ class tx_saltedpasswords_salts_blowfishTest extends tx_phpunit_testcase {
        /**
         * Sets up the fixtures for this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function setUp() {
                $this->objectInstance = t3lib_div::makeInstance('tx_saltedpasswords_salts_blowfish');
@@ -59,7 +59,7 @@ class tx_saltedpasswords_salts_blowfishTest extends tx_phpunit_testcase {
        /**
         * Tears down objects and settings created in this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function tearDown() {
                unset($this->objectInstance);
@@ -68,7 +68,7 @@ class tx_saltedpasswords_salts_blowfishTest extends tx_phpunit_testcase {
        /**
         * Marks tests as skipped if the blowfish method is not available.
         *
-        * @return      void
+        * @return void
         */
        protected function skipTestIfBlowfishIsNotAvailable() {
                if (!CRYPT_BLOWFISH) {
index 05b48a6..c56096d 100644 (file)
 /**
  * Testcases for class tx_saltedpasswords_salts_factory.
  *
- * @author      Marcus Krause <marcus#exp2009@t3sec.info>
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
  *
- * @since      2009-09-06
- * @package     TYPO3
- * @subpackage  tx_saltedpasswords
+ * @since 2009-09-06
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_factoryTest extends tx_phpunit_testcase {
 
@@ -51,7 +51,7 @@ class tx_saltedpasswords_salts_factoryTest extends tx_phpunit_testcase {
        /**
         * Sets up the fixtures for this testcase.
         *
-        * @return      void
+        * @return void
         */
        protected function setUp() {
                $this->objectInstance = tx_saltedpasswords_salts_factory::getSaltingInstance();
@@ -60,7 +60,7 @@ class tx_saltedpasswords_salts_factoryTest extends tx_phpunit_testcase {
        /**
         * Tears down objects and settings created in this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function tearDown() {
                unset($this->objectInstance);
index 4c7f5be..794f091 100644 (file)
@@ -32,9 +32,9 @@
 /**
  * Testcases for class tx_saltedpasswords_salts_md5.
  *
- * @author  Marcus Krause <marcus#exp2009@t3sec.info>
- * @package  TYPO3
- * @subpackage  tx_saltedpasswords
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_md5Test extends tx_phpunit_testcase {
 
@@ -50,7 +50,7 @@ class tx_saltedpasswords_salts_md5Test extends tx_phpunit_testcase {
        /**
         * Sets up the fixtures for this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function setUp() {
                $this->objectInstance = t3lib_div::makeInstance('tx_saltedpasswords_salts_md5');
@@ -59,7 +59,7 @@ class tx_saltedpasswords_salts_md5Test extends tx_phpunit_testcase {
        /**
         * Tears down objects and settings created in this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function tearDown() {
                unset($this->objectInstance);
@@ -68,7 +68,7 @@ class tx_saltedpasswords_salts_md5Test extends tx_phpunit_testcase {
        /**
         * Prepares a message to be shown when a salted hashing is not supported.
         *
-        * @return  string     empty string if salted hashing method is available, otherwise an according warning
+        * @return string Empty string if salted hashing method is available, otherwise an according warning
         */
        protected function getWarningWhenMethodUnavailable() {
                $warningMsg = '';
index 857a801..e1f1498 100644 (file)
 /**
  * Testcases for class tx_saltedpasswords_salts_phpass.
  *
- * @author  Marcus Krause <marcus#exp2009@t3sec.info>
- * @package  TYPO3
- * @subpackage  tx_saltedpasswords
+ * @author Marcus Krause <marcus#exp2009@t3sec.info>
+ * @package TYPO3
+ * @subpackage tx_saltedpasswords
  */
 class tx_saltedpasswords_salts_phpassTest extends tx_phpunit_testcase {
 
-
        /**
         * Keeps instance of object to test.
         *
@@ -50,7 +49,7 @@ class tx_saltedpasswords_salts_phpassTest extends tx_phpunit_testcase {
        /**
         * Sets up the fixtures for this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function setUp() {
                $this->objectInstance = t3lib_div::makeInstance('tx_saltedpasswords_salts_phpass');
@@ -59,7 +58,7 @@ class tx_saltedpasswords_salts_phpassTest extends tx_phpunit_testcase {
        /**
         * Tears down objects and settings created in this testcase.
         *
-        * @return      void
+        * @return void
         */
        public function tearDown() {
                unset($this->objectInstance);