Discussion :

[ram-0000]

Présentation des privilèges d'exécution dans l'environnement Microsoft Windows

Cet article a pour but de présenter la notion de "privilège" dans l'environnement Microsoft Windows et de montrer par un exemple simple écrit en C leur manipulation.

A vos commentaires !

[nicolas.sitbon]

Le code est du C++ et non du C (et je ne dis pas cela à cause de l'extension). En dehors de ça, c'est un excellent article qui a le mérite d'être précis et concis.

[ram-0000]

Le code est du C++ et non du C (et je ne dis pas cela à cause de l'extension).

Effectivement, l'extension en .ccp ne fait pas très C (, tellement l'habitude) mais il me semble que le code en lui même est du C (ou alors j'aurais manqué quelque chose ?)

En dehors de ça, c'est un excellent article qui a le mérite d'être précis et concis.

[nicolas.sitbon]

Effectivement, l'extension en .ccp ne fait pas très C (, tellement l'habitude) mais il me semble que le code en lui même est du C (ou alors j'aurais manqué quelque chose ?)

Le nom des paramètres n'est pas optionnel en C (voir le prototype de la fonction main), la déclaration dans l'entête de la boucle for n'existe qu'en C99, à ma connaissance non supporté par Microsoft, j'ai remarqué aussi plusieurs erreurs dans le code, notamment, CharToOem(), son premier paramètre est de type char const * et tu lui passes un wchar_t *, ensuite

Code :

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

1
2
/* allocation d'un buffer de 4096 BYTES */
BYTE * buffer[4096];

tu n'alloues pas 4096 BYTES mais 4096 pointeur sur BYTES, ce qui n'est pas vraiment grave dans la mesure ou c'est plus grand, mais l'utilisation que tu en fait est inapproprié:

Code :

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

TOKEN_PRIVILEGES * pTokenPrivileges = (TOKEN_PRIVILEGES *)buffer;

tu mélanges aussi instructions et déclarations...

Bref plutôt que rester là à critiquer ton code bêtement, je te propose une correction:

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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif

#include <tchar.h>
#include <locale.h>
#include <stdio.h>

#include <windows.h>
#include <ntsecapi.h>

#define HEAPALLOC(size)  HeapAlloc(GetProcessHeap(), 0, (size))
#define HEAPFREE(memory) HeapFree(GetProcessHeap(), 0, (memory)), (memory) = NULL

static void DisplayError(LPCTSTR message)
{
   LPTSTR buffer = NULL;
   if(message == NULL){message = _T("Error");}

   if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL, GetLastError(), 0, (LPTSTR)&buffer, 0, NULL) == 0)
   {
      if(GetLastError() == ERROR_NOT_ENOUGH_MEMORY)
      {
         _ftprintf(stderr, _T("%s : not enough memory\n"), message);
      }
      else
      {
         _ftprintf(stderr, _T("FormatMessage() failed : %lu\n"), GetLastError());
      }
   }
   else
   {
      _ftprintf(stderr, _T("%s : %s\n"), message, buffer);
      LocalFree(buffer), buffer = NULL;
   }
}

static LPVOID GetAllocatedTokenInformation(HANDLE token, TOKEN_INFORMATION_CLASS tokenInformationClass)
{
   LPVOID tokenInformation = NULL;
   DWORD length = 0;
   
   GetTokenInformation(token, tokenInformationClass, NULL, 0, &length); /* it must fail, we just want the good size */

   if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
   {
      SetLastError(ERROR_SUCCESS);
      tokenInformation = HEAPALLOC(length);


      if(tokenInformation != NULL && GetTokenInformation(token, TokenPrivileges, tokenInformation, length, &length) == FALSE)
      {
         DWORD lastError = GetLastError();
         HEAPFREE(tokenInformation);
         SetLastError(lastError);
      }
   }

   return tokenInformation;
}

static LPTSTR LookupAllocatedPrivilegeName(LPCTSTR systemName, PLUID luid)
{
   LPTSTR privilegeName = NULL;
   DWORD length = 0;
   LookupPrivilegeName(systemName, luid, NULL, &length); /* it must fail, we just want the good size */

   if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
   {
      privilegeName = (LPTSTR)HEAPALLOC((length + 1) * sizeof *privilegeName);

      if(privilegeName != NULL && LookupPrivilegeName(systemName, luid, privilegeName, &length) == FALSE)
      {
         DWORD lastError = GetLastError();
         HEAPFREE(privilegeName);
         SetLastError(lastError);
      }
   }

   return privilegeName;
}

static LPTSTR LookupAllocatedPrivilegeDisplayName(LPCTSTR systemName, LPCTSTR privilegeName, LPDWORD languageId)
{
   LPTSTR privilegeDisplayName = NULL;
   DWORD length = 0;
   
   LookupPrivilegeDisplayName(systemName, privilegeName, NULL, &length, languageId); /* it must fail, we just want the good size */

   if(GetLastError() == ERROR_INSUFFICIENT_BUFFER)
   {
      privilegeDisplayName = (LPTSTR)HEAPALLOC((length + 1) * sizeof *privilegeDisplayName);

      if(privilegeDisplayName != NULL && 
         LookupPrivilegeDisplayName(systemName, privilegeName, privilegeDisplayName, &length, languageId) == FALSE)
      {
         DWORD lastError = GetLastError();
         HEAPFREE(privilegeDisplayName);
         SetLastError(lastError);
      }
   }

   return privilegeDisplayName;
}

static BOOL DisplayTokenPrivileges(HANDLE token)
{
   BOOL ret = TRUE;
   PTOKEN_PRIVILEGES tokenPrivileges = (PTOKEN_PRIVILEGES)GetAllocatedTokenInformation(token, TokenPrivileges);

   _putts(_T("Affichage des privilèges d'un jeton"));

   if(tokenPrivileges == NULL) /* obtention des privileges du token */
   {
      DisplayError(_T("Erreur GetTokenInformation()"));
      ret = FALSE;
   }
   else
   {
      DWORD i = 0;
      LUID_AND_ATTRIBUTES * privileges = tokenPrivileges->Privileges;
      
      for(; i != tokenPrivileges->PrivilegeCount && ret == TRUE; i++) /* enumération de tous les LUID de privilèges */
      {
         LPTSTR privilegeName = LookupAllocatedPrivilegeName(NULL, &privileges[i].Luid);

         if(privilegeName == NULL)
         {
            DisplayError(_T("Erreur LookupPrivilegeName()"));
            ret = FALSE;
         }
         else
         {
            DWORD LangId;
            LPTSTR privilegeDisplayName = LookupAllocatedPrivilegeDisplayName(NULL, privilegeName, &LangId);

            if(privilegeDisplayName == NULL)
            {
               DisplayError(_T("Erreur LookupPrivilegeDisplayName()"));
               ret = FALSE;
            }
            else
            {
               _tprintf(_T("\"%s\" (%s)\n"), privilegeName, privilegeDisplayName);

               if(privileges[i].Attributes & SE_PRIVILEGE_ENABLED_BY_DEFAULT)
               {
                  _putts(_T("\tPrivilège activé par défaut"));
               }

               if(privileges[i].Attributes & SE_PRIVILEGE_ENABLED)
               {
                  _putts(_T("\tPrivilège activé"));
               }
               else
               {
                  _putts(_T("\tPrivilège désactivé"));
               }

               /* cet attribut n'est pas utilisé par la fonction GetTokenInformation(). 
                * Par contre, il peut être positionné par la fonction PrivilegeCheck() */
               if(privileges[i].Attributes & SE_PRIVILEGE_USED_FOR_ACCESS)
               {
                  _putts(_T("\tUtilisé pour vérifier l'accès"));
               }

               HEAPFREE(privilegeDisplayName);
            }

            HEAPFREE(privilegeName);
         }
      }
         
      HEAPFREE(tokenPrivileges);
   }

   return ret;
}

static BOOL SetTokenPrivilege(HANDLE token, LPCTSTR privilege, BOOL enablePrivilege) 
{ 
   LUID luid;
   BOOL ret = LookupPrivilegeValue(NULL, privilege, &luid); /* transforme le nom de privilege en LUID */

   if(ret == FALSE)
   {
      DisplayError(_T("\tErreur LookupPrivilegeValue()"));
   }
   else
   {
      TOKEN_PRIVILEGES tp = {0};
      tp.PrivilegeCount = 1;
      tp.Privileges[0].Luid = luid;
      tp.Privileges[0].Attributes = (enablePrivilege == TRUE) ? SE_PRIVILEGE_ENABLED : 0;

      ret = AdjustTokenPrivileges(token, FALSE, &tp, sizeof(tp), NULL, NULL);

      if(ret == FALSE || GetLastError() == ERROR_NOT_ALL_ASSIGNED)
      { 
         DisplayError(_T("\tErreur AdjustTokenPrivileges()"));
         ret = FALSE;
      }
   }

   return ret;
}

int _tmain()
{
   HANDLE currentProcessToken;
 
   _tsetlocale(LC_ALL, _T(""));

   if(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &currentProcessToken) == FALSE)
   {
      DisplayError(_T("Erreur OpenProcessToken()"));
   }
   else 
   {
      if(DisplayTokenPrivileges(currentProcessToken) != FALSE)
      {
         _tprintf(_T("Tentative de prise du privilège %s\n"), SE_TCB_NAME);

         /* modification des privilèges du token
          * on va tenter de s'autoriser le privilège SE_TCB_NAME ce qui devrait produire une erreur */
         if(SetTokenPrivilege(currentProcessToken, SE_TCB_NAME, TRUE) == FALSE)
         {
            _tprintf(_T("\tImpossible de prendre le privilege %s\n"), SE_TCB_NAME);
         }
         else
         {
            _putts(_T("\t==>OK\n"));
         }

         /* on va s'autoriser le privilège SE_SHUTDOWN_NAME qui est autorisé mais pas activé */
         _tprintf(_T("Tentative de prise du privilège %s\n"), SE_SHUTDOWN_NAME);

         if(SetTokenPrivilege(currentProcessToken, SE_SHUTDOWN_NAME, TRUE) == FALSE)
         {
            _tprintf(_T("Impossible de prendre le privilege %s\n"), SE_SHUTDOWN_NAME);
         }
         else
         {
            _putts(_T("\t==> OK"));
         }

         /* affichage des privilèges du nouveau token
          * ici, on devrait voir une modification dans le privilège SE_SHUTDOWN_NAME, maintenant, il doit être activé */
         DisplayTokenPrivileges(currentProcessToken);
      }

      CloseHandle(currentProcessToken);
   }

   return 0;
}

Cordialement.

[ram-0000]

Bref plutôt que rester là à critiquer ton code bêtement, je te propose une correction...

Proposition acceptée et intégrée dans l'article. (c'est vrai qu'il y avait des trucs bizarres dedans, j'ai dû les coder avec mes deux mains gauches )

pour le coup de main.

[nicolas.sitbon]

you're welcome!