[eZ] Mise en place d'un User Provider

**Rémy DEV** · 27/11/2018, 15h16

Bonjour chère communauté SF.

Je travaille sur une projet eZPlatform et je dois mettre en place un User Provider.

eZPlatform est un CMS basé sur Symfony 3. Il suffit de voir ça comme un gros bundle.

Je souhaite garder le système de connexion habituel des utilisateurs.

Formulaire de connexion (Login / Mot de passe)
Recherche de l'utilisateur dans la base eZ. C'est un peut comme des utilisateurs dans des entités doctrine.

Mais si l'utilisateur n'existe pas dans la base eZ il faut aller vérifier si il n'est pas disponible sur un service distant.

Formulaire de connexion (Login / Mot de passe)
Recherche de l'utilisateur dans la base eZ. C'est un peut comme des utilisateurs dans des entités doctrine.
Recherche de l'utilisateur dans le service distant.

Le service distant en question à été développé par un autre presta de mon client.
J'ai développé une API qui permet de réinterroger :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyAPI() {
  public function OAuthPassword($login, $password);
  /* return   {
                "access_token": "aaa",
                "token_type": "bearer",
                "refresh_token": "rrr",
                "expires_in": 4999,
                "scope": "read write trust",
                "service_ticket": "sss",
                "token": "ttt",
                "jti": "jjj"
   } */
  public function OAuthRefreshToken($refresh_token);
  // même retour que OAuthPassword
  public function OAuthCheckToken($access_token);
  public function OAuthPermissions($access_token);
  // Retournent des infos qui me seront utiles plus tard...

Pas de pb avec l'API elle semble répondre comme il faut.
En cas d'erreur elle renvoie des Exception

Puis j'ai suivit ce Tuto : How to Create a custom Authentication Provider https://symfony.com/doc/3.4/security..._provider.html

Mo token :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class MyUserToken extends AbstractToken
{
    public $login;
    public $password;
    public $data;
 
    public function __construct(array $roles = array())
    {
        parent::__construct($roles);
 
        // If the user has roles, consider it authenticated
        $this->setAuthenticated(count($roles) > 0);
    }
 
    public function getCredentials()
    {
        return '';
    }
 
    public function ready()
    {
        return $this->login && $this->password;
    }
}

Mon listener

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class MyListener implements ListenerInterface
{
    protected $tokenStorage;
    protected $authenticationManager;
 
    public function __construct(TokenStorageInterface $tokenStorage, AuthenticationManagerInterface $authenticationManager)
    {
        $this->tokenStorage = $tokenStorage;
        $this->authenticationManager = $authenticationManager;
    }
 
    public function handle(GetResponseEvent $event)
    {
        $request = $event->getRequest();
 
        $login = $request->request->get('_username');
        $password = $request->request->get('_password');
 
        $token = new MyUserToken();
        $token->login  = $login;
        $token->password  = $password;
 
        try {
            $authToken = $this->authenticationManager->authenticate($token);
            $this->tokenStorage->setToken($authToken);
            return;
        } catch (AuthenticationException $failed) {
            $token = $this->tokenStorage->getToken();
            if ($token instanceof MyUserToken) {
                $this->tokenStorage->setToken(null);
            }
            return;
        }
    }
}

Mon Authentication Provider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class MyAuthenticationProvider implements AuthenticationProviderInterface
{
    private $userProvider; // MyUserProvider
 
    public function __construct(UserProviderInterface $userProvider)
    {
        $this->userProvider = $userProvider;
    }
 
    public function authenticate(TokenInterface $token)
    {
                              // ==== Je pense que mon PB est là ... =====
        if ($token instanceof MyUserToken && $token->ready()) {
            $user = $this->userProvider->getUser($token->login, $token->password);
            $token->setUser($user);
            return $token;
        }
        throw new AuthenticationException('The My authentication failed.');
    }
 
    public function supports(TokenInterface $token)
    {
        return $token instanceof MyUserToken;
    }
}

Mon UserProvider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class MyUserProvider implements UserProviderInterface
{
    /** @var MyAPI  */
    private $api;
 
    public function __construct(MyAPI $api)
    {
        $this->api = $api;
    }
 
    public function supportsClass($class)
    {
        return MyUser::class === $class;
    }
 
    public function loadUserByUsername($username)
    {
        // ==== Ici je ne sais pas quoi faire. Je ne peux pas trouver d'utilisateur à partir de son username ... 
        throw new UsernameNotFoundException("User not found by username");
        return new MyUser($username);
    }
 
    public function getUser($login, $password)
    {
        try {
            $data = $this->api->OAuthPassword($login, $password);
            $user = new MyUser($login);
            $user->setData($data);
            $user->login = $login;
            $user->password = $password;
            $user->data = $data;
            return $user;
        } catch (\Exception $e) {
            throw new UsernameNotFoundException(__METHOD__." User not found. ". $e->getMessage());
        }
    }
 
    public function refreshUser(UserInterface $user)
    {
        if (!$user instanceof MyUser) {
            throw new UnsupportedUserException(
                sprintf('Instances of "%s" are not supported.', get_class($user))
            );
        }
 
        if ($user->getRefreshToken()) {
            $data = $this->api->OAuthRefreshToken($user->getRefreshToken());
            $user->setData($data);
            return $user;
        }
        // Idem je sais pas trop quoi faire ici
    }
}

Ma class User

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class MyUser implements UserInterface, EquatableInterface//, EncoderAwareInterface
{
    private $username;
    public $login;
    public $password = null;
    private $permissions = [];
    public $data;
 
    public function __construct($username, array $permissions = array())
    {
        $this->username = $username;
        $this->permissions = $permissions;
    }
 
    public function setPermissions($permissions = array())
    {
        $this->permissions = $permissions;
    }
 
    public function getPermissions()
    {
        return $this->permissions;
    }
 
    public function setData($data = array())
    {
        $this->data = $data;
    }
 
    public function getAccessToken()
    {
        return !empty($this->data['access_token'])  ? $this->data['access_token']  : '';
    }
    public function getRefreshToken()
    {
        return !empty($this->data['refresh_token'])  ? $this->data['refresh_token']  : '';
    }
 
    public function getRoles()
    {
        return array('ROLE_USER', 'ROLE_API_USER');
    }
 
    public function getPassword()
    {
        return $this->password;
    }
 
    public function getSalt()
    {
        return null;
    }
 
    public function getUsername()
    {
        return $this->username;
    }
 
    public function eraseCredentials()
    {
    }
 
    public function isEqualTo(UserInterface $user)
    {
        if (!$user instanceof MyUser) {
            return false;
        }
        return $this->username === $user->getUsername();
    }
}

Et pour finir avec le code : Voici ma factory :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class MySecurityFactory implements SecurityFactoryInterface
{
    public function create(ContainerBuilder $container, $id, $config, $userProvider, $defaultEntryPoint)
    {
        $providerId = 'security.authentication.provider.my.'.$id;
        $container
            ->setDefinition($providerId, new ChildDefinition(MyAuthenticationProvider::class))
            ->setArgument(0, new Reference($userProvider))
            ->setArgument(1, '@my.api') 
        ;
 
        $listenerId = 'security.authentication.listener.my.'.$id;
        $container->setDefinition($listenerId, new ChildDefinition(MyListener::class));
        return array($providerId, $listenerId, $defaultEntryPoint);
    }
 
    public function getPosition()
    {
        return 'pre_auth';
    }
 
    public function getKey()
    {
        return 'my';
    }
 
    public function addConfiguration(NodeDefinition $node)
    {
    }
}

Et la conf :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
security:
    providers:
        chain_provider:
            chain:
                providers:
                    - ezpublish
                    - my
        my:
            id: my.user_provider
        ezpublish:
            id: ezpublish.security.user_provider
    firewalls:
        my:
            pattern: ^/
            anonymous: ~
            ezpublish_rest_session: ~
            form_login:
                require_previous_session: false
            logout: ~
            my: true # C'est quoi ça ?
 
        ezpublish_front:
            pattern: ^/
            anonymous: ~
            ezpublish_rest_session: ~
            form_login:
                require_previous_session: false
            logout: ~

Voila pour mon code.

Lorsque je ne connecte j'ai le message d'erreur : Bad credentials.

**Rémy DEV** · 28/11/2018, 16h19

Bon j'ai revue en profondeur ma copie en me basant sur les travaux de sylozof

https://blog.vandenbrand.org/2012/06...st-webservice/

J'a donc mon implémentation du UserInterface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\EquatableInterface;
 
class MyUser implements UserInterface, EquatableInterface
{
    private $username;
    private $password;
    public $data;
 
    public function __construct($username)
    {
        $this->username = $username;
    }
 
    public function setData($data = array())
    {
        $this->data = $data;
    }
 
    public function getPermissions()
    {
        return !empty($this->data['permissions'])  ? $this->data['permissions']  : array();
    }
 
    public function getAccessToken()
    {
        return !empty($this->data['access_token'])  ? $this->data['access_token']  : '';
    }
 
    public function getRefreshToken()
    {
        return !empty($this->data['refresh_token'])  ? $this->data['refresh_token']  : '';
    }
 
    public function getRoles()
    {
        return array('ROLE_USER', 'ROLE_my_USER');
    }
 
    public function setPassword($password)
    {
        $this->password = $password;
    }
 
    public function getPassword()
    {
        return $this->password;
    }
 
    public function getSalt()
    {
        return null;
    }
 
    public function getUsername()
    {
        return $this->username;
    }
 
    public function eraseCredentials()
    {
    }
 
    public function isEqualTo(UserInterface $user)
    {
        if (!$user instanceof MyUser) {
            return false;
        }
        return $this->username === $user->getUsername();
    }
}

Puis mon UserAuthenticationProvider

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
use MyBundle\Entity\MyUser;
use MyBundle\Services\MyApi;
use Symfony\Bridge\Monolog\Logger;
use Symfony\Component\Security\Core\Authentication\Provider\UserAuthenticationProvider;
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Core\User\UserCheckerInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Exception\BadCredentialsException;
use Symfony\Component\Security\Core\Exception\AuthenticationServiceException;
use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
use Symfony\Component\Security\Core\Exception\AuthenticationException;
 
class MyUserAuthenticationProvider extends UserAuthenticationProvider
{
    private $providerKey;
    private $userProvider;
 
    /** @var MyApi */
    private $api;
 
    /** @var Logger */
    private $logger;
 
    public function __construct(MyApi $api, UserProviderInterface $userProvider, UserCheckerInterface $userChecker, $providerKey, $hideUserNotFoundExceptions = true, $logger)
    {
        parent::__construct($userChecker, $providerKey, $hideUserNotFoundExceptions);
        $this->providerKey = $providerKey;
        $this->userProvider = $userProvider;
        $this->api = $api;
        $this->logger = $logger;
    }
 
    /*
     * Cette méthode réalise l'authentification, mais en réalité celle-ci a déjà été faite dans la méthode retrieveUser.
     * En effet, la classe mère UserAuthenticationProvider contient une méthode authenticate() qui fait appel d'abord à retrieveUser()
     * et ensuite à checkAuthentication().
     *
     * retrieveUser() doit renvoyer un objet UserInterface.
     * Pour cela, le service web doit être contacté, et ce service web a besoin du login et du mot de passe en paramètres d'entrée.
     *
     * Le service vérifie la correspondance login et mot de passe, et si c'est OK il renvoie les données du client
     * Ainsi, la méthode retrieveUser() réalise déjà une sorte d'authentification (dans le sens où login et mot de passe sont vérifiés à ce moment),
     * mais ce n'est pas dans cette méthode que le système de sécurité de Symfony va être informé du succès ou de l'échec de l'authentification.
     *
     * Ce n'est qu'à l'exécution de checkAuthentication() que l'authentification proprement dite est faite.
     * Cependant, dans le cas où retrieveUser() a retourné un objet UserInterface, l'authentification dans checkAuthentication() sera forcément un succès.
     *
     * Et si retrieveUser() n'a pas retourné d'objet UserInterface, c'est qu'il n'existe pas de client avec login et le mot de passe fournis par la personne qui s'est connectée.
     *
     * Dans ce cas retrieveUser() aura renvoyé une exception qui sera gérée par la méthode authenticate() de la classe mère UserAuthencationProvider et checkAuthentication() ne sera même pas exécutée.
     *
     * checkAuthentication() est donc en quelque sorte inutile : soit retrieveUser() renvoie un objet UserInterface, et dans ce cas checkAuthentication()
     * permettra forcément l'authentification, soit retrieveUser() lance une exception, et dans ce cas checkAuthentication() n'est pas exécutée.
     * Cependant, pour le respect du système d'authentification tel qu'il a été pensé par Symfony, cette méthode est tout de même implémentée.
     */
 
    /**
     * Does additional checks on the user and token (like validating the credentials).
     *
     * @param UserInterface $user
     * @param UsernamePasswordToken $token
     *
     * @throws AuthenticationException if the credentials could not be validated
     */
    protected function checkAuthentication(UserInterface $user, UsernamePasswordToken $token)
    {
        $this->logger->debug(__METHOD__, ['$user'=>$user, '$token' => $token]);
 
        $currentUser = $token->getUser();
 
        if ($currentUser instanceof UserInterface) {
            if ($currentUser->getPassword() !== $user->getPassword())
            {
                throw new BadCredentialsException('Les identifiants ont été modifiés à partir d\'une autre session.');
            }
        } else {
            if (!$presentedPassword = $token->getCredentials()) {
                throw new BadCredentialsException('Le mot de passe ne peut pas être vide.');
            }
 
            $login = $token->getUsername();
            $password = $presentedPassword;
 
            try {
                $this->api->OAuthPassword($login, $password);
            } catch (\Exception $e) {
                throw new BadCredentialsException("Identifiants invalides ($login, $password). ". $e->getMessage(), 0, $e);
            }
        }
    }
 
    /**
     * Retrieves the user from an implementation-specific location.
     *
     * @param string                $username The username to retrieve
     * @param UsernamePasswordToken $token    The Token
     *
     * @return MyUser|UserInterface The user
     *
     * @throws UsernameNotFoundException        if a User cannot be found by its username (+password)
     * @throws AuthenticationServiceException   thrown when an authentication request could not be processed due to a system problem.
     * @throws AuthenticationException          if the credentials could not be validated
     */
    protected function retrieveUser($username, UsernamePasswordToken $token)
    {
        $this->logger->debug(__METHOD__, ['$username'=>$username, '$token' => $token]);
 
        if ($username == 'NONE_PROVIDED') {
            throw new BadCredentialsException('Bad credentials : $username == NONE_PROVIDED');
        }
 
        // I'm doubtful about the usefulness of this part...
        $user = $token->getUser();
        if ($user instanceof UserInterface) {
            $this->logger->debug('$user est déjà une instance de UserInterface. On le retourne.', ['$user'=>$user]);
            return $user;
        }
        $this->logger->debug('$user n\'est pas une instance de UserInterface', ['$user'=>$user]);
        // End doubtful
 
        $login = $username;
        $password = $token->getCredentials();
 
        try {
            $data1 = $this->api->OAuthPassword($login, $password);
            $access_token = $data1['access_token'];
        } catch (\Exception $e) {
            // UsernameNotFoundException is thrown if a User cannot be found by its username. extends AuthenticationException
            $n = new UsernameNotFoundException('Utilisateur non trouvé par le WS. '. $e->getMessage(), 0, $e);
            $n->setUsername($login);
            throw $n;
        }
 
        try {
            $data2 = $this->api->OAuthCheckToken($access_token);
            $data3 = $this->api->OAuthPermissions($access_token);
            $data = array_merge($data1, $data2 , $data3);
            $user = new MyUser($login);
            $user->setPassword($password);
            $user->setData($data);
            return $user;
        } catch (\Exception $e) {
            // AuthenticationServiceException is thrown when an authentication request could not be processed due to a system problem. extends AuthenticationException
            throw new AuthenticationServiceException('Access token invalide. '. $e->getMessage(), 0, $e);
        }
    }
 
    public function supports(TokenInterface $token)
    {
        return $token instanceof UsernamePasswordToken;
    }
}

La FormLoginFactory :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
use MyBundle\Security\Authentication\Provider\MyUserAuthenticationProvider;
use Symfony\Bundle\SecurityBundle\DependencyInjection\Security\Factory\FormLoginFactory;
use Symfony\Component\DependencyInjection\ChildDefinition;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
 
class MyFormLoginFactory extends FormLoginFactory
{
    public function createAuthProvider(ContainerBuilder $container, $id, $config, $userProvider)
    {
        $providerId = 'security.authentication_provider.my.' . $id;
        $container
            ->setDefinition($providerId, new ChildDefinition(MyUserAuthenticationProvider::class))
            ->replaceArgument(1, new Reference($userProvider))
            ->replaceArgument(3, $id)
        ;
        return $providerId;
    }
 
    public function getListenerId()
    {
        return 'security.authentication.listener.form';
    }
 
    public function getKey()
    {
        return 'my';
    }
}

Qui est ingecté dans le SecurityListenerFactory par mon Bundle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
use MyBundle\Security\Factory\MyFormLoginFactory;
use Symfony\Bundle\SecurityBundle\DependencyInjection\SecurityExtension;
use Symfony\Component\HttpKernel\Bundle\Bundle;
use Symfony\Component\DependencyInjection\ContainerBuilder;
 
class MYBundle extends Bundle
{
 
    public function build(ContainerBuilder $container)
    {
        parent::build($container);
 
        /** @var SecurityExtension $extension */
        $extension = $container->getExtension('security');
        $extension->addSecurityListenerFactory(new MyFormLoginFactory());
    }
}

Pour finir, la configuration de mes services et de la sécurité.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
services:
    my.api:
        class: MyBundle\Services\MyApi
        arguments:
                - '%my.base_url%'
                - '%my.authorization%'
                - '@monolog.logger.my'
 
    MyBundle\Security\Authentication\Provider\MyUserAuthenticationProvider:
        class: MyBundle\Security\Authentication\Provider\MyUserAuthenticationProvider
        arguments:
            - '@my.api'
            - # User Provider
            - '@security.user_checker'
            - # Provider-shared Key
            - '%security.authentication.hide_user_not_found%'
            - '@monolog.logger.my'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
security:
    providers:
        chain_provider:
            chain:
                providers:
                    - ezpublish
        ezpublish:
            id: ezpublish.security.user_provider
 
    firewalls:
        dev:
            pattern: ^/(_(profiler|wdt)|css|images|js|lib)/
            security: false
 
        ezpublish_forgot_password:
            pattern: /user/(forgot-password|reset-password)
            security: false
 
        ezpublish_front:
            pattern: ^/
            anonymous: ~
            ezpublish_rest_session: ~
            form_login:
                require_previous_session: false
            logout: ~
            my: true # Attache la factory
 
        main:
            anonymous: ~

[eZ] Mise en place d'un User Provider [3.x]

Symfony PHP

Vue hybride

Discussions similaires

Partager

Partager