[!!!][TASK] Implement Salted Passwords against SaltInterface 37/52737/15
authorChristian Futterlieb <christian@futterlieb.ch>
Mon, 11 Dec 2017 07:55:32 +0000 (08:55 +0100)
committerBenni Mack <benni@typo3.org>
Tue, 12 Dec 2017 14:59:35 +0000 (15:59 +0100)
Salt classes must implement SaltInterface only. The AbstractSalt
class is renamed to AbstractComposedSalt and implements
SaltInterface. Methods for salt-classes that compose the
password-hash string themselves (which are currently all in
saltedpasswords) are moved to AbstractComposedSalt as well.

This cleanup change prepares for the integration of the
PHP password API in a following change.

Relates: #79795
Relates: #79889
Resolves: #83294
Releases: master
Change-Id: Ife24aa39be99c5ad391b0f10497a2bceb04084f3
Reviewed-on: https://review.typo3.org/52737
Reviewed-by: Stefan Neufeind <typo3.neufeind@speedpartner.de>
Tested-by: TYPO3com <no-reply@typo3.com>
Reviewed-by: Christian Kuhn <lolli@schwarzbu.ch>
Tested-by: Christian Kuhn <lolli@schwarzbu.ch>
Reviewed-by: Benni Mack <benni@typo3.org>
Tested-by: Benni Mack <benni@typo3.org>
17 files changed:
composer.json
composer.lock
typo3/sysext/core/Documentation/Changelog/9.0/Breaking-83294-SaltedPasswordsCustomSaltingsMustUseTheSaltInterface.rst [new file with mode: 0644]
typo3/sysext/saltedpasswords/Classes/Evaluation/Evaluator.php
typo3/sysext/saltedpasswords/Classes/Salt/AbstractComposedSalt.php [new file with mode: 0644]
typo3/sysext/saltedpasswords/Classes/Salt/AbstractSalt.php [deleted file]
typo3/sysext/saltedpasswords/Classes/Salt/BlowfishSalt.php
typo3/sysext/saltedpasswords/Classes/Salt/Md5Salt.php
typo3/sysext/saltedpasswords/Classes/Salt/Pbkdf2Salt.php
typo3/sysext/saltedpasswords/Classes/Salt/PhpassSalt.php
typo3/sysext/saltedpasswords/Classes/Salt/SaltFactory.php
typo3/sysext/saltedpasswords/Classes/Salt/SaltInterface.php
typo3/sysext/saltedpasswords/Classes/SaltedPasswordService.php
typo3/sysext/saltedpasswords/Documentation/DevelopersGuide/Index.rst
typo3/sysext/saltedpasswords/Migrations/Code/ClassAliasMap.php [new file with mode: 0644]
typo3/sysext/saltedpasswords/Tests/Unit/Salt/SaltFactoryTest.php
typo3/sysext/saltedpasswords/composer.json

index 6692903..c760a33 100644 (file)
@@ -84,6 +84,7 @@
                                "typo3/sysext/info/Migrations/Code/ClassAliasMap.php",
                                "typo3/sysext/lowlevel/Migrations/Code/ClassAliasMap.php",
                                "typo3/sysext/reports/Migrations/Code/ClassAliasMap.php",
+                               "typo3/sysext/saltedpasswords/Migrations/Code/ClassAliasMap.php",
                                "typo3/sysext/workspaces/Migrations/Code/ClassAliasMap.php"
                        ]
                },
index 5c96b55..bf4b2b5 100644 (file)
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
         "This file is @generated automatically"
     ],
-    "content-hash": "6b0c9ff22949275bc4d6c60fd2f62f2b",
+    "content-hash": "ee8fd70e59c3f86ff7728b866e54149c",
     "packages": [
         {
             "name": "cogpowered/finediff",
diff --git a/typo3/sysext/core/Documentation/Changelog/9.0/Breaking-83294-SaltedPasswordsCustomSaltingsMustUseTheSaltInterface.rst b/typo3/sysext/core/Documentation/Changelog/9.0/Breaking-83294-SaltedPasswordsCustomSaltingsMustUseTheSaltInterface.rst
new file mode 100644 (file)
index 0000000..ff49c77
--- /dev/null
@@ -0,0 +1,39 @@
+.. include:: ../../Includes.txt
+
+===============================================================================
+Breaking: #83294 - Salted Passwords: Custom saltings must use the SaltInterface
+===============================================================================
+
+See :issue:`83294`
+
+Description
+===========
+
+The salted passwords factory allowed to register custom saltings has been changed. All custom salts
+need to implement :php:`TYPO3\CMS\SaltedPasswords\Salt\SaltInterface`. Before, this was
+handled by extending from :php:`TYPO3\CMS\SaltedPasswords\Salt\AbstractSalt`, which has been renamed to
+:php:`TYPO3\CMS\SaltedPasswords\Salt\AbstractComposedSalt` when the salting is implemented.
+
+
+Impact
+======
+
+When writing custom salts for TYPO3, they need to implement the SaltInterface.
+
+If extending from :php:`AbstractSalt`, custom salt now need to extend from :php:`AbstractComposedSalt` and
+implement the additional method :php:`getSaltLength()` and :php:`isValidSalt($salt)`.
+
+
+Affected Installations
+======================
+
+TYPO3 installations using custom salts for `EXT:saltedpasswords`.
+
+
+Migration
+=========
+
+Switch to the new implemention details mentioned above, and change your custom salt to fit
+to the :php:`SaltInterface` API.
+
+.. index:: PHP-API, NotScanned
\ No newline at end of file
index 4d33b28..58ecf7f 100644 (file)
@@ -14,6 +14,9 @@ namespace TYPO3\CMS\Saltedpasswords\Evaluation;
  * The TYPO3 project - inspiring people to share!
  */
 
+use TYPO3\CMS\Saltedpasswords\Salt\SaltFactory;
+use TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility;
+
 /**
  * Class implementing salted evaluation methods.
  */
@@ -49,20 +52,19 @@ class Evaluator
      */
     public function evaluateFieldValue($value, $is_in, &$set)
     {
-        $isEnabled = $this->mode ? \TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility::isUsageEnabled($this->mode) : \TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility::isUsageEnabled();
+        $isEnabled = $this->mode ? SaltedPasswordsUtility::isUsageEnabled($this->mode) : SaltedPasswordsUtility::isUsageEnabled();
         if ($isEnabled) {
             $isMD5 = preg_match('/[0-9abcdef]{32,32}/', $value);
             $hashingMethod = substr($value, 0, 2);
             $isDeprecatedSaltedHash = ($hashingMethod === 'C$' || $hashingMethod === 'M$');
-            /** @var $objInstanceSaltedPW \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface */
-            $objInstanceSaltedPW = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance(null, $this->mode);
+            $objInstanceSaltedPW = SaltFactory::getSaltingInstance(null, $this->mode);
             if ($isMD5) {
                 $set = true;
                 $value = 'M' . $objInstanceSaltedPW->getHashedPassword($value);
             } else {
                 // Determine method used for the (possibly) salted hashed password
                 $tempValue = $isDeprecatedSaltedHash ? substr($value, 1) : $value;
-                $tempObjInstanceSaltedPW = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance($tempValue);
+                $tempObjInstanceSaltedPW = SaltFactory::getSaltingInstance($tempValue);
                 if (!is_object($tempObjInstanceSaltedPW)) {
                     $set = true;
                     $value = $objInstanceSaltedPW->getHashedPassword($value);
diff --git a/typo3/sysext/saltedpasswords/Classes/Salt/AbstractComposedSalt.php b/typo3/sysext/saltedpasswords/Classes/Salt/AbstractComposedSalt.php
new file mode 100644 (file)
index 0000000..3d1829f
--- /dev/null
@@ -0,0 +1,115 @@
+<?php
+declare(strict_types=1);
+namespace TYPO3\CMS\Saltedpasswords\Salt;
+
+/*
+ * This file is part of the TYPO3 CMS project.
+ *
+ * It is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, either version 2
+ * of the License, or any later version.
+ *
+ * For the full copyright and license information, please read the
+ * LICENSE.txt file that was distributed with this source code.
+ *
+ * The TYPO3 project - inspiring people to share!
+ */
+
+/**
+ * Abstract class with methods needed to be extended
+ * in a salted hashing class that composes an own salted password hash.
+ */
+abstract class AbstractComposedSalt implements SaltInterface
+{
+    /**
+     * 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
+     */
+    abstract protected function applySettingsToSalt(string $salt): string;
+
+    /**
+     * Generates a random base salt settings for the hash.
+     *
+     * @return string A string containing settings and a random salt
+     */
+    abstract protected function getGeneratedSalt(): string;
+
+    /**
+     * 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
+     */
+    abstract protected function getItoa64(): string;
+
+    /**
+     * Returns setting string to indicate type of hashing method.
+     *
+     * @return string Setting string of hashing method
+     */
+    abstract protected function getSetting(): string;
+
+    /**
+     * Returns length of required salt.
+     *
+     * @return int Length of required salt
+     */
+    abstract public function getSaltLength(): int;
+
+    /**
+     * Method determines if a given string is a valid salt
+     *
+     * @param string $salt String to check
+     * @return bool TRUE if it's valid salt, otherwise FALSE
+     */
+    abstract public function isValidSalt(string $salt): bool;
+
+    /**
+     * Encodes bytes into printable base 64 using the *nix standard from crypt().
+     *
+     * @param string $input The string containing bytes to encode.
+     * @param int $count The number of characters (bytes) to encode.
+     * @return string Encoded string
+     */
+    public function base64Encode(string $input, int $count): string
+    {
+        $output = '';
+        $i = 0;
+        $itoa64 = $this->getItoa64();
+        do {
+            $value = ord($input[$i++]);
+            $output .= $itoa64[$value & 63];
+            if ($i < $count) {
+                $value |= ord($input[$i]) << 8;
+            }
+            $output .= $itoa64[$value >> 6 & 63];
+            if ($i++ >= $count) {
+                break;
+            }
+            if ($i < $count) {
+                $value |= ord($input[$i]) << 16;
+            }
+            $output .= $itoa64[$value >> 12 & 63];
+            if ($i++ >= $count) {
+                break;
+            }
+            $output .= $itoa64[$value >> 18 & 63];
+        } while ($i < $count);
+        return $output;
+    }
+
+    /**
+     * Method determines required length of base64 characters for a given
+     * length of a byte string.
+     *
+     * @param int $byteLength Length of bytes to calculate in base64 chars
+     * @return int Required length of base64 characters
+     */
+    protected function getLengthBase64FromBytes(int $byteLength): int
+    {
+        // Calculates bytes in bits in base64
+        return (int)ceil($byteLength * 8 / 6);
+    }
+}
diff --git a/typo3/sysext/saltedpasswords/Classes/Salt/AbstractSalt.php b/typo3/sysext/saltedpasswords/Classes/Salt/AbstractSalt.php
deleted file mode 100644 (file)
index 069df62..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-<?php
-namespace TYPO3\CMS\Saltedpasswords\Salt;
-
-/*
- * This file is part of the TYPO3 CMS project.
- *
- * It is free software; you can redistribute it and/or modify it under
- * the terms of the GNU General Public License, either version 2
- * of the License, or any later version.
- *
- * For the full copyright and license information, please read the
- * LICENSE.txt file that was distributed with this source code.
- *
- * The TYPO3 project - inspiring people to share!
- */
-
-/**
- * Abstract class with methods needed to be extended
- * in a salted hashing class.
- */
-abstract class AbstractSalt
-{
-    /**
-     * 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
-     */
-    abstract protected function applySettingsToSalt($salt);
-
-    /**
-     * Generates a random base salt settings for the hash.
-     *
-     * @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
-     */
-    abstract protected function getItoa64();
-
-    /**
-     * Returns setting string to indicate type 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 int $count The number of characters (bytes) to encode.
-     * @return string Encoded string
-     */
-    public function base64Encode($input, $count)
-    {
-        $output = '';
-        $i = 0;
-        $itoa64 = $this->getItoa64();
-        do {
-            $value = ord($input[$i++]);
-            $output .= $itoa64[$value & 63];
-            if ($i < $count) {
-                $value |= ord($input[$i]) << 8;
-            }
-            $output .= $itoa64[$value >> 6 & 63];
-            if ($i++ >= $count) {
-                break;
-            }
-            if ($i < $count) {
-                $value |= ord($input[$i]) << 16;
-            }
-            $output .= $itoa64[$value >> 12 & 63];
-            if ($i++ >= $count) {
-                break;
-            }
-            $output .= $itoa64[$value >> 18 & 63];
-        } while ($i < $count);
-        return $output;
-    }
-
-    /**
-     * Method determines required length of base64 characters for a given
-     * length of a byte string.
-     *
-     * @param int $byteLength Length of bytes to calculate in base64 chars
-     * @return int Required length of base64 characters
-     */
-    protected function getLengthBase64FromBytes($byteLength)
-    {
-        // Calculates bytes in bits in base64
-        return (int)ceil($byteLength * 8 / 6);
-    }
-}
index 18cdbb2..58b0cd6 100644 (file)
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace TYPO3\CMS\Saltedpasswords\Salt;
 
 /*
@@ -87,7 +88,7 @@ class BlowfishSalt extends Md5Salt
      * @param string $salt A salt to apply setting to
      * @return string Salt with setting
      */
-    protected function applySettingsToSalt($salt)
+    protected function applySettingsToSalt(string $salt): string
     {
         $saltWithSettings = $salt;
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -104,7 +105,7 @@ class BlowfishSalt extends Md5Salt
      * @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
      */
-    protected function getCountLog2($setting)
+    protected function getCountLog2(string $setting): int
     {
         $countLog2 = null;
         $setting = substr($setting, strlen($this->getSetting()));
@@ -124,7 +125,7 @@ class BlowfishSalt extends Md5Salt
      * @see $hashCount
      * @see setHashCount()
      */
-    public function getHashCount()
+    public function getHashCount(): int
     {
         return isset(self::$hashCount) ? self::$hashCount : self::HASH_COUNT;
     }
@@ -137,7 +138,7 @@ class BlowfishSalt extends Md5Salt
      * @see $maxHashCount
      * @see setMaxHashCount()
      */
-    public function getMaxHashCount()
+    public function getMaxHashCount(): int
     {
         return isset(self::$maxHashCount) ? self::$maxHashCount : self::MAX_HASH_COUNT;
     }
@@ -147,9 +148,9 @@ class BlowfishSalt extends Md5Salt
      *
      * @return bool Method available
      */
-    public function isAvailable()
+    public function isAvailable(): bool
     {
-        return CRYPT_BLOWFISH;
+        return (bool)CRYPT_BLOWFISH;
     }
 
     /**
@@ -160,7 +161,7 @@ class BlowfishSalt extends Md5Salt
      * @see $minHashCount
      * @see setMinHashCount()
      */
-    public function getMinHashCount()
+    public function getMinHashCount(): int
     {
         return isset(self::$minHashCount) ? self::$minHashCount : self::MIN_HASH_COUNT;
     }
@@ -173,7 +174,7 @@ class BlowfishSalt extends Md5Salt
      *
      * @return int Length of a Blowfish salt in bytes
      */
-    public function getSaltLength()
+    public function getSaltLength(): int
     {
         return self::$saltLengthBlowfish;
     }
@@ -186,7 +187,7 @@ class BlowfishSalt extends Md5Salt
      *
      * @return string Setting string of Blowfish salted hashes
      */
-    public function getSetting()
+    public function getSetting(): string
     {
         return self::$settingBlowfish;
     }
@@ -202,7 +203,7 @@ class BlowfishSalt extends Md5Salt
      * @param string $saltedPW Salted hash to check if it needs an update
      * @return bool TRUE if salted hash needs an update, otherwise FALSE
      */
-    public function isHashUpdateNeeded($saltedPW)
+    public function isHashUpdateNeeded(string $saltedPW): bool
     {
         // Check whether this was an updated password.
         if (strncmp($saltedPW, '$2', 2) || !$this->isValidSalt($saltedPW)) {
@@ -222,7 +223,7 @@ class BlowfishSalt extends Md5Salt
      * @param string $salt String to check
      * @return bool TRUE if it's valid salt, otherwise FALSE
      */
-    public function isValidSalt($salt)
+    public function isValidSalt(string $salt): bool
     {
         $isValid = ($skip = false);
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -252,7 +253,7 @@ class BlowfishSalt extends Md5Salt
      * @param string $saltedPW String to check
      * @return bool TRUE if it's valid salted hashed password, otherwise FALSE
      */
-    public function isValidSaltedPW($saltedPW)
+    public function isValidSaltedPW(string $saltedPW): bool
     {
         $isValid = !strncmp($this->getSetting(), $saltedPW, strlen($this->getSetting()));
         if ($isValid) {
@@ -269,9 +270,9 @@ class BlowfishSalt extends Md5Salt
      * @see $hashCount
      * @see getHashCount()
      */
-    public function setHashCount($hashCount = null)
+    public function setHashCount(int $hashCount = null)
     {
-        self::$hashCount = !is_null($hashCount) && is_int($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
+        self::$hashCount = !is_null($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
     }
 
     /**
@@ -282,9 +283,9 @@ class BlowfishSalt extends Md5Salt
      * @see $maxHashCount
      * @see getMaxHashCount()
      */
-    public function setMaxHashCount($maxHashCount = null)
+    public function setMaxHashCount(int $maxHashCount = null)
     {
-        self::$maxHashCount = !is_null($maxHashCount) && is_int($maxHashCount) ? $maxHashCount : self::MAX_HASH_COUNT;
+        self::$maxHashCount = $maxHashCount ?? self::MAX_HASH_COUNT;
     }
 
     /**
@@ -295,8 +296,8 @@ class BlowfishSalt extends Md5Salt
      * @see $minHashCount
      * @see getMinHashCount()
      */
-    public function setMinHashCount($minHashCount = null)
+    public function setMinHashCount(int $minHashCount = null)
     {
-        self::$minHashCount = !is_null($minHashCount) && is_int($minHashCount) ? $minHashCount : self::MIN_HASH_COUNT;
+        self::$minHashCount = $minHashCount ?? self::MIN_HASH_COUNT;
     }
 }
index 0543b43..fb5576c 100644 (file)
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace TYPO3\CMS\Saltedpasswords\Salt;
 
 /*
@@ -24,7 +25,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
  * MD5 salted hashing with PHP's crypt() should be available
  * on most of the systems.
  */
-class Md5Salt extends AbstractSalt implements SaltInterface
+class Md5Salt extends AbstractComposedSalt
 {
     /**
      * Keeps a string for mapping an int to the corresponding
@@ -59,7 +60,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      * @param string $salt A salt to apply setting to
      * @return string Salt with setting
      */
-    protected function applySettingsToSalt($salt)
+    protected function applySettingsToSalt(string $salt): string
     {
         $saltWithSettings = $salt;
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -78,7 +79,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      * @param string $saltedHashPW salted hash to compare plain-text password with
      * @return bool TRUE, if plain-text password matches the salted hash, otherwise FALSE
      */
-    public function checkPassword($plainPW, $saltedHashPW)
+    public function checkPassword(string $plainPW, string $saltedHashPW): bool
     {
         $isCorrect = false;
         if ($this->isValidSalt($saltedHashPW)) {
@@ -98,7 +99,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      *
      * @return string A character string containing settings and a random salt
      */
-    protected function getGeneratedSalt()
+    protected function getGeneratedSalt(): string
     {
         $randomBytes = GeneralUtility::makeInstance(Random::class)->generateRandomBytes($this->getSaltLength());
         return $this->base64Encode($randomBytes, $this->getSaltLength());
@@ -111,7 +112,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      * @param string $salt Optional custom salt with setting to use
      * @return string Salted hashed password
      */
-    public function getHashedPassword($password, $salt = null)
+    public function getHashedPassword(string $password, string $salt = null)
     {
         $saltedPW = null;
         if (!empty($password)) {
@@ -128,7 +129,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      *
      * @return string String for mapping an int to the corresponding base 64 character
      */
-    protected function getItoa64()
+    protected function getItoa64(): string
     {
         return self::ITOA64;
     }
@@ -138,9 +139,9 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      *
      * @return bool Method available
      */
-    public function isAvailable()
+    public function isAvailable(): bool
     {
-        return CRYPT_MD5;
+        return (bool)CRYPT_MD5;
     }
 
     /**
@@ -148,7 +149,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      *
      * @return int Length of a MD5 salt in bytes
      */
-    public function getSaltLength()
+    public function getSaltLength(): int
     {
         return self::$saltLengthMD5;
     }
@@ -158,7 +159,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      *
      * @return string Suffix of a salt
      */
-    protected function getSaltSuffix()
+    protected function getSaltSuffix(): string
     {
         return self::$saltSuffixMD5;
     }
@@ -168,7 +169,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      *
      * @return string Setting string of MD5 salted hashes
      */
-    public function getSetting()
+    public function getSetting(): string
     {
         return self::$settingMD5;
     }
@@ -185,7 +186,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      * @param string $passString Salted hash to check if it needs an update
      * @return bool TRUE if salted hash needs an update, otherwise FALSE
      */
-    public function isHashUpdateNeeded($passString)
+    public function isHashUpdateNeeded(string $passString): bool
     {
         return false;
     }
@@ -196,7 +197,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      * @param string $salt String to check
      * @return bool TRUE if it's valid salt, otherwise FALSE
      */
-    public function isValidSalt($salt)
+    public function isValidSalt(string $salt): bool
     {
         $isValid = ($skip = false);
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -226,7 +227,7 @@ class Md5Salt extends AbstractSalt implements SaltInterface
      * @param string $saltedPW String to check
      * @return bool TRUE if it's valid salted hashed password, otherwise FALSE
      */
-    public function isValidSaltedPW($saltedPW)
+    public function isValidSaltedPW(string $saltedPW): bool
     {
         $isValid = !strncmp($this->getSetting(), $saltedPW, strlen($this->getSetting()));
         if ($isValid) {
index 5578472..ab80faa 100644 (file)
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace TYPO3\CMS\Saltedpasswords\Salt;
 
 /*
@@ -21,7 +22,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
  * Class that implements PBKDF2 salted hashing based on PHP's
  * hash_pbkdf2() function.
  */
-class Pbkdf2Salt extends AbstractSalt implements SaltInterface
+class Pbkdf2Salt extends AbstractComposedSalt
 {
     /**
      * Keeps a string for mapping an int to the corresponding
@@ -88,7 +89,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $salt A salt to apply setting to
      * @return string Salt with setting
      */
-    protected function applySettingsToSalt($salt)
+    protected function applySettingsToSalt(string $salt): string
     {
         $saltWithSettings = $salt;
         // salt without setting
@@ -106,7 +107,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $saltedHashPW salted hash to compare plain-text password with
      * @return bool TRUE, if plain-text password matches the salted hash, otherwise FALSE
      */
-    public function checkPassword($plainPW, $saltedHashPW)
+    public function checkPassword(string $plainPW, string $saltedHashPW): bool
     {
         return $this->isValidSalt($saltedHashPW) && \hash_equals($this->getHashedPassword($plainPW, $saltedHashPW), $saltedHashPW);
     }
@@ -117,7 +118,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $setting Complete hash or a hash's setting string or to get log2 iteration count from
      * @return int|null Used hashcount for given hash string
      */
-    protected function getIterationCount($setting)
+    protected function getIterationCount(string $setting)
     {
         $iterationCount = null;
         $setting = substr($setting, strlen($this->getSetting()));
@@ -143,7 +144,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      *
      * @return string A character string containing settings and a random salt
      */
-    protected function getGeneratedSalt()
+    protected function getGeneratedSalt(): string
     {
         return GeneralUtility::makeInstance(Random::class)->generateRandomBytes($this->getSaltLength());
     }
@@ -155,7 +156,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $salt
      * @return string
      */
-    protected function getStoredSalt($salt)
+    protected function getStoredSalt(string $salt): string
     {
         if (!strncmp('$', $salt, 1)) {
             if (!strncmp($this->getSetting(), $salt, strlen($this->getSetting()))) {
@@ -171,7 +172,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      *
      * @return string String for mapping an int to the corresponding base 64 character
      */
-    protected function getItoa64()
+    protected function getItoa64(): string
     {
         return self::ITOA64;
     }
@@ -183,7 +184,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $salt Optional custom salt with setting to use
      * @return string|null Salted hashed password
      */
-    public function getHashedPassword($password, $salt = null)
+    public function getHashedPassword(string $password, string $salt = null)
     {
         $saltedPW = null;
         if ($password !== '') {
@@ -207,7 +208,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @see $hashCount
      * @see setHashCount()
      */
-    public function getHashCount()
+    public function getHashCount(): int
     {
         return isset(self::$hashCount) ? self::$hashCount : self::HASH_COUNT;
     }
@@ -220,7 +221,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @see $maxHashCount
      * @see setMaxHashCount()
      */
-    public function getMaxHashCount()
+    public function getMaxHashCount(): int
     {
         return isset(self::$maxHashCount) ? self::$maxHashCount : self::MAX_HASH_COUNT;
     }
@@ -230,7 +231,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      *
      * @return bool Method available
      */
-    public function isAvailable()
+    public function isAvailable(): bool
     {
         return function_exists('hash_pbkdf2');
     }
@@ -243,7 +244,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @see $minHashCount
      * @see setMinHashCount()
      */
-    public function getMinHashCount()
+    public function getMinHashCount(): int
     {
         return isset(self::$minHashCount) ? self::$minHashCount : self::MIN_HASH_COUNT;
     }
@@ -256,7 +257,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      *
      * @return int Length of a PBKDF2 salt in bytes
      */
-    public function getSaltLength()
+    public function getSaltLength(): int
     {
         return self::$saltLengthPbkdf2;
     }
@@ -269,7 +270,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      *
      * @return string Setting string of PBKDF2 salted hashes
      */
-    public function getSetting()
+    public function getSetting(): string
     {
         return self::$settingPbkdf2;
     }
@@ -285,7 +286,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $saltedPW Salted hash to check if it needs an update
      * @return bool TRUE if salted hash needs an update, otherwise FALSE
      */
-    public function isHashUpdateNeeded($saltedPW)
+    public function isHashUpdateNeeded(string $saltedPW): bool
     {
         // Check whether this was an updated password.
         if (strncmp($saltedPW, $this->getSetting(), strlen($this->getSetting())) || !$this->isValidSalt($saltedPW)) {
@@ -305,7 +306,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $salt String to check
      * @return bool TRUE if it's valid salt, otherwise FALSE
      */
-    public function isValidSalt($salt)
+    public function isValidSalt(string $salt): bool
     {
         $isValid = ($skip = false);
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -335,7 +336,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $saltedPW String to check
      * @return bool TRUE if it's valid salted hashed password, otherwise FALSE
      */
-    public function isValidSaltedPW($saltedPW)
+    public function isValidSaltedPW(string $saltedPW): bool
     {
         $isValid = !strncmp($this->getSetting(), $saltedPW, strlen($this->getSetting()));
         if ($isValid) {
@@ -352,9 +353,9 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @see $hashCount
      * @see getHashCount()
      */
-    public function setHashCount($hashCount = null)
+    public function setHashCount(int $hashCount = null)
     {
-        self::$hashCount = !is_null($hashCount) && is_int($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
+        self::$hashCount = !is_null($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
     }
 
     /**
@@ -365,9 +366,9 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @see $maxHashCount
      * @see getMaxHashCount()
      */
-    public function setMaxHashCount($maxHashCount = null)
+    public function setMaxHashCount(int $maxHashCount = null)
     {
-        self::$maxHashCount = !is_null($maxHashCount) && is_int($maxHashCount) ? $maxHashCount : self::MAX_HASH_COUNT;
+        self::$maxHashCount = $maxHashCount ?? self::MAX_HASH_COUNT;
     }
 
     /**
@@ -378,9 +379,9 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @see $minHashCount
      * @see getMinHashCount()
      */
-    public function setMinHashCount($minHashCount = null)
+    public function setMinHashCount(int $minHashCount = null)
     {
-        self::$minHashCount = !is_null($minHashCount) && is_int($minHashCount) ? $minHashCount : self::MIN_HASH_COUNT;
+        self::$minHashCount = $minHashCount ?? self::MIN_HASH_COUNT;
     }
 
     /**
@@ -391,7 +392,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param int $count The number of characters (bytes) to encode.
      * @return string Encoded string
      */
-    public function base64Encode($input, $count)
+    public function base64Encode(string $input, int $count): string
     {
         $input = substr($input, 0, $count);
         return rtrim(str_replace('+', '.', base64_encode($input)), " =\r\n\t\0\x0B");
@@ -404,7 +405,7 @@ class Pbkdf2Salt extends AbstractSalt implements SaltInterface
      * @param string $value
      * @return string
      */
-    public function base64Decode($value)
+    public function base64Decode(string $value): string
     {
         return base64_decode(str_replace('.', '+', $value));
     }
index 89d93cb..9dcf084 100644 (file)
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace TYPO3\CMS\Saltedpasswords\Salt;
 
 /*
@@ -28,7 +29,7 @@ use TYPO3\CMS\Core\Utility\GeneralUtility;
  * @see http://drupal.org/node/29706/
  * @see http://www.openwall.com/phpass/
  */
-class PhpassSalt extends AbstractSalt implements SaltInterface
+class PhpassSalt extends AbstractComposedSalt
 {
     /**
      * Keeps a string for mapping an int to the corresponding
@@ -100,7 +101,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @param string $salt A salt to apply setting to
      * @return string Salt with setting
      */
-    protected function applySettingsToSalt($salt)
+    protected function applySettingsToSalt(string $salt): string
     {
         $saltWithSettings = $salt;
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -122,7 +123,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @param string $saltedHashPW Salted hash to compare plain-text password with
      * @return bool TRUE, if plain-text password matches the salted hash, otherwise FALSE
      */
-    public function checkPassword($plainPW, $saltedHashPW)
+    public function checkPassword(string $plainPW, string $saltedHashPW): bool
     {
         $hash = $this->cryptPassword($plainPW, $saltedHashPW);
         return $hash && \hash_equals($hash, $saltedHashPW);
@@ -133,7 +134,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      *
      * @return bool Method available
      */
-    public function isAvailable()
+    public function isAvailable(): bool
     {
         return true;
     }
@@ -150,7 +151,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @param string $setting An existing hash or the output of getGeneratedSalt()
      * @return mixed A string containing the hashed password (and salt)
      */
-    protected function cryptPassword($password, $setting)
+    protected function cryptPassword(string $password, string $setting)
     {
         $saltedPW = null;
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -183,7 +184,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @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
      */
-    protected function getCountLog2($setting)
+    protected function getCountLog2(string $setting): int
     {
         return strpos($this->getItoa64(), $setting[strlen($this->getSetting())]);
     }
@@ -199,7 +200,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      *
      * @return string A character string containing settings and a random salt
      */
-    protected function getGeneratedSalt()
+    protected function getGeneratedSalt(): string
     {
         $randomBytes = GeneralUtility::makeInstance(Random::class)->generateRandomBytes($this->getSaltLength());
         return $this->base64Encode($randomBytes, $this->getSaltLength());
@@ -213,7 +214,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @see $hashCount
      * @see setHashCount()
      */
-    public function getHashCount()
+    public function getHashCount(): int
     {
         return isset(self::$hashCount) ? self::$hashCount : self::HASH_COUNT;
     }
@@ -223,9 +224,9 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      *
      * @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
+     * @return string|null salted hashed password
      */
-    public function getHashedPassword($password, $salt = null)
+    public function getHashedPassword(string $password, string $salt = null)
     {
         $saltedPW = null;
         if (!empty($password)) {
@@ -242,7 +243,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      *
      * @return string String for mapping an int to the corresponding base 64 character
      */
-    protected function getItoa64()
+    protected function getItoa64(): string
     {
         return self::ITOA64;
     }
@@ -255,7 +256,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @see $maxHashCount
      * @see setMaxHashCount()
      */
-    public function getMaxHashCount()
+    public function getMaxHashCount(): int
     {
         return isset(self::$maxHashCount) ? self::$maxHashCount : self::MAX_HASH_COUNT;
     }
@@ -268,7 +269,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @see $minHashCount
      * @see setMinHashCount()
      */
-    public function getMinHashCount()
+    public function getMinHashCount(): int
     {
         return isset(self::$minHashCount) ? self::$minHashCount : self::MIN_HASH_COUNT;
     }
@@ -278,7 +279,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      *
      * @return int Length of a Blowfish salt in bytes
      */
-    public function getSaltLength()
+    public function getSaltLength(): int
     {
         return self::$saltLengthPhpass;
     }
@@ -288,7 +289,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      *
      * @return string Setting string of PHPass salted hashes
      */
-    public function getSetting()
+    public function getSetting(): string
     {
         return self::$settingPhpass;
     }
@@ -305,7 +306,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @param string $passString Salted hash to check if it needs an update
      * @return bool TRUE if salted hash needs an update, otherwise FALSE
      */
-    public function isHashUpdateNeeded($passString)
+    public function isHashUpdateNeeded(string $passString): bool
     {
         // Check whether this was an updated password.
         if (strncmp($passString, '$P$', 3) || strlen($passString) != 34) {
@@ -321,7 +322,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @param string $salt String to check
      * @return bool TRUE if it's valid salt, otherwise FALSE
      */
-    public function isValidSalt($salt)
+    public function isValidSalt(string $salt): bool
     {
         $isValid = ($skip = false);
         $reqLenBase64 = $this->getLengthBase64FromBytes($this->getSaltLength());
@@ -351,7 +352,7 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @param string $saltedPW String to check
      * @return bool TRUE if it's valid salted hashed password, otherwise FALSE
      */
-    public function isValidSaltedPW($saltedPW)
+    public function isValidSaltedPW(string $saltedPW): bool
     {
         $isValid = !strncmp($this->getSetting(), $saltedPW, strlen($this->getSetting()));
         if ($isValid) {
@@ -368,9 +369,9 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @see $hashCount
      * @see getHashCount()
      */
-    public function setHashCount($hashCount = null)
+    public function setHashCount(int $hashCount = null)
     {
-        self::$hashCount = !is_null($hashCount) && is_int($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
+        self::$hashCount = !is_null($hashCount) && $hashCount >= $this->getMinHashCount() && $hashCount <= $this->getMaxHashCount() ? $hashCount : self::HASH_COUNT;
     }
 
     /**
@@ -381,9 +382,9 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @see $maxHashCount
      * @see getMaxHashCount()
      */
-    public function setMaxHashCount($maxHashCount = null)
+    public function setMaxHashCount(int $maxHashCount = null)
     {
-        self::$maxHashCount = !is_null($maxHashCount) && is_int($maxHashCount) ? $maxHashCount : self::MAX_HASH_COUNT;
+        self::$maxHashCount = $maxHashCount ?? self::MAX_HASH_COUNT;
     }
 
     /**
@@ -394,8 +395,8 @@ class PhpassSalt extends AbstractSalt implements SaltInterface
      * @see $minHashCount
      * @see getMinHashCount()
      */
-    public function setMinHashCount($minHashCount = null)
+    public function setMinHashCount(int $minHashCount = null)
     {
-        self::$minHashCount = !is_null($minHashCount) && is_int($minHashCount) ? $minHashCount : self::MIN_HASH_COUNT;
+        self::$minHashCount = $minHashCount ?? self::MIN_HASH_COUNT;
     }
 }
index c8888a3..359bb2e 100644 (file)
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace TYPO3\CMS\Saltedpasswords\Salt;
 
 /*
@@ -14,6 +15,9 @@ namespace TYPO3\CMS\Saltedpasswords\Salt;
  * The TYPO3 project - inspiring people to share!
  */
 
+use TYPO3\CMS\Core\Utility\GeneralUtility;
+use TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility;
+
 /**
  * Class that implements Blowfish salted hashing based on PHP's
  * crypt() function.
@@ -24,7 +28,7 @@ class SaltFactory
      * An instance of the salted hashing method.
      * This member is set in the getSaltingInstance() function.
      *
-     * @var \TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt
+     * @var SaltInterface
      */
     protected static $instance = null;
 
@@ -34,7 +38,7 @@ class SaltFactory
      *
      * @return array
      */
-    public static function getRegisteredSaltedHashingMethods()
+    public static function getRegisteredSaltedHashingMethods(): array
     {
         $saltMethods = static::getDefaultSaltMethods();
         if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/saltedpasswords']['saltMethods'])) {
@@ -58,13 +62,13 @@ class SaltFactory
      *
      * @return array
      */
-    protected static function getDefaultSaltMethods()
+    protected static function getDefaultSaltMethods(): array
     {
         return [
-            \TYPO3\CMS\Saltedpasswords\Salt\Md5Salt::class => \TYPO3\CMS\Saltedpasswords\Salt\Md5Salt::class,
-            \TYPO3\CMS\Saltedpasswords\Salt\BlowfishSalt::class => \TYPO3\CMS\Saltedpasswords\Salt\BlowfishSalt::class,
-            \TYPO3\CMS\Saltedpasswords\Salt\PhpassSalt::class => \TYPO3\CMS\Saltedpasswords\Salt\PhpassSalt::class,
-            \TYPO3\CMS\Saltedpasswords\Salt\Pbkdf2Salt::class => \TYPO3\CMS\Saltedpasswords\Salt\Pbkdf2Salt::class
+            Md5Salt::class => Md5Salt::class,
+            BlowfishSalt::class => BlowfishSalt::class,
+            PhpassSalt::class => PhpassSalt::class,
+            Pbkdf2Salt::class => Pbkdf2Salt::class
         ];
     }
 
@@ -78,7 +82,7 @@ class SaltFactory
      *
      * @param string|null $saltedHash Salted hashed password to determine the type of used method from or NULL to reset to the default type
      * @param string $mode The TYPO3 mode (FE or BE) saltedpasswords shall be used for
-     * @return SaltInterface An instance of salting hash method class
+     * @return SaltInterface|null An instance of salting hash method class or null if given hash is not supported
      */
     public static function getSaltingInstance($saltedHash = '', $mode = TYPO3_MODE)
     {
@@ -94,9 +98,9 @@ class SaltFactory
                     self::$instance = null;
                 }
             } else {
-                $classNameToUse = \TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility::getDefaultSaltingHashingMethod($mode);
+                $classNameToUse = SaltedPasswordsUtility::getDefaultSaltingHashingMethod($mode);
                 $availableClasses = static::getRegisteredSaltedHashingMethods();
-                self::$instance = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance($availableClasses[$classNameToUse]);
+                self::$instance = GeneralUtility::makeInstance($availableClasses[$classNameToUse]);
             }
         }
         return self::$instance;
@@ -111,17 +115,17 @@ class SaltFactory
      * @param string $mode (optional) The TYPO3 mode (FE or BE) saltedpasswords shall be used for
      * @return bool TRUE, if salting hashing method has been found, otherwise FALSE
      */
-    public static function determineSaltingHashingMethod($saltedHash, $mode = TYPO3_MODE)
+    public static function determineSaltingHashingMethod(string $saltedHash, $mode = TYPO3_MODE): bool
     {
         $registeredMethods = static::getRegisteredSaltedHashingMethods();
-        $defaultClassName = \TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility::getDefaultSaltingHashingMethod($mode);
+        $defaultClassName = SaltedPasswordsUtility::getDefaultSaltingHashingMethod($mode);
         $defaultReference = $registeredMethods[$defaultClassName];
         unset($registeredMethods[$defaultClassName]);
         // place the default method first in the order
         $registeredMethods = [$defaultClassName => $defaultReference] + $registeredMethods;
         $methodFound = false;
         foreach ($registeredMethods as $method) {
-            $objectInstance = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance($method);
+            $objectInstance = GeneralUtility::makeInstance($method);
             if ($objectInstance instanceof SaltInterface) {
                 $methodFound = $objectInstance->isValidSaltedPW($saltedHash);
                 if ($methodFound) {
@@ -137,13 +141,13 @@ class SaltFactory
      * Method sets a custom salting hashing method class.
      *
      * @param string $resource Object resource to use (e.g. \TYPO3\CMS\Saltedpasswords\Salt\BlowfishSalt::class)
-     * @return \TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt An instance of salting hashing method object
+     * @return SaltInterface|null An instance of salting hashing method object or null
      */
-    public static function setPreferredHashingMethod($resource)
+    public static function setPreferredHashingMethod(string $resource)
     {
         self::$instance = null;
-        $objectInstance = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance($resource);
-        if (is_object($objectInstance) && is_subclass_of($objectInstance, \TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt::class)) {
+        $objectInstance = GeneralUtility::makeInstance($resource);
+        if ($objectInstance instanceof SaltInterface) {
             self::$instance = $objectInstance;
         }
         return self::$instance;
index 83022ef..fac7ea5 100644 (file)
@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 namespace TYPO3\CMS\Saltedpasswords\Salt;
 
 /*
@@ -28,21 +29,14 @@ interface SaltInterface
      * @param string $saltedHashPW Salted hash to compare plain-text password with
      * @return bool TRUE, if plaintext password is correct, otherwise FALSE
      */
-    public function checkPassword($plainPW, $saltedHashPW);
-
-    /**
-     * Returns length of required salt.
-     *
-     * @return int Length of required salt
-     */
-    public function getSaltLength();
+    public function checkPassword(string $plainPW, string $saltedHashPW): bool;
 
     /**
      * Returns whether all prequesites for the hashing methods are matched
      *
      * @return bool Method available
      */
-    public function isAvailable();
+    public function isAvailable(): bool;
 
     /**
      * Method creates a salted hash for a given plaintext password
@@ -51,7 +45,7 @@ interface SaltInterface
      * @param string $salt Optional custom salt to use
      * @return string Salted hashed password
      */
-    public function getHashedPassword($password, $salt = null);
+    public function getHashedPassword(string $password, string $salt = null);
 
     /**
      * Checks whether a user's hashed password needs to be replaced with a new hash.
@@ -65,15 +59,7 @@ interface SaltInterface
      * @param string $passString Salted hash to check if it needs an update
      * @return bool 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 bool TRUE if it's valid salt, otherwise FALSE
-     */
-    public function isValidSalt($salt);
+    public function isHashUpdateNeeded(string $passString): bool;
 
     /**
      * Method determines if a given string is a valid salted hashed password.
@@ -81,5 +67,5 @@ interface SaltInterface
      * @param string $saltedPW String to check
      * @return bool TRUE if it's valid salted hashed password, otherwise FALSE
      */
-    public function isValidSaltedPW($saltedPW);
+    public function isValidSaltedPW(string $saltedPW): bool;
 }
index 60f44fd..e8d1e49 100644 (file)
@@ -50,7 +50,7 @@ class SaltedPasswordService extends AbstractAuthenticationService
      * An instance of the salted hashing method.
      * This member is set in the getSaltingInstance() function.
      *
-     * @var \TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt
+     * @var \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface
      */
     protected $objInstanceSaltedPW = null;
 
index b027deb..6f46e4d 100644 (file)
@@ -93,8 +93,10 @@ such additional method available for this extension.
 Steps to be done:
 
 - create a new salting class that implements interface
-  :code:`\TYPO3\CMS\Saltedpasswords\Salt\SaltInterface` and abstract class
-  :code:`\TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt` (see class
+  :code:`\TYPO3\CMS\Saltedpasswords\Salt\SaltInterface`
+
+  Optional: take advantage of abstract class
+  :code:`\TYPO3\CMS\Saltedpasswords\Salt\AbstractComposedSalt` (see class
   :code:`\TYPO3\CMS\Saltedpasswords\Salt\Md5Salt` for an example implementation)
 
 - register your salting method class
diff --git a/typo3/sysext/saltedpasswords/Migrations/Code/ClassAliasMap.php b/typo3/sysext/saltedpasswords/Migrations/Code/ClassAliasMap.php
new file mode 100644 (file)
index 0000000..eff3a7a
--- /dev/null
@@ -0,0 +1,4 @@
+<?php
+return [
+    'TYPO3\\CMS\\Saltedpasswords\\Salt\\AbstractSalt' => \TYPO3\CMS\Saltedpasswords\Salt\AbstractComposedSalt::class,
+];
index d72c23e..281b9fb 100644 (file)
@@ -24,7 +24,7 @@ class SaltFactoryTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
     /**
      * Keeps instance of object to test.
      *
-     * @var \TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt
+     * @var \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface
      */
     protected $objectInstance = null;
 
@@ -62,29 +62,20 @@ class SaltFactoryTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
     /**
      * @test
      */
-    public function objectInstanceExtendsAbstractClass()
-    {
-        $this->assertTrue(is_subclass_of($this->objectInstance, \TYPO3\CMS\Saltedpasswords\Salt\AbstractSalt::class));
-    }
-
-    /**
-     * @test
-     */
     public function objectInstanceImplementsInterface()
     {
-        $this->assertTrue(method_exists($this->objectInstance, 'checkPassword'), 'Missing method checkPassword() from interface ' . \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class . '.');
-        $this->assertTrue(method_exists($this->objectInstance, 'isHashUpdateNeeded'), 'Missing method isHashUpdateNeeded() from interface ' . \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class . '.');
-        $this->assertTrue(method_exists($this->objectInstance, 'isValidSalt'), 'Missing method isValidSalt() from interface ' . \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class . '.');
-        $this->assertTrue(method_exists($this->objectInstance, 'isValidSaltedPW'), 'Missing method isValidSaltedPW() from interface ' . \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class . '.');
-        $this->assertTrue(method_exists($this->objectInstance, 'getHashedPassword'), 'Missing method getHashedPassword() from interface ' . \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class . '.');
-        $this->assertTrue(method_exists($this->objectInstance, 'getSaltLength'), 'Missing method getSaltLength() from interface ' . \TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class . '.');
+        $this->assertInstanceOf(\TYPO3\CMS\Saltedpasswords\Salt\SaltInterface::class, $this->objectInstance);
     }
 
     /**
      * @test
      */
-    public function base64EncodeReturnsProperLength()
+    public function abstractComposedSaltBase64EncodeReturnsProperLength()
     {
+        // set up an instance that extends AbstractComposedSalt first
+        $saltPbkdf2 = '$pbkdf2-sha256$6400$0ZrzXitFSGltTQnBWOsdAw$Y11AchqV4b0sUisdZd0Xr97KWoymNE0LNNrnEgY4H9M';
+        $this->objectInstance = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance($saltPbkdf2);
+
         // 3 Bytes should result in a 6 char length base64 encoded string
         // used for MD5 and PHPass salted hashing
         $byteLength = 3;
@@ -107,6 +98,7 @@ class SaltFactoryTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
         $saltMD5 = '$1$rasmusle$rISCgZzpwk3UhDidwXvin0';
         $this->objectInstance = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance($saltMD5);
         $this->assertTrue(get_class($this->objectInstance) == \TYPO3\CMS\Saltedpasswords\Salt\Md5Salt::class || is_subclass_of($this->objectInstance, \TYPO3\CMS\Saltedpasswords\Salt\Md5Salt::class));
+        $this->assertInstanceOf(\TYPO3\CMS\Saltedpasswords\Salt\AbstractComposedSalt::class, $this->objectInstance);
     }
 
     /**
@@ -117,6 +109,7 @@ class SaltFactoryTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
         $saltBlowfish = '$2a$07$abcdefghijklmnopqrstuuIdQV69PAxWYTgmnoGpe0Sk47GNS/9ZW';
         $this->objectInstance = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance($saltBlowfish);
         $this->assertTrue(get_class($this->objectInstance) == \TYPO3\CMS\Saltedpasswords\Salt\BlowfishSalt::class || is_subclass_of($this->objectInstance, \TYPO3\CMS\Saltedpasswords\Salt\BlowfishSalt::class));
+        $this->assertInstanceOf(\TYPO3\CMS\Saltedpasswords\Salt\AbstractComposedSalt::class, $this->objectInstance);
     }
 
     /**
@@ -127,6 +120,7 @@ class SaltFactoryTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
         $saltPhpass = '$P$CWF13LlG/0UcAQFUjnnS4LOqyRW43c.';
         $this->objectInstance = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance($saltPhpass);
         $this->assertTrue(get_class($this->objectInstance) == \TYPO3\CMS\Saltedpasswords\Salt\PhpassSalt::class || is_subclass_of($this->objectInstance, \TYPO3\CMS\Saltedpasswords\Salt\PhpassSalt::class));
+        $this->assertInstanceOf(\TYPO3\CMS\Saltedpasswords\Salt\AbstractComposedSalt::class, $this->objectInstance);
     }
 
     /**
@@ -137,6 +131,7 @@ class SaltFactoryTest extends \TYPO3\TestingFramework\Core\Unit\UnitTestCase
         $saltPbkdf2 = '$pbkdf2-sha256$6400$0ZrzXitFSGltTQnBWOsdAw$Y11AchqV4b0sUisdZd0Xr97KWoymNE0LNNrnEgY4H9M';
         $this->objectInstance = \TYPO3\CMS\Saltedpasswords\Salt\SaltFactory::getSaltingInstance($saltPbkdf2);
         $this->assertTrue(get_class($this->objectInstance) == \TYPO3\CMS\Saltedpasswords\Salt\Pbkdf2Salt::class || is_subclass_of($this->objectInstance, \TYPO3\CMS\Saltedpasswords\Salt\Pbkdf2Salt::class));
+        $this->assertInstanceOf(\TYPO3\CMS\Saltedpasswords\Salt\AbstractComposedSalt::class, $this->objectInstance);
     }
 
     /**
index 9a1914c..21966ff 100644 (file)
                                "partOfMinimalUsableSystem": true
                        },
                        "extension-key": "saltedpasswords"
+               },
+               "typo3/class-alias-loader": {
+                       "class-alias-maps": [
+                               "Migrations/Code/ClassAliasMap.php"
+                       ]
                }
        },
        "autoload": {