[2.x] Authentification et entity manager

Authentification et entity manager

Salut,

j'ai enfin réussi à configurer mon authentification avec LDAP, mon soucis aujourd'hui viens de la gestion des rôles.

Pour ma gestion des rôles elle doit se faire sur une base de donnée MySQL, donc dans le constructeur de mon User je rentre mes infos tiré du ldap et ensuite je fait une recherche sur ma BDD. (Tous ça pendant l'authentification)

J'arrive pendant l'authentification à récupérer mon Entity Manager que je stock dans mon ldapmanager mais le problème c'est que ensuite mon ldapmanager se fait serializer et unserializer pour le token et ça pose problème car l'em une fois unserializer ne fonctionne plus...

Si quelqu'un connais peut être une méthode pour ne pas serializer que un attribut d'un objet ou aurai une solution je suis preneur !

A mon avis tu es reparti encore dans une usine a gaz et n'applique pas les méthodes normales :)

Ce qui est sérialise et stocker dans la session c'est bien ton token, mais celui ci contient déjà tes rôles.

Normalement tu récupère ton user via le userprovider défini dans la conf et passer en paramètre a ton listener.

Ex de Listener :

Code:

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
 
class NTLMListener implements ListenerInterface
{
    protected $securityContext;
    protected $authenticationManager;
    protected $adldap;
    protected $groupPattern = "";
 
    public function __construct(SecurityContextInterface $securityContext,
        AuthenticationManagerInterface $authenticationManager,
        Ldap $adldap,
        $groupPattern)
    {
        $this->securityContext = $securityContext;
        $this->authenticationManager = $authenticationManager;
        $this->adldap = $adldap; 
        $this->groupPattern = $groupPattern;
    }
 
    public function handle(GetResponseEvent $event)
    {
        $request = $event->getRequest();
 
        $securityToken = $this->securityContext->getToken();
        if (!isset($securityToken) || !$securityToken->isAuthenticated() )
        {
            if (isset($_SERVER['REMOTE_USER']) && $_SERVER['AUTH_TYPE']=='NTLM') {
                $userdata = explode('\\',$_SERVER['REMOTE_USER']);
                $user = $this->adldap->getUser($userdata[1]);
                if (isset($user)) {
                    $roles = array();
                    if ($this->groupPattern != "") 
                    {
                        $groups = $user->getGroups();
                        foreach ($groups as $group) {
                            if (preg_match($this->groupPattern, $group->getCn(), $matches) == 1)
                            {
                                $roles[] = 'ROLE_'.strtoupper($matches[1]);
                            }
                        }
                    }
                    $securityToken = new NTLMUserToken($roles);
                    $securityToken->setUser($user->getSamaccountname());
                    $securityToken->setDomain($userdata[0]);
                    $securityToken->setCompany($user->getCompany());
                    $securityToken->setEmail($user->getMail());
                    $securityToken->setName($user->getCn());
                    $securityToken->setSid($user->getObjectsid());
                    $securityToken->setAuthenticated(true);
 
                } else {
                    $securityToken = new NTLMUserToken();
                }
            }
        }
 
 
        try {
            $returnValue = $this->authenticationManager->authenticate($securityToken);
            if ($returnValue instanceof TokenInterface) {
                return $this->securityContext->setToken($returnValue);
            } else if ($returnValue instanceof Response) {
                return $event->setResponse($response);
            }
        } catch (AuthenticationException $e) {}
 
        $response = new Response();
        $response->setStatusCode(403);
        $event->setResponse($response);
    }
}

Les tokens :

Code:

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
 
 
class NTLMUserToken extends AbstractToken
{
 
    public function getCredentials()
    {
        return md5($this->getUser());
    }
 
    public function getUserId() 
    {
        return $this->getAttribute('userId');
    }
 
    public function setUserId($id) 
    {
        $this->setAttribute('userId', $id);
    }     
 
    public function getSid() 
    {
        return $this->getAttribute('sid');
    }
 
    public function setSid($sid) 
    {
        $this->setAttribute('sid', $sid);
    }    
 
    public function getDomain() 
    {
        return $this->getAttribute('domain');
    }
 
    public function setDomain($domain) 
    {
        $this->setAttribute('domain', $domain);
    }
 
    public function getName() 
    {
        return $this->getAttribute('name');
    }
 
    public function setName($name) 
    {
        $this->setAttribute('name', $name);
    }  
 
    public function getCompany() 
    {
        return $this->getAttribute('company');
    }
 
    public function setCompany($company) 
    {  
        $this->setAttribute('company', $company);
    }  
 
    public function getEmail() 
    {
        return $this->getAttribute('email');
    }
 
    public function setEmail($email) 
    {
        $this->setAttribute('email', $email);
    }  
 
}

Le provider ultra simple pour mon cas mais a completer avec ta gestion car il recupere ici ton user provider :

Code:

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
 
class NTLMProvider implements AuthenticationProviderInterface
{
    private $userProvider;
 
    public function __construct(UserProviderInterface $userProvider)
    {
        $this->userProvider = $userProvider;
    }
 
    public function authenticate(TokenInterface $token)
    {
       if($token->isAuthenticated())
       {
            $token->setUser($token->getUsername());
            return $token;
       }
 
       throw new AuthenticationException('The NTLM authentication failed.');
    }
 
    public function supports(TokenInterface $token)
    {
        return $token instanceof NTLMUserToken;
    }
}

Merci ta réponse m'a bien aidé j'ai tous reconstruis comme il faut ça marche impeccable !! :)

Bonjour à vous, serait-il possible d'avoir la source qui t'a permis de mettre en place NTLM?

Un grand merci d'avance.