Gérer les droit d'accès d'un dossier / fichier

J'ai retrouvé un vieux code mal indenté qui fait ça...

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
/*
ListerDroitsDAcces.h:
	Fichier d'en-tête principal de ListerDroitsDAcces.
	Contient les prototypes de fonction, etc.
*/
 
//=== Prototypes de fonction ===
//--- Fonctions de AfficherAide.cpp ---
void AfficherAide(void);
 
//--- Fonctions de AfficherDroitsDAccess.cpp ---
void AfficherDroitsDAccess(
 LPCTSTR const sczFichier
 );
void AfficherDroitsFichier(
 DWORD dwAcces
 );
void AfficherDroitsStandard(
 DWORD dwAcces
 );
void AfficherDroitsAutres(
 DWORD dwAcces
 );
 
//--- Fonctions de ListerDroitsDAcces.cpp ---
SECURITY_DESCRIPTOR * GetDescripteurSecuriteFichier(
 LPCTSTR const sczFichier,	//[in] Nom de fichier
 SECURITY_INFORMATION const typeInfos,	//[in] Informations à récupérer
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );
SECURITY_DESCRIPTOR * GetDescripteurSecuriteObjet(
 HANDLE const hObjet,	//[in] Objet dont on veut le descripteur
 SECURITY_INFORMATION const typeInfos,	//[in] Informations à récupérer
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );
BOOL FreeDescripteurSecurite(
 SECURITY_DESCRIPTOR * const pt_descSuppr	//[in] Descripteur à détruire
 );
BOOL GetUserRightsFromDescWithNameC(
 SECURITY_DESCRIPTOR * const pt_secDesc,	//[in] descripteur de sécurité
 LPCTSTR const sczNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );
BOOL GetUserRightsFromDescWithName(
 SECURITY_DESCRIPTOR * const pt_secDesc,	//[in] descripteur de sécurité
 LPTSTR const szNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );
BOOL GetUserRightsFromAclWithNameC(
 PACL const pt_acl,	//[in] Liste de contrôle d'accès à consulter
 LPCTSTR const sczNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );
BOOL GetUserRightsFromAclWithName(
 PACL const pt_acl,	//[in] Liste de contrôle d'accès à consulter
 LPTSTR const szNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );
BOOL GetNomProprietaire(
 SECURITY_DESCRIPTOR * const pt_secDesc,	//[in] descripteur de sécurité
 LPTSTR const szNomProprio,	//[out] Nom d'utilisateur du propriétaire
 LPDWORD pt_dwTailleNom,	//[in/out] Taille du buffer/nom d'utilisateur
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 );

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
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
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
/*
ListerDroitsDAcces.cpp:
	Ce fichier contient les fonctions pour examiner les droits d'accès
	d'un fichier.
*/
 
#include "stdafx.h"
#include "ListerDroitsDAcces.h"
 
 
 
/* Fonction pour obtenir le descripteur de sécurité d'un fichier
   ------------------------------------------------------------- */
SECURITY_DESCRIPTOR * GetDescripteurSecuriteFichier(
 LPCTSTR const sczFichier,	//[in] Nom de fichier
 SECURITY_INFORMATION const typeInfos,	//[in] Informations à récupérer
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
DWORD dwErreur = 0;
SECURITY_DESCRIPTOR *pt_descRetour = NULL; 
 
#ifdef _DEBUG
EcritSortieA("Recherche de \"", stdout, ES_OEM_STDOUT);
EcritSortie(sczFichier, stdout, ES_STDOUT);
EcritSortieA("\"\n", stdout, ES_OEM_STDOUT);
#endif
 
HANDLE hFichier = CreateFile(
 sczFichier,
 READ_CONTROL,
 FILE_SHARE_READ,
 NULL,
 OPEN_EXISTING,
 FILE_FLAG_BACKUP_SEMANTICS,
 NULL
 );
if(hFichier != INVALID_HANDLE_VALUE)
	{
	#ifdef _DEBUG
	EcritSortieA("Fichier ouvert en lecture.\n", stdout, ES_OEM_STDOUT);
	#endif
 
	pt_descRetour = GetDescripteurSecuriteObjet(hFichier, typeInfos, bEcritErreur);
 
	CloseHandle(hFichier);
	}
else
	{
	LPTSTR szMessage = FormatErreur(dwErreur);
	EcritSortieA("Échec d'ouverture du fichier - ", stdout, ES_STDOUT);
	EcritSortie(szMessage, stdout, ES_STDOUT);
	LocalFree(szMessage);
	}
return pt_descRetour;
}
 
 
/* Obtenir le descripteur de sécurité d'un objet ouvert
   ---------------------------------------------------- */
SECURITY_DESCRIPTOR * GetDescripteurSecuriteObjet(
 HANDLE const hObjet,	//[in] Objet dont on veut le descripteur
 SECURITY_INFORMATION const typeInfos,	//[in] Informations à récupérer
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
DWORD dwTaille = 0;
DWORD dwErreur = ERROR_SUCCESS;
SECURITY_DESCRIPTOR * pt_descRetour = NULL; 
 
//Premier essai : sans buffer
BOOL bOK = GetKernelObjectSecurity(
 hObjet,
 typeInfos,
 NULL,
 0,
 &dwTaille
 );
dwErreur = GetLastError();
 
if( !bOK && ERROR_INSUFFICIENT_BUFFER==dwErreur)
	{
	//Alloue le buffer demandé
	pt_descRetour = FROMVOID_CAST(SECURITY_DESCRIPTOR *,
	 HeapAlloc(GetProcessHeap(), 0, dwTaille)
	 );
	if(pt_descRetour)
		{
		//Second essai : avec buffer
		bOK = GetKernelObjectSecurity(
		 hObjet,
		 typeInfos,
		 pt_descRetour,
		 dwTaille,
		 &dwTaille
		 );
		dwErreur = GetLastError();
 
		//Résultat...
		#ifdef _DEBUG
		_tprintf(_T("Resultat de BOOL GetKernelObjectSecurity() : %d\n"), bOK);
		#endif
		if( bOK )
			{
			//OK, cool...
			}
		else
			{
			//Échec de GetFileSecurity()
			if(bEcritErreur)
				{
				LPTSTR szMessage = FormatErreur(dwErreur);
				EcritSortieA("Échec de récupération des informations - ", 
				 stdout, ES_STDOUT
				 );
				EcritSortie(szMessage, stdout, ES_STDOUT);
				LocalFree(szMessage);
				}
			}// if /bOK
 
		//Libère la mémoire allouée si échec
		if( !bOK )
			{
			FreeDescripteurSecurite(pt_descRetour);
			pt_descRetour = NULL;
			}
		}
	else//Échec de HeapAlloc()
		{
		if(bEcritErreur)
			{
			LPTSTR szMessage = FormatErreur(dwErreur);
			EcritSortieA("Échec d'allocation mémoire - ", stdout, ES_STDOUT);
			EcritSortie(szMessage, stdout, ES_STDOUT);
			LocalFree(szMessage);
			}
		}//if /HeapAlloc()
	}
else//Échec autre que ERROR_INSUFFICIENT_BUFFER ou succès anormal.
	{
	if(bEcritErreur)
		{
		LPTSTR szMessage = FormatErreur(dwErreur);
		EcritSortieA("Échec d'acquisition de taille du descripteur - ", 
		 stdout, ES_STDOUT
		 );
		EcritSortie(szMessage, stdout, ES_STDOUT);
		LocalFree(szMessage);
		}
	}//if /GetKernelObjectSecurity(NULL)
return pt_descRetour;
}
 
 
/* Fonction  pour libérer la mémoire d'un descripteur de sécurité
   -------------------------------------------------------------- */
BOOL FreeDescripteurSecurite(
 SECURITY_DESCRIPTOR * const pt_descSuppr	//[in] Descripteur à détruire
 )
{
return HeapFree(GetProcessHeap(), 0, pt_descSuppr);
}
 
 
 
/* Fonction pour récupérer les droits à partir d'un nom const d'utilisateur
   ------------------------------------------------------------------------ */
BOOL GetUserRightsFromDescWithNameC(
 SECURITY_DESCRIPTOR * const pt_secDesc,	//[in] descripteur de sécurité
 LPCTSTR const sczNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
//Effectue une copie du nom avant d'appeler la fonction
TCHAR szNomUser[UNLEN+1] = _T("");
if(sczNomUser==NULL
 || _tcslen(sczNomUser) > UNLEN
 )
	return FALSE;
 
lstrcpyn(szNomUser, sczNomUser, UNLEN+1);
szNomUser[UNLEN] = _T('\0');
 
return GetUserRightsFromDescWithName(
 pt_secDesc, szNomUser, pt_dwAcces, bEcritErreur
 );
}
 
 
/* Fonction pour récupérer les droits à partir d'un nom d'utilisateur
   ------------------------------------------------------------------ */
BOOL GetUserRightsFromDescWithName(
 SECURITY_DESCRIPTOR * const pt_secDesc,	//[in] descripteur de sécurité
 LPTSTR const szNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
BOOL bDefaut;
BOOL bDacl;
PACL pt_acl = NULL;
//Récupère la DACL
BOOL bOK = GetSecurityDescriptorDacl(pt_secDesc, &bDacl, &pt_acl, &bDefaut);
DWORD dwErreur = GetLastError();
if(bOK)
	{
	if(bDacl && pt_acl)
		{
		//La DACL est récupérée: On la lit.
		bOK = GetUserRightsFromAclWithName(
		 pt_acl, szNomUser, pt_dwAcces, bEcritErreur
		 );
		}
	else
		{
		//La fonction a réussi mais il n'y a pas de DACL.
		if(bEcritErreur)
			EcritSortieA("Le descripteur de sécurité n'a pas de DACL.\n",
			 stdout, ES_STDOUT
			 );
		bOK = FALSE;
		}
	}
else
	{
	LPTSTR szMessage = FormatErreur(dwErreur);
	EcritSortieA("Échec récupération de la liste d'accès - ", stdout, ES_STDOUT);
	EcritSortie(szMessage, stdout, ES_STDOUT);		
	LocalFree(szMessage);
	}
return bOK;
}
 
 
/* Fonction pour récupérer les droits à partir d'un nom const d'utilisateur
   ------------------------------------------------------------------------ */
BOOL GetUserRightsFromAclWithNameC(
 PACL const pt_acl,	//[in] Liste de contrôle d'accès à consulter
 LPCTSTR const sczNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
//Effectue une copie du nom avant d'appeler la fonction
TCHAR szNomUser[UNLEN+1] = _T("");
if(sczNomUser==NULL
 || _tcslen(sczNomUser) > UNLEN
 )
	{
	SetLastError(ERROR_INVALID_PARAMETER);
	return FALSE;
	}
 
lstrcpyn(szNomUser, sczNomUser, UNLEN+1);
szNomUser[UNLEN] = _T('\0');
 
return GetUserRightsFromAclWithName(
 pt_acl, szNomUser, pt_dwAcces, bEcritErreur
 );
}
 
 
/* Fonction pour récupérer les droits à partir d'un nom d'utilisateur
   ------------------------------------------------------------------ */
BOOL GetUserRightsFromAclWithName(
 PACL const pt_acl,	//[in] Liste de contrôle d'accès à consulter
 LPTSTR const szNomUser,	//[in] Nom de l'utilisateur
 PACCESS_MASK const pt_dwAcces,	//[out] droits d'accès
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
TRUSTEE tr = {0};
BOOL bOK = FALSE;
DWORD dwErreur = ERROR_SUCCESS;
 
if(pt_acl==NULL || szNomUser==NULL || pt_dwAcces==NULL)
	{
	SetLastError(ERROR_INVALID_PARAMETER);
	return FALSE;
	}
 
//Monter le Trustee
BuildTrusteeWithName(
 &tr,
 szNomUser
 );
 
//Lire les droits
dwErreur = GetEffectiveRightsFromAcl(pt_acl, &tr, pt_dwAcces);
bOK = (dwErreur==ERROR_SUCCESS);
 
if( !bOK && bEcritErreur )
	{
	LPTSTR szMessage = FormatErreur(dwErreur);
	EcritSortieA("Échec lecture de la liste d'accès - ", stdout, ES_STDOUT);
	EcritSortie(szMessage, stdout, ES_STDOUT);		
	LocalFree(szMessage);
	}
 
return bOK;
}
 
 
/* Fonction pour retrouver le nom du propriétaire d'un objet
   --------------------------------------------------------- */
BOOL GetNomProprietaire(
 SECURITY_DESCRIPTOR * const pt_secDesc,	//[in] descripteur de sécurité
 LPTSTR const szNomProprio,	//[out] Nom d'utilisateur du propriétaire
 LPDWORD pt_dwTailleNom,	//[in/out] Taille du buffer/nom d'utilisateur
 BOOL const bEcritErreur	//[in] Affiche les erreurs si vrai
 )
{
PSID pt_sid = NULL;
SID_NAME_USE snu;
TCHAR szNomDomaine[DNLEN+1];
DWORD dwTailleDomaine = DNLEN+1;
BOOL bDefaut;
BOOL bOK = FALSE;
DWORD dwErreur = ERROR_SUCCESS;
 
if(pt_secDesc==NULL || szNomProprio==NULL || pt_dwTailleNom==NULL)
	return FALSE;
 
szNomProprio[0] = _T('\0');
 
bOK = GetSecurityDescriptorOwner(pt_secDesc, &pt_sid, &bDefaut);
bOK = bOK && LookupAccountSid(NULL, pt_sid, szNomProprio, pt_dwTailleNom,
 szNomDomaine, &dwTailleDomaine, &snu
 );
dwErreur = GetLastError();
if(bOK)
	{
	//Ben... OK, quoi
	}
else
	{
	//Echec de l'une des fonctions.
	if(bEcritErreur)
		{
		LPTSTR szMessage = FormatErreur(dwErreur);
		EcritSortieA("Echec de recherche du nom du propriétaire\n",
		 stdout, ES_STDOUT
		 ); 
		EcritSortie(szMessage, stdout, ES_STDOUT);
		LocalFree(szMessage);
		#ifdef _DEBUG
		_tprintf(_T("Taille nom : %lu - Taille domaine : %lu\n"),
		 *pt_dwTailleNom, dwTailleDomaine
		 );
		#endif
		}
	}
return bOK;
}

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
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
/*
AfficherDroitsDAcces.cpp:
	Ce fichier contient les fonctions pour afficher les droits d'accès
	d'un fichier. Ces fonctions utilisent celles de ListerDroitsDAcces.cpp.
*/
 
#include "stdafx.h"
#include "ListerDroitsDAcces.h"
 
//Macros de privilège
#define ACTIVER_PRIVILEGE(priv,nom,b) if(IsPrivilegeEnabled(priv))\
	EcritSortieA("(Privilège " nom " actif)\n", stdout, ES_STDOUT);\
else {\
	if(EnablePrivilege(priv, TRUE))	{\
		EcritSortieA("(Privilège " nom " obtenu)\n", stdout, ES_STDOUT);\
		b = TRUE;\
	} else\
		EcritSortieA("(N'a pas obtenu le privilège " nom ")\n", stdout, ES_STDOUT);\
}
 
//Macros pour les fonctions d'affichage
#define TESTER_DROITS(acces, droit)	{ if( ((acces)&(droit))==(droit) ) \
 _tprintf( _T("%08X : %s\n"), (droit), _T( #droit )); }
#define TESTER_DROIT(acces, droit)	{ if( ((acces)&(droit))==(droit) ) \
 _tprintf( _T("%08X :  %s\n"), (droit), _T( #droit )); }
 
 
 
/* Fonction pour afficher les droits d'accès d'un fichier
   ------------------------------------------------------ */
void AfficherDroitsDAccess(
 LPCTSTR const sczFichier
 )
{
DWORD dwErreur = 0;
 
//Pour commencer, on va tenter d'obtenir le privilère Backup, 
//pour avoir l'accès en lecture sur tout.
BOOL bDisablePrivBackup = FALSE;
BOOL bDisablePrivSecurity = FALSE;
BOOL bDisablePrivTakeOwnership = FALSE;
 
ACTIVER_PRIVILEGE(SE_BACKUP_NAME, "Backup", bDisablePrivBackup);
//ACTIVER_PRIVILEGE(SE_SECURITY_NAME, "Security", bDisablePrivSecurity);
//ACTIVER_PRIVILEGE(
// SE_TAKE_OWNERSHIP_NAME, "TakeOwnership", bDisablePrivTakeOwnership
// );
 
#if 0
if(IsPrivilegeEnabled(SE_BACKUP_NAME))
	EcritSortieA("(Privilège Backup actif)\n", stdout, ES_STDOUT);
else
	{
	if(EnablePrivilege(SE_BACKUP_NAME, TRUE))
		{
		EcritSortieA("(Privilège Backup obtenu)\n", stdout, ES_STDOUT);
		bDisablePrivBackup = TRUE;
		}
	else
		EcritSortieA("(N'a pas obtenu le privilège Backup)\n", stdout, ES_STDOUT);
	}
#endif
 
EcritSortieA("Lecture du descripteur de sécurité...\n", stdout, ES_STDOUT);
SECURITY_DESCRIPTOR * pt_desc = GetDescripteurSecuriteFichier(
 sczFichier,
 DACL_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION,
 TRUE
 );
 
if(pt_desc)
	{
	//On a le descripteur de sécurité : On va jouer avec, à présent.
	TCHAR szNomUser[UNLEN+1] = _T("");
	ACCESS_MASK dwAcces;
 
	BOOL bOK = TRUE;
 
	EcritSortieA("Lecture des droits pour l'utilisateur courant...\n",
	 stdout, ES_STDOUT
	 );
 
	//Récupérer le nom de l'utilisateur courant
	if( bOK )
		{
		DWORD dwTailleNom = UNLEN+1;
		bOK = GetUserName(szNomUser, &dwTailleNom);
		dwErreur = GetLastError();
		//lstrcpyn(szNomUser, _T("bidule"), UNLEN);//Test avec un nom pourri
		if( !bOK )
			EcritSortieA("Échec récupération du nom d'utilisateur - ", stdout, ES_STDOUT);
		}
 
	//Lire les droits
	if( bOK )
		{
		bOK = GetUserRightsFromDescWithName(pt_desc, szNomUser, &dwAcces, TRUE);
		dwErreur = GetLastError();
		if( !bOK )
			EcritSortieA("Échec lecture des droits - ", stdout, ES_STDOUT);
		}
 
	if( bOK )
		{
		//La lecture des droits a réussi.
		char szBufNomUserCon[UNLEN+1];
		CharToOem(szNomUser, szBufNomUserCon);
 
		EcritSortieA("Ça marche!\n", stdout, ES_STDOUT);
 
		//Variables locales: Nom du propriétaire
			{
			TCHAR szNomProprio[UNLEN+1] = _T("");
			DWORD dwTailleNom = UNLEN+1;
 
			EcritSortieA("Propriétaire du fichier: ", stdout, ES_STDOUT);
			bOK = GetNomProprietaire(pt_desc, szNomProprio, &dwTailleNom, TRUE);
			if(bOK)
				{
				EcritSortie(szNomProprio, stdout, ES_STDOUT);
				EcritSortieA("\n", stdout, ES_OEM_STDOUT);
				}
			}//variables locales
 
		printf("Droits pour %s : %08lX\n", szBufNomUserCon, dwAcces);
		AfficherDroitsFichier(dwAcces);
		AfficherDroitsStandard(dwAcces);
		AfficherDroitsAutres(dwAcces);
 
		}
	else
		{
		//Echec.
		LPTSTR szMessage = FormatErreur(dwErreur);
		EcritSortie(szMessage, stdout, ES_STDOUT);		
		LocalFree(szMessage);
		}
 
	FreeDescripteurSecurite(pt_desc), pt_desc=NULL;
	}
 
//Retire le privilège si on l'avait
//TODO: (à modifier plus tard)
if(bDisablePrivBackup)
	EnablePrivilege(SE_BACKUP_NAME, FALSE);
if(bDisablePrivSecurity)
	EnablePrivilege(SE_SECURITY_NAME, FALSE);
if(bDisablePrivTakeOwnership)
	EnablePrivilege(SE_TAKE_OWNERSHIP_NAME, FALSE);
}
 
 
/* Fonction pour afficher les droits d'un fichier
   ---------------------------------------------- */
void AfficherDroitsFichier(
 DWORD dwAcces
 )
{
TESTER_DROITS(dwAcces, FILE_ALL_ACCESS);
TESTER_DROITS(dwAcces, FILE_GENERIC_READ);
TESTER_DROITS(dwAcces, FILE_GENERIC_WRITE);
TESTER_DROITS(dwAcces, FILE_GENERIC_EXECUTE);
 
TESTER_DROIT(dwAcces, FILE_READ_DATA);
TESTER_DROIT(dwAcces, FILE_LIST_DIRECTORY);
TESTER_DROIT(dwAcces, FILE_WRITE_DATA);
TESTER_DROIT(dwAcces, FILE_ADD_FILE);
TESTER_DROIT(dwAcces, FILE_APPEND_DATA);
TESTER_DROIT(dwAcces, FILE_ADD_SUBDIRECTORY);
TESTER_DROIT(dwAcces, FILE_CREATE_PIPE_INSTANCE);
TESTER_DROIT(dwAcces, FILE_READ_EA);
TESTER_DROIT(dwAcces, FILE_WRITE_EA);
TESTER_DROIT(dwAcces, FILE_EXECUTE);
TESTER_DROIT(dwAcces, FILE_TRAVERSE);
TESTER_DROIT(dwAcces, FILE_DELETE_CHILD);
TESTER_DROIT(dwAcces, FILE_READ_ATTRIBUTES);
TESTER_DROIT(dwAcces, FILE_WRITE_ATTRIBUTES);
}
 
 
/* Fonction pour afficher les droits standard
   ------------------------------------------ */
void AfficherDroitsStandard(
 DWORD dwAcces
 )
{
TESTER_DROITS(dwAcces, STANDARD_RIGHTS_ALL);
TESTER_DROITS(dwAcces, STANDARD_RIGHTS_EXECUTE);
TESTER_DROITS(dwAcces, STANDARD_RIGHTS_READ);
TESTER_DROITS(dwAcces, STANDARD_RIGHTS_REQUIRED);
TESTER_DROITS(dwAcces, STANDARD_RIGHTS_WRITE);
 
TESTER_DROIT(dwAcces, DELETE);
TESTER_DROIT(dwAcces, READ_CONTROL);
TESTER_DROIT(dwAcces, WRITE_DAC);
TESTER_DROIT(dwAcces, WRITE_OWNER);
TESTER_DROIT(dwAcces, SYNCHRONIZE);
}
 
 
/* Fonction pour afficher les droits ni spécifiques ni standard
   ------------------------------------------------------------ */
void AfficherDroitsAutres(
 DWORD dwAcces
 )
{
TESTER_DROIT(dwAcces, ACCESS_SYSTEM_SECURITY);
TESTER_DROIT(dwAcces, MAXIMUM_ALLOWED);
TESTER_DROIT(dwAcces, GENERIC_ALL);
TESTER_DROIT(dwAcces, GENERIC_EXECUTE);
TESTER_DROIT(dwAcces, GENERIC_WRITE);
TESTER_DROIT(dwAcces, GENERIC_READ);
}

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
//////////////////////////////////////////////////////////////////////////////
// Project : (utilitaires)
// Source file : Privilege.c
//
//////////////////////////////////////////////////////////////////////////////
 
//=== en-tête privé ===
 
//--- inclusions privées ---
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "Util.h"
 
//--- définitions privées ---
 
//--- typedefs privés ---
 
//=== suite de l'en-tête privé ===
 
 
//--- autres définitions privées ---
 
//--- structures privées ---
 
//--- prototypes privés ---
 
//--- définitions unicode privées (A/W) ---
#ifdef UNICODE
#else
#endif
 
//=== Fonctions: toujours privées ===
 
/* Fonction pour activer ou désactiver un privilège
   ------------------------------------------------ */
BOOL EnablePrivilege(
 LPCTSTR const sczPrivName,	//[in] nom du privilège demandé
 BOOL const bEnable	//[in] Vrai pour activer le privilège
 )
{
	HANDLE hToken; 
	TOKEN_PRIVILEGES tkp = {0}; 
	BOOL bOK = FALSE;
 
	// Récupérer le jeton d'accès du processus. 
	bOK = OpenProcessToken(GetCurrentProcess(), 
	 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);
	if( ! bOK ) 
		return FALSE; 
 
	// Obtenir le Locally Unique ID du privilège demandé. 
	LookupPrivilegeValue(NULL, sczPrivName, 
		&tkp.Privileges[0].Luid); 
 
	tkp.PrivilegeCount = 1;  // Un privilège à régler
	tkp.Privileges[0].Attributes = (bEnable ? SE_PRIVILEGE_ENABLED : 0);
 
	// Régler le privilège pour ce processus. 
	AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, NULL, NULL); 
	CloseHandle(hToken);
 
	return (GetLastError() == ERROR_SUCCESS);
}
 
 
/* Fonction pour vérifier si un privilège est activé
   ------------------------------------------------- */
BOOL IsPrivilegeEnabled(
 LPCTSTR const sczPrivName
 )
{
	PRIVILEGE_SET ps = {0};
	BOOL bReturnVal = FALSE;
	HANDLE hToken = NULL;
 
	// Récupérer le jeton d'accès du processus. 
	bReturnVal = OpenProcessToken(GetCurrentProcess(), 
	 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);
	if( ! bReturnVal ) 
		return FALSE; 
 
	// Obtenir le Locally Unique ID du privilège demandé. 
	LookupPrivilegeValue(NULL, sczPrivName, &ps.Privilege[0].Luid);
 
	ps.Control = 0;
	ps.PrivilegeCount = 1;
 
	PrivilegeCheck(hToken, &ps, &bReturnVal);
 
	CloseHandle(hToken);
	return bReturnVal;
}