D:\Raymond\Developpement\Test\Audit\Release>Audit.exe 

Catégorie = Système 

        Modification de l'état de la sécurité (Success) 

        Extension système de sécurité 

        Intégrité du système (Success, Failure) 

        Pilote IPSEC 

        Autres événements système (Success, Failure) 

Catégorie = Ouverture/Fermeture de session 

        Ouvrir la session (Success) 

        Fermer la session (Success) 

        Verrouillage du compte (Success) 

        Mode principal IPsec 

        Mode rapide IPsec 

        Mode étendu IPsec 

        Ouverture de session spéciale (Success) 

        Autres événements d'ouverture/fermeture de session 

        Serveur NPS (Success, Failure) 

Catégorie = Accès aux objets 

        Système de fichiers 

        Registre 

        Objet de noyau 

        SAM 

        Services de certification 

        Généré par application 

        Manipulation de handle 

        Partage de fichiers 

        Rejet de paquet par la plateforme de filtrage 

        Connexion de la plateforme de filtrage 

        Autres événements d'accès à l'objet 

        Partage de fichiers détaillé 

Catégorie = Utilisation de privilège 

        Utilisation de privilèges sensibles 

        Utilisation de privilèges non sensibles 

        Autres événements d'utilisation de privilèges 

Catégorie = Suivi détaillé 

        Création du processus 

        Fin du processus 

        Activité DPAPI 

        Événements RPC 

Catégorie = Changement de stratégie 

        Modification de la stratégie d'audit (Success) 

        Modification de la stratégie d'authentification (Success) 

        Modification de la stratégie d'autorisation 

        Modification de la stratégie de niveau règle MPSSVC 

        Modification de la stratégie de plateforme de filtrage 

        Autres événements de modification de stratégie 

Catégorie = Gestion des comptes 

        Gestion des comptes d'utilisateur (Success, Failure) 

        Gestion des comptes d'ordinateur (Success, Failure) 

        Gestion des groupes de sécurité (Success, Failure) 

        Gestion des groupes de distribution (Success, Failure) 

        Gestion des groupes d'applications (Success, Failure) 

        Autres événements de gestion des comptes (Success, Failure) 

Catégorie = Accès DS 

        Accès au service d'annuaire 

        Modification du service d'annuaire 

        Réplication du service d'annuaire 

        Réplication du service d'annuaire détaillé 

Catégorie = Connexion de compte 

        Validation des informations d'identification (Success, Failure) 

        Opérations de ticket du service Kerberos (Success, Failure) 

        Autres événements d'ouverture de session (Success, Failure) 

        Service d'authentification Kerberos (Success, Failure) 

D:\Raymond\Developpement\Test\Audit\Release> 

#ifndef _WIN32_WINNT 

#define _WIN32_WINNT 0x0501 

#endif 

#include <tchar.h> 

#include <locale.h> 

#include <stdio.h> 

#include <windows.h> 

#include <Ntsecapi.h> 

static void DisplayError(LPCTSTR message); 

static void EnumerateCategories(void); 

static void EnumerateSubCategories(const GUID *Guid); 

static void PrintStatus(const GUID *SubCategoryGuid); 

int _tmain() 

{ 

   _tsetlocale(LC_ALL, _T("")); 

   EnumerateCategories(); 

   return 0; 

} 

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) 

         _tprintf(_T("%s : not enough memory\n"), message); 

      else 

         _tprintf(_T("FormatMessage() failed : %lu\n"), GetLastError()); 

   } 

   else 

   { 

      _tprintf(_T("%s : %s"), message, buffer); 

      LocalFree(buffer); 

      buffer = NULL; 

   } 

} 

static void EnumerateCategories(void) 

{ 

GUID *Tbl; 

DWORD Size; 

BOOL ret; 

DWORD boucle; 

   ret = AuditEnumerateCategories(&Tbl, &Size); 

   if(ret == FALSE) 

   { 

      DisplayError(_T("Erreur AuditEnumerateCategories()")); 

      return; 

   } 

   for(boucle = 0; boucle != Size; boucle++) 

   { 

      LPTSTR Str; 

      /* display category name */ 

      ret = AuditLookupCategoryName(&Tbl[boucle], &Str); 

      if(ret == FALSE) 

      { 

         DisplayError(_T("Erreur AuditLookupCategoryName()")); 

         return; 

      } 

      _tprintf(_T("Catégorie = %s\n"), Str); 

      AuditFree(Str); 

      /* display sub categories */ 

      EnumerateSubCategories(&Tbl[boucle]); 

   } 

   AuditFree(Tbl); 

} 

static void EnumerateSubCategories(const GUID *Guid) 

{ 

GUID *SubTbl; 

DWORD SubSize; 

DWORD boucle2; 

BOOL ret; 

LPTSTR Str; 

   /* get sub categories */ 

   ret = AuditEnumerateSubCategories(Guid, FALSE, &SubTbl, &SubSize); 

   if(ret == FALSE) 

   { 

      DisplayError(_T("Erreur AuditEnumerateSubCategories()")); 

      return; 

   } 

   for(boucle2 = 0; boucle2 != SubSize; boucle2++) 

   { 

      ret = AuditLookupSubCategoryName(&SubTbl[boucle2], &Str); 

      if(ret == FALSE) 

      { 

         DisplayError(_T("Erreur AuditLookupSubCategoryName()")); 

         return; 

      } 

      _tprintf(L"\t%s", Str); 

      AuditFree(Str); 

      PrintStatus(&SubTbl[boucle2]); 

   } 

   AuditFree(SubTbl); 

} 

static void PrintStatus(const GUID *SubCategoryGuid) 

{ 

BOOL ret; 

AUDIT_POLICY_INFORMATION *p_information; 

BOOL at_least_one = FALSE; 

   ret = AuditQuerySystemPolicy(SubCategoryGuid, 1, &p_information); 

   if(ret == FALSE) 

   { 

      DisplayError(_T("Erreur AuditQuerySystemPolicy()")); 

      return; 

   } 

   if( (p_information->AuditingInformation & POLICY_AUDIT_EVENT_SUCCESS) == POLICY_AUDIT_EVENT_SUCCESS) 

   { 

      if(at_least_one == FALSE) 

      { 

         at_least_one = TRUE; 

         _tprintf(_T(" (")); 

      } 

      else 

      { 

         _tprintf(_T(", ")); 

      } 

      _tprintf(_T("Success")); 

   } 

   if( (p_information->AuditingInformation & POLICY_AUDIT_EVENT_FAILURE) == POLICY_AUDIT_EVENT_FAILURE) 

   { 

      if(at_least_one == FALSE) 

      { 

         at_least_one = TRUE; 

         _tprintf(_T(" (")); 

      } 

      else 

      { 

         _tprintf(_T(", ")); 

      } 

      _tprintf(_T("Failure")); 

   } 

   if( (p_information->AuditingInformation & POLICY_AUDIT_EVENT_NONE) == POLICY_AUDIT_EVENT_NONE) 

   { 

      if(at_least_one == FALSE) 

      { 

         at_least_one = TRUE; 

         _tprintf(_T(" (")); 

      } 

      else 

      { 

         _tprintf(_T(", ")); 

      } 

      _tprintf(_T("None")); 

   } 

   if(at_least_one == TRUE) 

   { 

      _tprintf(_T(")")); 

   } 

   _tprintf(_T("\n")); 

   AuditFree(p_information); 

}