Les privilèges dans l'environnement Microsoft [Tutoriel]

**ram-0000** · 23/09/2010, 19h42

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** · 27/09/2010, 11h36

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** · 27/09/2010, 11h56

Envoyé par nicolas.sitbon

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 ?)

Envoyé par nicolas.sitbon

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

**nicolas.sitbon** · 27/09/2010, 13h54

Envoyé par ram-0000

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** · 27/09/2010, 19h09

Envoyé par nicolas.sitbon

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** · 27/09/2010, 19h28

you're welcome!

**Médinoc** · 30/09/2010, 17h11

Quelques petits trucs de clarification:

En fait, "bypass traverse checking" signifie qu'on peut lire un fichier auquel on a accès même s'il est dans un répertoire auquel on n'a pas accès.

Une autre fonction utile est LsaAddAccountRights(), qui permet une gestion non-graphique des privilèges. Je m'en étais servi pour donner le privilège SystemTime à mon compte non-admin sous XP familial (si j'y pense encore en rentrant ce soir, je pourrai donner un code exemple).

**ram-0000** · 30/09/2010, 19h53

Envoyé par Médinoc

En fait, "bypass traverse checking" signifie qu'on peut lire un fichier auquel on a accès même s'il est dans un répertoire auquel on n'a pas accès.

Complément ajouté, merci !!

Envoyé par Médinoc

Une autre fonction utile est LsaAddAccountRights(), qui permet une gestion non-graphique des privilèges. Je m'en étais servi pour donner le privilège SystemTime à mon compte non-admin sous XP familial (si j'y pense encore en rentrant ce soir, je pourrai donner un code exemple).

Je compléterai ultérieurement l'article avec un rapide survol des fonctions Lsaxxx mais je suis preneur de ton code.

**Médinoc** · 01/10/2010, 23h03

Voilà le code tel quel. Il utilise du (mauvais) C++ si on ne compile pas en Unicode (TCHAR vs WCHAR), mais pour le reste il devrait pouvoir compiler en C sans trop de problèmes.

Code C++ :

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
// AddPrivilege.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <string>
#include <sstream>
 
#ifndef STATUS_SUCCESS
#define STATUS_SUCCESS 0
#endif
//Déclarations manquantes dans MinGW.
#ifndef _MSC_VER
namespace std
{
typedef basic_ostringstream< wchar_t > wostringstream;
}
#endif
 
//Direct copy from MSDN, updated for /wp64.
static bool InitLsaString(
  PLSA_UNICODE_STRING pLsaString,
  LPCWSTR pwszString
)
{
  size_t nLen = 0;
 
  if (NULL == pLsaString)
      return FALSE;
 
  if (NULL != pwszString)
  {
      nLen = wcslen(pwszString);
      if (nLen > 0x7ffe)   // String is too large
          return FALSE;
  }
 
  // Store the string.
  pLsaString->Buffer = const_cast< WCHAR * >(pwszString);
  pLsaString->Length =  (USHORT)nLen * sizeof(WCHAR);
  pLsaString->MaximumLength= (USHORT)(nLen+1) * sizeof(WCHAR);
 
  return TRUE;
}
 
//Direct copy from MSDN, updated for name in parameters.
static void AddPrivileges(LPCWSTR sczName, PSID AccountSID, LSA_HANDLE PolicyHandle)
{
	LSA_UNICODE_STRING lucPrivilege;
	NTSTATUS ntsResult;
 
	// Create an LSA_UNICODE_STRING for the privilege names.
	if(!InitLsaString(&lucPrivilege, sczName))
	{
		wprintf(L"Failed InitLsaString\n");
		return;
	}
 
	ntsResult = LsaAddAccountRights(
	 PolicyHandle,  // An open policy handle.
	 AccountSID,    // The target SID.
	 &lucPrivilege, // The privileges.
	 1              // Number of privileges.
	);
	if (ntsResult == STATUS_SUCCESS)
	{
		wprintf(L"Privilege added.\n");
	}
	else
	{
		wprintf(L"Privilege was not added - %lu \n",
		LsaNtStatusToWinError(ntsResult));
	}
}
 
static PSID GetSid(LPCTSTR name)
{
	PSID pSid = NULL;
	LPTSTR szDomain = NULL;
	DWORD cbSid = 0;
	DWORD cbDomain = 0;
	SID_NAME_USE use;
	if( !LookupAccountName(NULL, name, NULL, &cbSid, NULL, &cbDomain, &use) && GetLastError()!=ERROR_INSUFFICIENT_BUFFER )
	{
		wprintf(L"Failed to get SID size - %lu\n", GetLastError());
		return NULL;
	}
 
	pSid = reinterpret_cast< PSID >(new BYTE[cbSid]);
	if(pSid)
	{
		BOOL bOK = FALSE;
		szDomain = new TCHAR[cbDomain];
		if(szDomain)
		{
			bOK = LookupAccountName(NULL, name, pSid, &cbSid, szDomain, &cbDomain, &use);
			delete[] szDomain;
		}
 
		if(!bOK)
		{
			delete[] reinterpret_cast<BYTE *>(pSid);
			pSid = NULL;
		}
	}
 
	if(pSid)
		wprintf(L"Got SID!\n");
	else
		wprintf(L"Failed to get SID - %lu\n", GetLastError());
	return pSid;
}
 
static void MyFreeSid(PSID pSid)
{
	delete[] reinterpret_cast< BYTE * >(pSid);
}
 
//
// M A I N
//
int _tmain(/*int argc, _TCHAR* argv[]*/)
{
	LPCTSTR name = SE_SYSTEMTIME_NAME;
	LPCWSTR nameW;
	#ifndef UNICODE
	std::wostringstream ossW;
	ossW << name;
	std::wstring sNameW = ossW.str();
	nameW = sNameW.c_str();
	#else
	nameW = name;
	#endif
	LSA_OBJECT_ATTRIBUTES attr = {0}; //Le warning est idiot.
	LSA_HANDLE hPol = NULL;
	attr.Length = sizeof(attr);
 
	//Remplacer la chaîne en dessous par le nom d'utilisateur.
	//Généralement, c'est le nom du dossier dans Documents and Settings.
	PSID pSid = GetSid(_T("Frederic"));
	if(pSid)
	{
		NTSTATUS ntsResult = LsaOpenPolicy(NULL, &attr, POLICY_ALL_ACCESS, &hPol);
		if(ntsResult == STATUS_SUCCESS)
		{
			wprintf(L"Policy opened!\n");
 
			wprintf(L"Trying to add privilege %s...\n", nameW);
			AddPrivileges(nameW, pSid, hPol);
			LsaClose(hPol);
		}
		else
		{
		wprintf(L"Failed to open policy - %lu \n",
		  LsaNtStatusToWinError(ntsResult));
		}
		MyFreeSid(pSid);
	}
	return 0;
}

**alexisleprogrammeur** · 02/03/2013, 07h19

Heuu Heuuu...
Comme vous pouvez le constater je n'ai pas d'insigne d'expert mais je crois fort en l'amélioration.
Ce sujet je suis tombé dessus comme par hazard. De plus, il parle d'un langage que j'aime bien. En l'occurrence, le C.

Je ne suis que debutant en C mais secpol je connais un peu vu que j'étais candidat pour l'obtention d'un certificate de Microsoft que j'ai malheureusement rate.Mais utilizer ces codes....... wooooowwww!

je voudrais bien comprendre pas ce que vous faites sous windows avec ces bouts de codes. Mais plutot c'est quoi ces codes. Comment arriver à un niveau pareil en programmation C. Je sais que la réponse est par la pratique

.
Pour mieux préciser, c'est quoi la base de tout ca.

J'espère avoir une répoinse bientot
Un grand merci déjà vu que je n'ai pas vraiment de commentaire à faire visant à améliorer le document

**Médinoc** · 02/03/2013, 09h31

Franchement, à l'époque où j'ai écrit le prog pour la première fois, c'était une bête recopie de MSDN, sauf pour le main().

J'avais fait ce programme pour me donner le privilège SystemTime, car ne pas pouvoir voir le calendrier était ce qui m'embêtait le plus quand j'utilisais mon Windows XP en tant qu'utilisateur limité, par prudence. J'ai déjà dit ça.

Les privilèges dans l'environnement Microsoft [Tutoriel]

Windows

Discussions similaires

Partager

Partager