SaltFactory.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Saltedpasswords\Salt;

class SaltFactory {

    static protected $instance = NULL;

    static public function getRegisteredSaltedHashingMethods() {
        $saltMethods = static::getDefaultSaltMethods();
        if (isset($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/saltedpasswords']['saltMethods'])) {
            $configuredMethods = (array)$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['ext/saltedpasswords']['saltMethods'];
            if (count($configuredMethods) > 0) {
                if (isset($configuredMethods[0])) {
                    // ensure the key of the array is not numeric, but a class name
                    foreach ($configuredMethods as $method) {
                        $saltMethods[$method] = $method;
                    }
                } else {
                    $saltMethods = array_merge($saltMethods, $configuredMethods);
                }
            }
        }
        return $saltMethods;
    }

    static protected function getDefaultSaltMethods() {
        return array(
            'TYPO3\\CMS\\Saltedpasswords\\Salt\\Md5Salt' => 'TYPO3\\CMS\\Saltedpasswords\\Salt\\Md5Salt',
            'TYPO3\\CMS\\Saltedpasswords\\Salt\\BlowfishSalt' => 'TYPO3\\CMS\\Saltedpasswords\\Salt\\BlowfishSalt',
            'TYPO3\\CMS\\Saltedpasswords\\Salt\\PhpassSalt' => 'TYPO3\\CMS\\Saltedpasswords\\Salt\\PhpassSalt'
        );
    }


    static public function getSaltingInstance($saltedHash = '', $mode = TYPO3_MODE) {
        // 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) || $saltedHash === NULL) {
            // Determine method by checking the given hash
            if (!empty($saltedHash)) {
                $result = self::determineSaltingHashingMethod($saltedHash, $mode);
                if (!$result) {
                    self::$instance = NULL;
                }
            } else {
                $classNameToUse = \TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility::getDefaultSaltingHashingMethod($mode);
                $availableClasses = static::getRegisteredSaltedHashingMethods();
                self::$instance = \TYPO3\CMS\Core\Utility\GeneralUtility::getUserObj($availableClasses[$classNameToUse]);
            }
        }
        return self::$instance;
    }

    static public function determineSaltingHashingMethod($saltedHash, $mode = TYPO3_MODE) {
        $registeredMethods = static::getRegisteredSaltedHashingMethods();
        $defaultClassName = \TYPO3\CMS\Saltedpasswords\Utility\SaltedPasswordsUtility::getDefaultSaltingHashingMethod($mode);
        $defaultReference = $registeredMethods[$defaultClassName];
        unset($registeredMethods[$defaultClassName]);
        // place the default method first in the order
        $registeredMethods = array($defaultClassName => $defaultReference) + $registeredMethods;
        $methodFound = FALSE;
        foreach ($registeredMethods as $method) {
            $objectInstance = \TYPO3\CMS\Core\Utility\GeneralUtility::getUserObj($method);
            if ($objectInstance instanceof SaltInterface) {
                $methodFound = $objectInstance->isValidSaltedPW($saltedHash);
                if ($methodFound) {
                    self::$instance = $objectInstance;
                    break;
                }
            }
        }
        return $methodFound;
    }

    static public function setPreferredHashingMethod($resource) {
        self::$instance = NULL;
        $objectInstance = \TYPO3\CMS\Core\Utility\GeneralUtility::getUserObj($resource);
        if (is_object($objectInstance) && is_subclass_of($objectInstance, 'TYPO3\\CMS\\Saltedpasswords\\Salt\\AbstractSalt')) {
            self::$instance = $objectInstance;
        }
        return self::$instance;
    }
}