AuthController.php

<?php

namespace UnicaenAuth\Controller;

use DomainException;
use UnicaenApp\Controller\Plugin\AppInfos;
use UnicaenApp\Controller\Plugin\Mail;
use UnicaenApp\Exception\RuntimeException;
use UnicaenAuth\Authentication\Adapter\Db;
use UnicaenAuth\Authentication\Adapter\Ldap;
use UnicaenAuth\Authentication\Adapter\Shib;
use UnicaenAuth\Options\Traits\ModuleOptionsAwareTrait;
use UnicaenAuth\Service\ShibService;
use UnicaenAuth\Service\Traits\CasServiceAwareTrait;
use UnicaenAuth\Service\Traits\ShibServiceAwareTrait;
use UnicaenAuth\Service\Traits\UserServiceAwareTrait;
use Zend\Authentication\AuthenticationService;
use Zend\Form\FormInterface;
use Zend\Http\Request;
use Zend\Http\Response;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\Mvc\Plugin\FlashMessenger\FlashMessenger;
use Zend\Stdlib\ResponseInterface;
use Zend\View\Model\ViewModel;
use ZfcUser\Controller\Plugin\ZfcUserAuthentication;

/**
 * @method ZfcUserAuthentication zfcUserAuthentication()
 * @method AppInfos appInfos()
 * @method Mail mail()
 * @method FlashMessenger flashMessenger()
 *
 * @author Bertrand GAUTHIER <bertrand.gauthier at unicaen.fr>
 */
class AuthController extends AbstractActionController
{
    use CasServiceAwareTrait;
    use ShibServiceAwareTrait;
    use UserServiceAwareTrait;
    use ModuleOptionsAwareTrait;

    /**
     * @var FormInterface[] [type => FormInterface]
     */
    protected $loginFormForType;

    /**
     * @var callable $redirectCallback
     */
    protected $redirectCallback;

    /**
     * @param callable $redirectCallback
     * @return self
     */
    public function setRedirectCallback(callable $redirectCallback): self
    {
        $this->redirectCallback = $redirectCallback;
        return $this;
    }

    /**
     * @var AuthenticationService
     */
    private $authenticationService;

    /**
     * @param AuthenticationService $authenticationService
     */
    public function setAuthenticationService(AuthenticationService $authenticationService)
    {
        $this->authenticationService = $authenticationService;
    }

    /**
     * @param string $type
     * @return FormInterface
     */
    public function getLoginFormForType(string $type)
    {
        if (! isset($this->loginFormForType[$type])) {
            throw new RuntimeException("Pas de formulaire spécifié pour le type '$type'");
        }

        return $this->loginFormForType[$type];
    }

    /**
     * @param FormInterface $loginForm
     * @param string $type
     * @return self
     */
    public function setLoginFormForType(FormInterface $loginForm, string $type): self
    {
        $this->loginFormForType[$type] = $loginForm;

        return $this;
    }

    /**
     * @todo Make this dynamic / translation-friendly
     * @var string
     */
    protected $failedLoginMessage = "Identifiant ou mot de passe incorrect.";

    /**
     * Login form
     */
    public function loginAction()
    {
        if ($this->zfcUserAuthentication()->hasIdentity()) {
            return $this->redirect()->toRoute($this->moduleOptions->getLoginRedirectRoute());
        }

        $request = $this->getRequest();
        $type = $this->params('type');
        $types = $this->moduleOptions->getEnabledAuthTypes(); // types d'auth activés

        if ($type === null) {
            // si aucun type n'est spécifié dans la requête, on prend le 1er type activé.
            $type = key($types);
            // si le type possède un subsitut (ex: 'local'), on l'utilise.
            $type = $types[$type]['type'] ?? $type;
            return $this->redirect()->toRoute(null, ['type' => $type], ['query' => $this->params()->fromQuery()], true);
        } elseif (isset($types[$type]['type'])) {
            // si le type spécifié possède un subsitut (ex: 'local'), on l'utilise.
            $type = $types[$type]['type'];
            return $this->redirect()->toRoute(null, ['type' => $type], ['query' => $this->params()->fromQuery()], true);
        }

        $form = $this->getLoginFormForType($type);

        // si le formulaire POSTé ne possède aucun champ identifiant, on va directement à authenticateAction()
        if ($request->isPost() and ! $request->getPost()->get('identity')) {
            return $this->redirect()->toRoute('zfcuser/authenticate', [], ['query' => $this->params()->fromQuery()], true);
        }

        if ($this->moduleOptions->getUseRedirectParameterIfPresent() && $request->getQuery()->get('redirect')) {
            $redirect = $request->getQuery()->get('redirect');
        } else {
            $redirect = false;
        }

        $queryParams = ['query' => $redirect ? ['redirect' => $redirect] : []];
        $url = $this->url()->fromRoute(null, [], $queryParams, true);
        $form->setAttribute('action', $url);

        if (!$request->isPost()) {
            return array(
                'types' => $this->moduleOptions->getEnabledAuthTypes(),
                'type' => $type,
                'loginForm' => $form,
                'redirect'  => $redirect,
                'enableRegistration' => $this->moduleOptions->getEnableRegistration(),
            );
        }

        $form->setData($request->getPost());

        if (!$form->isValid()) {
            $this->flashMessenger()->setNamespace('zfcuser-login-form')->addMessage($this->failedLoginMessage);
            return $this->redirect()->toUrl($url);
        }

        // clear adapters
        $this->zfcUserAuthentication()->getAuthAdapter()->resetAdapters();
        $this->zfcUserAuthentication()->getAuthService()->clearIdentity();

        return $this->authenticateAction();
    }

    /**
     * General-purpose authentication action
     */
    public function authenticateAction()
    {
        if ($this->zfcUserAuthentication()->hasIdentity()) {
            return $this->redirect()->toRoute($this->moduleOptions->getLoginRedirectRoute());
        }

        $type    = $this->params('type');
        $adapter = $this->zfcUserAuthentication()->getAuthAdapter();
        $redirect = $this->params()->fromPost('redirect', $this->params()->fromQuery('redirect', false));

        $this->getRequest()->getPost()->set('type', $type);
        $result = $adapter->prepareForAuthentication($this->getRequest());

        // Return early if an adapter returned a response
        if ($result instanceof ResponseInterface) {
            return $result;
        }

        $auth = $this->zfcUserAuthentication()->getAuthService()->authenticate($adapter);

        if (!$auth->isValid()) {
            $this->flashMessenger()->setNamespace('zfcuser-login-form')->addMessage($this->failedLoginMessage);
            $adapter->resetAdapters();
            $url = $this->url()->fromRoute(null, [], ['query' => $redirect ? ['redirect' => $redirect] : []], true);
            return $this->redirect()->toUrl($url);
        }

        $redirect = $this->redirectCallback;

        return $redirect();
    }

    /**
     * Logout and clear the identity
     */
    public function logoutAction()
    {
        $chain = $this->zfcUserAuthentication()->getAuthAdapter();
        $service = $this->zfcUserAuthentication()->getAuthService();

        $chain->resetAdapters();

        /**
         * @see Db::logout()
         * @see Ldap::logout()
         * @see Shib::logout()
         */
        $result = $chain->logoutAdapters();

        $service->clearIdentity();

        if ($result instanceof ResponseInterface) {
            return $result;
        }

        $redirect = $this->redirectCallback;

        return $redirect();
    }

    /**
     * Cette action peut être appelée lorsque l'authentification Shibboleth est activée
     * (unicaen-auth.shibboleth.enable === true).
     *
     * > Si la config Apache du module Shibboleth est correcte sur le serveur d'appli, une requête à l'adresse
     *   correspondant à cette action sera détournée par Apache pour réaliser l'authentification Shibboleth.
     *   Une fois l'authentification réalisée avec succès, le Apache renvoie une nouvelle requête
     *   à l'adresse correspondant à cette action, et l'utilisateur authentifié est disponible via
     *   {@see ShibService::getAuthenticatedUser()}.
     *
     * > Par contre, si la config Apache du module Shibboleth est incorrecte ou absente (sur votre machine de dev par
     *   exemple), alors :
     *     - si la simulation Shibboleth est activée dans la config du module unicaen/auth
     *       (unicaen-auth.shibboleth.simulate), c'est l'utilisateur configurée qui sera authentifié ;
     *     - sinon, une page d'aide s'affichera indiquant que la config Apache du module Shibboleth est sans doute
     *       erronée.
     *
     * @return Response|array
     */
    public function shibbolethAction()
    {
        $shibUser = $this->shibService->getAuthenticatedUser();
        // NB: si la simulation d'authentification est activée (cf. config), $shibUser !== null.

        if ($shibUser === null) {
            return []; // affichage d'une page d'aide
        }

        // URL vers laquelle rediriger une fois l'authentification réussie
        $redirectUrl = $this->params()->fromQuery('redirect', '/');

        return $this->redirect()->toUrl($redirectUrl);
    }

    /**
     * @return Response|ViewModel
     */
    public function requestPasswordResetAction()
    {
        $form = $this->userService->createResetPasswordEmailForm();

        $view = new ViewModel();
        $view->setVariable('form', $form);
        $view->setTemplate('unicaen-auth/auth/request-password-reset-form');

        /** @var Request $request */
        $request = $this->getRequest();

        if ($request->isPost()) {
            $data = $request->getPost();
            $form->setData($data);
            if ($form->isValid()) {
                $email = $data['email'];
                try {
                    $this->processPasswordResetRequest($email);

                    $view->setVariable('email', $email);
                    $view->setTemplate('unicaen-auth/auth/request-password-reset-success');
                } catch (DomainException $de) {
                    // affichage de l'erreur comme une erreur de validation
                    $form->get('email')->setMessages([$de->getMessage()]);
                }
            }
        }

        return $view;
    }

    /**
     * @param string $email
     */
    private function processPasswordResetRequest($email)
    {
        // Recherche de l'utilisateur ayant pour *username* (login) l'email spécifié
        $user = $this->userService->getUserMapper()->findOneByUsername($email);

        if ($user === null) {
            // Aucun utilisateur trouvé ayant l'email spécifié :
            // on ne fait rien mais on ne le signale pas sinon le formulaire permettrait
            // de tester si des emails potentiellement valides existent dans la base.
            return;
        }
        if (! $user->isLocal()) {
            // L'email spécifié appartient à un utilisateur non local : on signale l'impossibilité de changer le mdp.
            throw new DomainException("Le changement de mot de passe n'est pas possible pour cet utilisateur.");
        }

        // génération/enregistrement d'un token
        $token = $this->userService->updateUserPasswordResetToken($user);

        // envoi du mail contenant le lien de changement de mdp
        $app = $this->appInfos()->getNom();
        $subject = "[$app] Demande de changement de mot de passe";
        $changePasswordUrl = $this->url()->fromRoute('auth/changePassword', ['token' => $token], ['force_canonical' => true]);
        $body = <<<EOS
<p>Une demande de changement de mot de passe a été faite sur l'application $app.</p>
<p>Si vous n'en êtes pas l'auteur, vous pouvez ignorer ce message.</p>
<p>Cliquez sur le lien suivant pour accéder au formulaire de changement de votre mot de passe :<br><a href='$changePasswordUrl'>$changePasswordUrl</a></p>
EOS;
        $message = $this->mail()->createNewMessage($body, $subject);
        $message->setTo($email);
        $this->mail()->send($message);
    }

    /**
     * @return array|ViewModel
     */
    public function changePasswordAction()
    {
        $token = $this->params()->fromRoute('token');
        $view = new ViewModel();

        // recherche du token spécifié dans table utilisateur
        $user = $this->userService->getUserMapper()->findOneByPasswordResetToken($token);
        if ($user === null) {
            // token inexistant
            $view->setVariable('result', 'unknown_token');
            $view->setTemplate('unicaen-auth/auth/change-password-result');

            return $view;
        }

        $form = $this->userService->createPasswordChangeForm();

        /** @var Request $request */
        $request = $this->getRequest();

        if ($request->isPost()) {
            $data = $request->getPost();
            $form->setData($data);
            if ($form->isValid()) {
                // màj password
                $password = $this->params()->fromPost('password');
                $this->userService->updateUserPassword($user, $password);

                $view->setVariable('result', 'success');
                $view->setTemplate('unicaen-auth/auth/change-password-result');

                // todo: faut-il déconnecter l'utilisateur (attention au logout shib différent) ?

                return $view;
            }
        }

        // test durée de vie du token
        $date = $this->userService->extractDateFromResetPasswordToken($token);
        if ($date < date_create()) {
            // token expiré, on le raz
            $this->userService->clearUserPasswordResetToken($user);

            $view->setVariable('result', 'dead_token');
            $view->setTemplate('unicaen-auth/auth/change-password-result');

            return $view;
        }

        $view->setVariable('form', $form);
        $view->setTemplate('unicaen-auth/auth/change-password-form');

        return $view;
    }
}