Discussion :

[Mat_F]

Bonjour à tous et toutes,

Cela fait plusieurs jours que je cherche désespéremment des infos sur le mécanisme d'impersonification dans .NET, typiquement dans le but d'accéder à une ressource réseau via un nom d'utilisateur et mot de passe.

La plupart de la documentation fait référence à la fonction LogonUser fournie par advapi32.dll (Advanced Windows 32 Base API DLL). Sur ce point j'ai fait des tests qui ne fonctionnent que partiellement, sans compter que je trouve ça très bizarre de faire appel à une fonction externe au framework .NET

D'autres mentionnent la classe System.Security.Principal, mais la doc correspondante manque cruellement, n'ayant pu trouver aucun exemple concret de code.

Y a-t-il quelqu'un sur ce forum qui ait une expérience concrète avec l'impersonification et qui pourrait clarifier les choses ?

[cinemania]

Pour le réseau, ya les credentials... pas forcément obliger de sortir l'artillerie lourde de l'impersonnification.

Sinon, tout est toujours différence de point de vue. Il existe de quoi changer ton niveau d'accès et acquérir le niveau admin, sous dotnet, mais le changement d'identité à proprement dit n'est pas un comportement très "habituel" dans dotnet, aussi il est normal que le framework ne couvre pas tous les cas et en particulier ces cas là.
La majorité des programmes tournent très bien dans leur propre niveau de privilège et session, car ils sont exécutés sur une machine cliente, d'utilisateur lambda lui même admin.
Il est vrai que dans un environnement serveur, d'entreprise, donc soumis aux AD c'est un peu plus gênant, mais suffisamment rare pour ne pas faire partie du Framework...
Et c'est également pour cette raison que le P/INVOKE existe !

J'ai là du code d'impersonification, et on utilise plusieurs phases, on essaie par dotnet, ensuite par les api, et si ca passe pas comme voulu, par les api et par un process externe exécuté sur la bonne session, grace aux api non dotnet toujours.

[Mat_F]

Merci pour cette contribution, d'un point de vue général cela apporte un éclairage bienvenu.

Pour le réseau, ya les credentials... pas forcément obliger de sortir l'artillerie lourde de l'impersonnification.

Peux-tu STP développer ? Existe-t-il de la doc (avec si possible des exemples de code) là dessus ?

J'ai là du code d'impersonification, et on utilise plusieurs phases, on essaie par dotnet, ensuite par les api, et si ca passe pas comme voulu, par les api et par un process externe exécuté sur la bonne session, grace aux api non dotnet toujours.

Serait-il possible de voir ce code ? Ou au moins développer les points ci-dessus ?

Et qu'en est-il de System.Security.Principal ?

[Max]

Salut.

D'un point de vue du code, tu trouveras plusieurs exemples d'impersonation par là ou par ici (le tout dans le namespace System.Security.Principal )

Il y a d'ailleurs plusieurs sujets dans le forum C# qui traitent du problème ("impersonation" renvoie beaucoup plus de résultats que "impersonification" ).

Bon courage

[Mat_F]

Merci eusebe19, mais malheureusement, après lecture de tous les posts "Impersonation" je n'ai toujours pas avancé

Les liens fournis renvoient tous à la fonction LogonUser (advapi32). L'idée était de trouver une alternative intégrée au Framework .NET via System.Security.Principal (qqn. avait suggéré ça sur un forum sans donner de détails).

cinemania propose d'utiliser les "credentials", malheureusement toujours sans donner de détails ou de liens vers une doc plus conséquente. J'ai essayé de chercher de la doc sur NetworkCredentials mais d'une part je n'en ai pas trouvé et d'autre part on dirait que c'est seulement dans un contexte ASP.Net, alors que ma config est une application Winform.

Help!

[Max]

Les liens fournis renvoient tous à la fonction LogonUser (advapi32). L'idée était de trouver une alternative intégrée au Framework .NET via System.Security.Principal (qqn. avait suggéré ça sur un forum sans donner de détails).

Il y a un élément que je ne comprends pas : ça fait partie de tes contraintes que de ne pas utiliser la fonction LogonUser ?

[Mat_F]

@eusebe19

Pour le réseau, ya les credentials... pas forcément obliger de sortir l'artillerie lourde de l'impersonnification.

Non, ce n'est pas une contrainte mais apparamment l'utilisation de LogonUser via P/Invoke n'est pas le meilleur moyen (ni le plus universel on dirait) de résoudre mon problème : copier un fichier sur une machine distante via un login / password (donc indépendemment des permissions occtroyées par le système à l'application windows qui doit accomplir cette tâche).

[Max]

Non, ce n'est pas une contrainte mais apparamment l'utilisation de LogonUser via P/Invoke n'est pas le meilleur moyen (ni le plus universel on dirait) de résoudre mon problème : copier un fichier sur une machine distante via un login / password (donc indépendemment des permissions occtroyées par le système à l'application windows qui doit accomplir cette tâche).

Tu demandais un retour d'expérience : chez mon client on dispose d'une classe présente dans une librairie qui gère l'impersonation avec LogonUser : le code source, commentaires enlevés, fait environ 200 lignes et 95% de ce dernier est recopié directement depuis MSDN, donc on peut considérer que cela a été très rapidement développé.

Ensuite, à l'utilisation, c'est très simple et ça ressemble à ça, et c'est totalement transparent pour l'utilisateur final :

Code :

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

1
2
3
4
5
using (ImpersonateObject impersonateObject = new  ImpersonateObject()) {
    if (impersonateObject.Impersonate(domain, login, password)) {
        // Le code nécessitant d'autres autorisations
    }
}

Il ne te reste alors qu'à bien placer les informations du user proxy dans ton application, tu peux les mettre par exemple dans une section cryptée d'un app.config, etc.. Tu peux également aller plus loin en créant / détruisant un partage à la volée sur ta machine distante en WMI le temps de faire ta copie, etc., etc..

C'est pourquoi, à mon humble avis, je pense que c'est ce qui a de plus simple, efficace et rapide à mettre en place dans ton cas

[Mat_F]

Bon, explorons donc la méthode P/Invoke. Voici concrètement le code que j'ai réalisé pour effectuer l'impersonation.

Merci eusebe19 ou autres de me donner un avis là-dessus, j'aimerais être sûr que c'est la meilleure façon de faire, notamment au niveau de la gestion mémoire et de la sécurité (sur point, le code fourni n'est probablement pas parfait).

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
 
    public void ImpersonationTest()
    {
        using (Impersonation i = new Impersonation())
        {
            try
            {
                i.Impersonate(
                    "user", 
                    "domain", 
                    "password", 
                    Impersonation.LogonType.LOGON32_LOGON_NEW_CREDENTIALS, 
                    Impersonation.LogonProvider.LOGON32_PROVIDER_WINNT50);
            }
            catch (Exception)
            {
                ...
            }   
        }
    }

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
 
    public class Impersonation : IDisposable
    {
        public enum LogonType
        {
            LOGON32_LOGON_INTERACTIVE = 2,
            LOGON32_LOGON_NETWORK = 3,
            LOGON32_LOGON_BATCH = 4,
            LOGON32_LOGON_SERVICE = 5,
            LOGON32_LOGON_UNLOCK = 7,
            LOGON32_LOGON_NETWORK_CLEARTEXT = 8,
            LOGON32_LOGON_NEW_CREDENTIALS = 9
        };
 
        public enum LogonProvider
        {
            LOGON32_PROVIDER_DEFAULT = 0,
            LOGON32_PROVIDER_WINNT35 = 1,
            LOGON32_PROVIDER_WINNT40 = 2,
            LOGON32_PROVIDER_WINNT50 = 3
        };
 
        [DllImport("advapi32.dll", SetLastError = true)]
        public static extern bool LogonUser(
            string lpszUserName,
            string lpszDomain,
            string lpszPassword,
            int dwLogonType,
            int dwLogonProvider,
            out IntPtr phToken);
 
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern bool CloseHandle(IntPtr handle);
 
        private WindowsImpersonationContext _impersonationContext;
 
        public Impersonation()
        {
            _impersonationContext = null;
        }
 
        public void Impersonate(
            string userName,
            string domainName,
            string password,
            LogonType logonType,
            LogonProvider logonProvider)
        {
            IntPtr impersonationToken = IntPtr.Zero;
            try
            {
                if (LogonUser(
                    userName,
                    domainName,
                    password,
                    (int)logonType,
                    (int)logonProvider,
                    out impersonationToken))
                {
                    WindowsIdentity impersonationIdentity = new WindowsIdentity(impersonationToken);
                    _impersonationContext = impersonationIdentity.Impersonate();
                }
                else
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }
            }
            finally
            {
                if (impersonationToken != IntPtr.Zero)
                {
                    CloseHandle(impersonationToken);
                }
            }
        }
 
        private void UndoImpersonation()
        {
            if (_impersonationContext != null)
            {
                _impersonationContext.Undo();
            }
            _impersonationContext = null;
        }
 
        public void Dispose()
        {
            UndoImpersonation();
        }
 
    }

[Max]

j'aimerais être sûr que c'est la meilleure façon de faire, notamment au niveau de la gestion mémoire et de la sécurité (sur point, le code fourni n'est probablement pas parfait).

Salut.

Personnellement, ça me paraît bien .

D'autant plus que c'est ce qu'on trouve sur la MSDN, donc même si tu as des problèmes dans le futur, tu pourras te dédouaner en disant que tu as suivi les préconisations M$