Db::updateUserPasswordHash() - Code Metrics - Inspection of "Hotfix/servicemanager" - ZF-Commons/ZfcUser - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.x (#637)

by Daniel

created 2016-05-05 19:21 UTC

Db::updateUserPasswordHash() A

↳ Parent: Db

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	2	Features	0

Metric	Value
c	2
b	2
f	0
dl	0
loc	10
rs	9.4285
cc	2
eloc	7
nc	2
nop	3

<?php

namespace ZfcUser\Authentication\Adapter;

use DateTime;
use Zend\Authentication\Result as AuthenticationResult;
use Zend\ServiceManager\ServiceManagerAwareInterface;
use Zend\ServiceManager\ServiceManager;
use Zend\Crypt\Password\Bcrypt;
use Zend\Session\Container as SessionContainer;
use ZfcUser\Authentication\Adapter\AdapterChainEvent as AuthEvent;
use ZfcUser\Mapper\User as UserMapperInterface;
use ZfcUser\Options\AuthenticationOptionsInterface;

class Db extends AbstractAdapter
{
    /**
     * @var UserMapperInterface
     */
    protected $mapper;

    /**
     * @var closure / invokable object
     */
    protected $credentialPreprocessor;

    /**
     * @var ServiceManager
     */
    protected $serviceManager;

    /**
     * @var AuthenticationOptionsInterface
     */
    protected $options;

    /**
     * Called when user id logged out
     * @param  AuthEvent $e event passed
     */
    public function logout(AuthEvent $e)
    {
        $this->getStorage()->clear();
    }

    public function authenticate(AuthEvent $e)
    {
        if ($this->isSatisfied()) {
            $storage = $this->getStorage()->read();
            $e->setIdentity($storage['identity'])
              ->setCode(AuthenticationResult::SUCCESS)
              ->setMessages(array('Authentication successful.'));
            return;
        }

        $identity   = $e->getRequest()->getPost()->get('identity');
        $credential = $e->getRequest()->getPost()->get('credential');
        $credential = $this->preProcessCredential($credential);
        $userObject = null;

        // Cycle through the configured identity sources and test each
        $fields = $this->getOptions()->getAuthIdentityFields();
        while (!is_object($userObject) && count($fields) > 0) {
            $mode = array_shift($fields);
            switch ($mode) {
                case 'username':
                    $userObject = $this->getMapper()->findByUsername($identity);
                    break;
                case 'email':
                    $userObject = $this->getMapper()->findByEmail($identity);
                    break;
            }
        }

        if (!$userObject) {
            $e->setCode(AuthenticationResult::FAILURE_IDENTITY_NOT_FOUND)
              ->setMessages(array('A record with the supplied identity could not be found.'));
            $this->setSatisfied(false);
            return false;
        }

        if ($this->getOptions()->getEnableUserState()) {
            // Don't allow user to login if state is not in allowed list
            if (!in_array($userObject->getState(), $this->getOptions()->getAllowedLoginStates())) {
                $e->setCode(AuthenticationResult::FAILURE_UNCATEGORIZED)
                  ->setMessages(array('A record with the supplied identity is not active.'));
                $this->setSatisfied(false);
                return false;
            }
        }

        $bcrypt = new Bcrypt();
        $bcrypt->setCost($this->getOptions()->getPasswordCost());
        if (!$bcrypt->verify($credential, $userObject->getPassword())) {
            // Password does not match
            $e->setCode(AuthenticationResult::FAILURE_CREDENTIAL_INVALID)
              ->setMessages(array('Supplied credential is invalid.'));
            $this->setSatisfied(false);
            return false;
        }

        // regen the id
        $session = new SessionContainer($this->getStorage()->getNameSpace());
        $session->getManager()->regenerateId();

        // Success!
        $e->setIdentity($userObject->getId());
        // Update user's password hash if the cost parameter has changed
        $this->updateUserPasswordHash($userObject, $credential, $bcrypt);
        $this->setSatisfied(true);
        $storage = $this->getStorage()->read();
        $storage['identity'] = $e->getIdentity();
        $this->getStorage()->write($storage);
        $e->setCode(AuthenticationResult::SUCCESS)
          ->setMessages(array('Authentication successful.'));
    }

    protected function updateUserPasswordHash($userObject, $password, $bcrypt)
    {
        $hash = explode('$', $userObject->getPassword());
        if ($hash[2] === $bcrypt->getCost()) {
            return;
        }
        $userObject->setPassword($bcrypt->create($password));
        $this->getMapper()->update($userObject);
        return $this;
    }

    public function preprocessCredential($credential)
    {
        $processor = $this->getCredentialPreprocessor();
        if (is_callable($processor)) {
            return $processor($credential);
        }
        return $credential;
    }

    /**
     * getMapper
     *
     * @return UserMapperInterface
     */
    public function getMapper()
    {
        if (null === $this->mapper) {
            $this->mapper = $this->getServiceManager()->get('zfcuser_user_mapper');
        }
        return $this->mapper;

    }

    /**
     * setMapper
     *
     * @param UserMapperInterface $mapper
     * @return Db
     */
    public function setMapper(UserMapperInterface $mapper)
    {
        $this->mapper = $mapper;
        return $this;
    }

    /**
     * Get credentialPreprocessor.
     *
     * @return \callable
     */
    public function getCredentialPreprocessor()
    {
        return $this->credentialPreprocessor;
    }

    /**
     * Set credentialPreprocessor.
     *
     * @param $credentialPreprocessor the value to be set
     */
    public function setCredentialPreprocessor($credentialPreprocessor)
    {
        $this->credentialPreprocessor = $credentialPreprocessor;
        return $this;
    }

    /**
     * Retrieve service manager instance
     *
     * @return ServiceManager
     */
    public function getServiceManager()
    {
        return $this->serviceManager;
    }

    /**
     * Set service manager instance
     *
     * @param ServiceManager $locator
     * @return void
     */
    public function setServiceManager(ServiceManager $serviceManager)
    {
        $this->serviceManager = $serviceManager;
    }

    /**
     * @param AuthenticationOptionsInterface $options
     */
    public function setOptions(AuthenticationOptionsInterface $options)
    {
        $this->options = $options;
    }

    /**
     * @return AuthenticationOptionsInterface
     */
    public function getOptions()
    {
        if (!$this->options instanceof AuthenticationOptionsInterface) {
            $this->setOptions($this->getServiceManager()->get('zfcuser_module_options'));
        }
        return $this->options;
    }
}


1			<?php
2
3			namespace ZfcUser\Authentication\Adapter;
4
5			use DateTime;
6			use Zend\Authentication\Result as AuthenticationResult;
7			use Zend\ServiceManager\ServiceManagerAwareInterface;
8			use Zend\ServiceManager\ServiceManager;
9			use Zend\Crypt\Password\Bcrypt;
10			use Zend\Session\Container as SessionContainer;
11			use ZfcUser\Authentication\Adapter\AdapterChainEvent as AuthEvent;
12			use ZfcUser\Mapper\User as UserMapperInterface;
13			use ZfcUser\Options\AuthenticationOptionsInterface;
14
15			class Db extends AbstractAdapter
16			{
17			/**
18			* @var UserMapperInterface
19			*/
20			protected $mapper;
21
22			/**
23			* @var closure / invokable object
24			*/
25			protected $credentialPreprocessor;
26
27			/**
28			* @var ServiceManager
29			*/
30			protected $serviceManager;
31
32			/**
33			* @var AuthenticationOptionsInterface
34			*/
35			protected $options;
36
37			/**
38			* Called when user id logged out
39			* @param AuthEvent $e event passed
40			*/
41			public function logout(AuthEvent $e)
42			{
43			$this->getStorage()->clear();
44			}
45
46			public function authenticate(AuthEvent $e)
47			{
48			if ($this->isSatisfied()) {
49			$storage = $this->getStorage()->read();
50			$e->setIdentity($storage['identity'])
51			->setCode(AuthenticationResult::SUCCESS)
52			->setMessages(array('Authentication successful.'));
53			return;
54			}
55
56			$identity = $e->getRequest()->getPost()->get('identity');
57			$credential = $e->getRequest()->getPost()->get('credential');
58			$credential = $this->preProcessCredential($credential);
59			$userObject = null;
60
61			// Cycle through the configured identity sources and test each
62			$fields = $this->getOptions()->getAuthIdentityFields();
63			while (!is_object($userObject) && count($fields) > 0) {
64			$mode = array_shift($fields);
65			switch ($mode) {
66			case 'username':
67			$userObject = $this->getMapper()->findByUsername($identity);
68			break;
69			case 'email':
70			$userObject = $this->getMapper()->findByEmail($identity);
71			break;
72			}
73			}
74
75			if (!$userObject) {
76			$e->setCode(AuthenticationResult::FAILURE_IDENTITY_NOT_FOUND)
77			->setMessages(array('A record with the supplied identity could not be found.'));
78			$this->setSatisfied(false);
79			return false;
80			}
81
82			if ($this->getOptions()->getEnableUserState()) {
83			// Don't allow user to login if state is not in allowed list
84			if (!in_array($userObject->getState(), $this->getOptions()->getAllowedLoginStates())) {
85			$e->setCode(AuthenticationResult::FAILURE_UNCATEGORIZED)
86			->setMessages(array('A record with the supplied identity is not active.'));
87			$this->setSatisfied(false);
88			return false;
89			}
90			}
91
92			$bcrypt = new Bcrypt();
93			$bcrypt->setCost($this->getOptions()->getPasswordCost());
94			if (!$bcrypt->verify($credential, $userObject->getPassword())) {
95			// Password does not match
96			$e->setCode(AuthenticationResult::FAILURE_CREDENTIAL_INVALID)
97			->setMessages(array('Supplied credential is invalid.'));
98			$this->setSatisfied(false);
99			return false;
100			}
101
102			// regen the id
103			$session = new SessionContainer($this->getStorage()->getNameSpace());
104			$session->getManager()->regenerateId();
105
106			// Success!
107			$e->setIdentity($userObject->getId());
108			// Update user's password hash if the cost parameter has changed
109			$this->updateUserPasswordHash($userObject, $credential, $bcrypt);
110			$this->setSatisfied(true);
111			$storage = $this->getStorage()->read();
112			$storage['identity'] = $e->getIdentity();
113			$this->getStorage()->write($storage);
114			$e->setCode(AuthenticationResult::SUCCESS)
115			->setMessages(array('Authentication successful.'));
116			}
117
118			protected function updateUserPasswordHash($userObject, $password, $bcrypt)
119			{
120			$hash = explode('$', $userObject->getPassword());
121			if ($hash[2] === $bcrypt->getCost()) {
122			return;
123			}
124			$userObject->setPassword($bcrypt->create($password));
125			$this->getMapper()->update($userObject);
126			return $this;
127			}
128
129			public function preprocessCredential($credential)
130			{
131			$processor = $this->getCredentialPreprocessor();
132			if (is_callable($processor)) {
133			return $processor($credential);
134			}
135			return $credential;
136			}
137
138			/**
139			* getMapper
140			*
141			* @return UserMapperInterface
142			*/
143			public function getMapper()
144			{
145			if (null === $this->mapper) {
146			$this->mapper = $this->getServiceManager()->get('zfcuser_user_mapper');
147			}
148			return $this->mapper;
			0 ignored issues – show Bug Compatibility introduced 2016-03-07 22:55 UTC by Report Bug Copy Issue Report The expression `$this->mapper;` of type `object\|array` adds the type `array` to the return on line 148 which is incompatible with the return type documented by `ZfcUser\Authentication\Adapter\Db::getMapper` of type `ZfcUser\Mapper\User`. Loading history...
149			}
150
151			/**
152			* setMapper
153			*
154			* @param UserMapperInterface $mapper
155			* @return Db
156			*/
157			public function setMapper(UserMapperInterface $mapper)
158			{
159			$this->mapper = $mapper;
160			return $this;
161			}
162
163			/**
164			* Get credentialPreprocessor.
165			*
166			* @return \callable
167			*/
168			public function getCredentialPreprocessor()
169			{
170			return $this->credentialPreprocessor;
171			}
172
173			/**
174			* Set credentialPreprocessor.
175			*
176			* @param $credentialPreprocessor the value to be set
177			*/
178			public function setCredentialPreprocessor($credentialPreprocessor)
179			{
180			$this->credentialPreprocessor = $credentialPreprocessor;
181			return $this;
182			}
183
184			/**
185			* Retrieve service manager instance
186			*
187			* @return ServiceManager
188			*/
189			public function getServiceManager()
190			{
191			return $this->serviceManager;
192			}
193
194			/**
195			* Set service manager instance
196			*
197			* @param ServiceManager $locator
198			* @return void
199			*/
200			public function setServiceManager(ServiceManager $serviceManager)
201			{
202			$this->serviceManager = $serviceManager;
203			}
204
205			/**
206			* @param AuthenticationOptionsInterface $options
207			*/
208			public function setOptions(AuthenticationOptionsInterface $options)
209			{
210			$this->options = $options;
211			}
212
213			/**
214			* @return AuthenticationOptionsInterface
215			*/
216			public function getOptions()
217			{
218			if (!$this->options instanceof AuthenticationOptionsInterface) {
219			$this->setOptions($this->getServiceManager()->get('zfcuser_module_options'));
220			}
221			return $this->options;
222			}
223			}
224

ZF-Commons / ZfcUser

Pull Request — 1.x (#637)

Db::updateUserPasswordHash() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like