[C/DEVCPP]LIREEXEC (LECTURE DANS LA BASE DE REGISTRE DE L'HISTORIQUE WINDOWS CODÉ EN ROD 13 AVEC GESTION DE LA DATE)

//------------------------------------------------------------------------------
// Projet LireExec      : Récupération de l'historique d'exécution d'application et liens de windows,
//                        décodage de la dernière utilisation, nombre d'utilisation et numéro de session de la dernière utilisation.
// Auteur               : Hanteville Nicolas
// Fichier              : main.c
// Version              : 1.1
// Date de modification : 26/07/2008
// Site                 : http:\\omni.a.free.fr
//------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------
//objectifs: (gestion multi utilisateurs)
//          - récupération d'un chemin,
//          - ajout entête,
//          - test si le log est activé pour le compte en test,
//          - test si codage road13 activé,       
//          - récupération pour chaque clé de la date de dernière modification,
//          - numéro de session,
//          - nombre de fois exécuté,
//          - clé décodé.
//---------------------------------------------------------------------------------------------------------------

//------------------constantes-----------------
#define TAILLE_TMP                   256
#define TAILLE_REG_DEFAULT           512
#define TAILLE_REG_EXT               1024
#define TAILLE_REG_DBEXT             2048
//----------------fin-constantes---------------

//------------------libs-----------------
#include <stdio.h>
#include <windows.h>
//----------------fin-libs---------------
//---------------------------------------------------------------------------------------------------------------
// on donne une valeur hexa de 8 caracteres et on obtient le resultat
// gestion des chiffres + caractères minuscules et majuscules
//---------------------------------------------------------------------------------------------------------------
unsigned long HexaToDec(char *hexa,unsigned int taille)
{
 unsigned long k=0;//resultat   
 unsigned long j=1,i; // j =coef multiplicateur et i variable de boucle       
    //traitement de la valeur hexa   
    
    for (i=(taille-1);i>0;i--)//calcul de la valeur hexa en decimal
    {
        switch(hexa[i])
        {
         case '1':k=k+j;break;
         case '2':k=k+(2*j);break;
         case '3':k=k+(3*j);break;
         case '4':k=k+(4*j);break;
         case '5':k=k+(5*j);break;
         case '6':k=k+(6*j);break;
         case '7':k=k+(7*j);break;
         case '8':k=k+(8*j);break;
         case '9':k=k+(9*j);break;
         case 'a':k=k+(10*j);break;
         case 'A':k=k+(10*j);break;
         case 'b':k=k+(11*j);break;
         case 'B':k=k+(11*j);break;
         case 'c':k=k+(12*j);break;
         case 'C':k=k+(12*j);break;
         case 'd':k=k+(13*j);break;
         case 'D':k=k+(13*j);break;
         case 'e':k=k+(14*j);break;
         case 'E':k=k+(14*j);break;
         case 'f':k=k+(15*j);break;
         case 'F':k=k+(15*j);break;
        }; 
        j=j*16;  
    };
  return k;       
};
//---------------------------------------------------------------------------------------------------------------
// decoder une chaine de caractères de ROD13 en lisible
//---------------------------------------------------------------------------------------------------------------
void RODTOASCII(char *donnee,char *resultat,int taille) 
{ 
 int i;
 
 strcpy(resultat,"");

 for (i=0;i<taille;i++)
 {
    switch(donnee[i])
    {
     case 'a': strcat(resultat,"n"); break;
     case 'b': strcat(resultat,"o"); break;
     case 'c': strcat(resultat,"p"); break;
     case 'd': strcat(resultat,"q"); break;
     case 'e': strcat(resultat,"r"); break;
     case 'f': strcat(resultat,"s"); break;
     case 'g': strcat(resultat,"t"); break;
     case 'h': strcat(resultat,"u"); break;
     case 'i': strcat(resultat,"v"); break;
     case 'j': strcat(resultat,"w"); break;
     case 'k': strcat(resultat,"x"); break;
     case 'l': strcat(resultat,"y"); break;
     case 'm': strcat(resultat,"z"); break;
     case 'n': strcat(resultat,"a"); break;
     case 'o': strcat(resultat,"b"); break;
     case 'p': strcat(resultat,"c"); break;
     case 'q': strcat(resultat,"d"); break;
     case 'r': strcat(resultat,"e"); break;
     case 's': strcat(resultat,"f"); break;
     case 't': strcat(resultat,"g"); break;
     case 'u': strcat(resultat,"h"); break;
     case 'v': strcat(resultat,"i"); break;
     case 'w': strcat(resultat,"j"); break;
     case 'x': strcat(resultat,"k"); break;
     case 'y': strcat(resultat,"l"); break;
     case 'z': strcat(resultat,"m"); break;
     case 'A': strcat(resultat,"N"); break;
     case 'B': strcat(resultat,"O"); break;
     case 'C': strcat(resultat,"P"); break;
     case 'D': strcat(resultat,"Q"); break;
     case 'E': strcat(resultat,"R"); break;
     case 'F': strcat(resultat,"S"); break;
     case 'G': strcat(resultat,"T"); break;
     case 'H': strcat(resultat,"U"); break;
     case 'I': strcat(resultat,"V"); break;
     case 'J': strcat(resultat,"W"); break;
     case 'K': strcat(resultat,"X"); break;
     case 'L': strcat(resultat,"Y"); break;
     case 'M': strcat(resultat,"Z"); break;
     case 'N': strcat(resultat,"A"); break;
     case 'O': strcat(resultat,"B"); break;
     case 'P': strcat(resultat,"C"); break;
     case 'Q': strcat(resultat,"D"); break;
     case 'R': strcat(resultat,"E"); break;
     case 'S': strcat(resultat,"F"); break;
     case 'T': strcat(resultat,"G"); break;
     case 'U': strcat(resultat,"H"); break;
     case 'V': strcat(resultat,"I"); break;
     case 'W': strcat(resultat,"J"); break;
     case 'X': strcat(resultat,"K"); break;
     case 'Y': strcat(resultat,"L"); break;
     case 'Z': strcat(resultat,"M"); break;
     case '\\': strcat(resultat,"\\"); break;
     case ' ': strcat(resultat," "); break;
     case ':': strcat(resultat,":"); break;
     case '+': strcat(resultat,"+"); break;
     case '-': strcat(resultat,"-"); break;
     case '_': strcat(resultat,"_"); break;
     case '.': strcat(resultat,"."); break;
     case ']': strcat(resultat,"]"); break;
     case '[': strcat(resultat,"["); break;
     case '(': strcat(resultat,"("); break;
     case ')': strcat(resultat,")"); break;
     case '#': strcat(resultat,"#"); break;
     case '0': strcat(resultat,"0"); break;
     case '1': strcat(resultat,"1"); break;     
     case '2': strcat(resultat,"2"); break;     
     case '3': strcat(resultat,"3"); break;
     case '4': strcat(resultat,"4"); break;
     case '5': strcat(resultat,"5"); break;     
     case '6': strcat(resultat,"6"); break;     
     case '7': strcat(resultat,"7"); break;
     case '8': strcat(resultat,"8"); break;     
     case '9': strcat(resultat,"9"); break; 
     case '\'':  strcat(resultat,"'"); break;  
     case '\0': strcat(resultat,"\0");
     return;                 
     };  
  };      
}
//---------------------------------------------------------------------------------------------------------------
// lecture de données binaires dans la base de registre, transformés suivant le besoin et écrite dans le fichier
// & mise en forme dans le fichier
// [DATE](ID SESSION - NB USE) CHAINE
//---------------------------------------------------------------------------------------------------------------
void LireValBin(HKEY ENTETE,char *chemin,char *nom,FILE *fic,char *donnes) 
{ 
    //variables 
    DWORD tailleCle=TAILLE_REG_DEFAULT;
    HKEY CleTmp=NULL; 
    char Valeur[TAILLE_REG_DEFAULT];//16=taille max des données
    char Count[8];//récupération en hexa
    char Id[8];///récupération en hexa
    char Date1[8];//récupération en hexa
    char Date2[8];//récupération en hexa
    char Ttmp[TAILLE_REG_DBEXT]; 

    //convertion de la date
    FILETIME FileTime, LocalFileTime;
    SYSTEMTIME SysTime;
    
   //lecture de la valeur binaire
   // on ouvre la cle
   if (RegOpenKey(ENTETE,chemin, &CleTmp)==ERROR_SUCCESS)
   {
     //On recupere la taille de la cle qui va être lue
     if (RegQueryValueEx(CleTmp, nom, NULL, NULL, NULL, &tailleCle)==ERROR_SUCCESS)
     {
       strcpy(Valeur,"");
       //On lit la valeur 
       if (RegQueryValueEx(CleTmp, nom, NULL, NULL, Valeur, &tailleCle)==ERROR_SUCCESS)
       {  
         //décortication
         
         if (tailleCle==8)//si =8 alors il n'y a que le nombre d'utilisation
         {
           //lecture du nombre d'exécution
           //transformation ASCII to HEXA et HEXA to DEC
           sprintf(Count,"%02x%02x%02x%02x",Valeur[7]&255,Valeur[6]&255,Valeur[5]&255,Valeur[4]&255);
          
           snprintf(Ttmp,TAILLE_REG_DBEXT,"[jj.mm.aaaa  hhh mmm sss](ID SESSION: 0000 - NB USE: %04d) %s\n",HexaToDec(Count,8),donnes);
           fputs(Ttmp,fic);

         }else if (tailleCle==16) //si = 16 = 4 nb utilisation, 4 id de session, 8 date utilisation
         {
           //lecture du nombre d'exécution
           //transformation ASCII to HEXA et HEXA to DEC
           sprintf(Count,"%02x%02x%02x%02x",Valeur[7]&255,Valeur[6]&255,Valeur[5]&255,Valeur[4]&255);
           
           //lecture numéro de session
           sprintf(Id,"%02x%02x%02x%02x",Valeur[3]&255,Valeur[2]&255,Valeur[1]&255,Valeur[0]&255);
          
           //lecture 1er partie de la date
           sprintf(Date1,"%02x%02x%02x%02x",Valeur[11]&255,Valeur[10]&255,Valeur[9]&255,Valeur[8]&255);
                    
           //lecture 2ème partie de la date
           sprintf(Date2,"%02x%02x%02x%02x",Valeur[15]&255,Valeur[14]&255,Valeur[13]&255,Valeur[12]&255);
                     
           FileTime.dwLowDateTime = (DWORD)HexaToDec(Date1,8);
           FileTime.dwHighDateTime = (DWORD)HexaToDec(Date2,8);
           
           //dans le cas ou ==0 non utilisable et pas de modification sur  le nombre d'utilisation
           if (( FileTime.dwLowDateTime==0)&&(FileTime.dwHighDateTime==0))
           {
               sprintf(Ttmp,"[jj.mm.aaaa  hhh mmm sss](ID SESSION: %04d - NB USE: %04d) %s",HexaToDec(Id,8),HexaToDec(Count,8),donnes); 
           }
           else
           { 
               FileTimeToLocalFileTime(&FileTime, &LocalFileTime);
               FileTimeToSystemTime(&LocalFileTime, &SysTime);
               
               //comme le nombre d'utilisation commence à 6, on effectue une diminution de 5^^
               sprintf(Ttmp,"[%02d.%02d.%02d  %02dh %02dm %02ds](ID SESSION: %04d - NB USE: %04d) %s",SysTime.wDay,SysTime.wMonth,SysTime.wYear,SysTime.wHour,SysTime.wMinute,SysTime.wSecond,HexaToDec(Id,8),HexaToDec(Count,8)-5,donnes); 
           }
           fputs(Ttmp,fic);
           fputs("\n",fic);       
         };

         //fermeture de la clé
         RegCloseKey(CleTmp);
         return;
       }
     }
     //fermeture de la clé
     RegCloseKey(CleTmp);
   }//si on arrive pas a récupérer les données
     //formatage et écriture dans le fichier
     snprintf(Ttmp,TAILLE_REG_DBEXT,"[jj.mm.aaaa  hhh mmm sss](ID SESSION: 0000 - NB USE: 0000) %s",donnes);
     fputs(Ttmp,fic);
     fputs("\n",fic);
}
//---------------------------------------------------------------------------------------------------------------
// lecture de valeur tres importantes comme des descriptions limités à 1 caractère
//---------------------------------------------------------------------------------------------------------------
int LireGValeur(HKEY ENTETE,char *chemin,char *nom,char *Valeur) 
{ 
    //variables 
    DWORD tailleCle;
    HKEY CleTmp=NULL; 
    
    // on ouvre la cle
    if (RegOpenKey(ENTETE,chemin, &CleTmp)==ERROR_SUCCESS)
    {
      //On recupere la taille de la cle qui va être lue
      if (RegQueryValueEx(CleTmp, nom, NULL, NULL, NULL, &tailleCle)==ERROR_SUCCESS)
      {
        if (tailleCle<2)//gestion de la taille de la clé si on dépace 1 on quitte pour éviter buffer overflow
        {
          if (RegQueryValueEx(CleTmp, nom, NULL, NULL, Valeur, &tailleCle)==ERROR_SUCCESS)
          {
            RegCloseKey(CleTmp);    
            return TRUE;                        
          }
        }
      }
      //On ferme la cle   
      RegCloseKey(CleTmp);
    }
     return FALSE; 
} 

//---------------------------------------------------------------------------------------------------------------
// fonction principale (MAIN)
//---------------------------------------------------------------------------------------------------------------
int main(void)
{
  //variables
  FILE *fic;                                               //fichier de résultat
  HKEY CleTmp=0,CleTmp2=0,CleTmp3=0;                       //entête clé
  DWORD nbValue=0,nbSubKey2=0,nbSubKey3=0;                 //nombre de sous clé
  int j,k,l;                                                  //variable de boucle
  int TailleNomSubKey2,TailleNomSubKey3;                    //taille des clés de récupération de données
  DWORD TailleNomValue=TAILLE_REG_EXT;
  DWORD TailleMAXValue=TAILLE_REG_EXT;
  
  //variables de transitions et lecture de données
  char chemintmp[TAILLE_REG_DBEXT];
  char NomSubKey2[TAILLE_REG_EXT];
  char NomSubKey3[TAILLE_REG_EXT];
  char chemin[TAILLE_REG_DBEXT]; // le chemin complet c lui
  char NomValeur[TAILLE_REG_EXT]; // Nom de la Valeur recupere
  char Valeur[TAILLE_REG_EXT];
  char resultat[TAILLE_REG_EXT];
  char tmp;
  int ROD13ENABLE=1;
  
  // test
  char ltmp[1024];
    
    
    
  //présentation:
  printf("LireExec V 1.1, 26/07/2008 par Nicolas Hanteville de http:\\\\omni.a.free.fr\n"
         "recuperation de l'historique windows code en ROD13.\n\n"
         "Necessite les droits administrateurs!!!\n");  
 
  //ouverture du fichier de résultat
  if ((fic= fopen("resultat.txt","w+"))==NULL)
    printf("ERREUR - Creation du fichier resultat impossible!!!\n");
  else
  {
    //création de l'entête aide
    fputs("----------------------------------------------------\n"
          "LireExec V 1.1, 26/07/2008 par Nicolas Hanteville\n"
          "de http:\\\\omni.a.free.fr\n"
          "récupération de l'historique windows codé en ROD13.\n"
          "----------------------------------------------------\n\n"
          "Format:\n"
          "-----------\nClé source\n-----------\n"
          "[Date de dernier accès](Numéro de session - nombre d'utilisation) clé : chaine\n"
          "\nType de clé:"
          "\n---------------------------------------------------"
          "\nUEME_RUNPIDL     : Fichier local, titre de page web"
          "\nUEME_RUNPATH     : Exécutables"
          "\nUEME_CTLSESSION  : 1ère clé créé"
          "\nUEME_CTLCUACount : Compte courant"
          "\nUEME_UISCUT      : Couper presse-papier ???"
          "\nUEME_UIQCUT      : Couper presse-papier ???"
          "\nUEME_UIHOTKEY    : Touche raccourcis"
          "\nUEME_RUNWMCMD    : Exécuté sous Commandes DOS "
          "\nUEME_RUNCPL      : Applet du panneau de configuration"
          "\nUEME_UITOOLBAR   : Raccourcis de bar accès rapide\n\n\n"
          ,fic);

    // récupération du chemin de chacun des utilisateurs:
    if (RegOpenKey((HKEY)HKEY_USERS,"",&CleTmp2)==ERROR_SUCCESS)
    {
        //nombre de sous clés
        if (RegQueryInfoKey (CleTmp2,NULL,NULL,NULL,&nbSubKey2,NULL,NULL,NULL,NULL,NULL,NULL,NULL)==ERROR_SUCCESS)
        {
          //on traite chacune des clé une par une
          for (k=0;k<nbSubKey2;k++)
          {
             TailleNomSubKey2=TAILLE_REG_DBEXT; // à chaque boucle on réinitialise
             //lecture de la clé "k"
             if (RegEnumKeyEx (CleTmp2,k,NomSubKey2,(LPDWORD)&TailleNomSubKey2,NULL,NULL,NULL,NULL)==ERROR_SUCCESS)
             {
               //création du chemin de récupération
               snprintf(chemintmp,TAILLE_REG_DBEXT,"%s\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\",NomSubKey2);          
          
               // maintenant on récuper le ID pour construire la cle a ouvrire final
               if (RegOpenKey((HKEY)HKEY_USERS,chemintmp,&CleTmp3)==ERROR_SUCCESS)
               {
                 //récupération du nombre de sous clés
                 if ((RegQueryInfoKey (CleTmp3,NULL,NULL,NULL,&nbSubKey3,NULL,NULL,NULL,NULL,NULL,NULL,NULL)==ERROR_SUCCESS))
                 if (nbSubKey3>0)//si il y a bien des sous clés alors on récupère leurs noms:
                 {
                      
                      //test si les logs sont activés ou non pour chacun des utilisateurs
                      fputs("************************************************************************************************************************************\n",fic);

                      ROD13ENABLE=1;                      
                      //test si les logs sont codés en ROD13
                      //\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\Settings as: NoEncrypt = 1 (DWORD)
                      //test dans chemintmp si NoEncrypt==1
                      if (LireGValeur(HKEY_USERS,chemintmp,"NoEncrypt",&tmp))
                      {
                        if (tmp=='1')
                        {
                          fputs("Codage en ROD13 désactivé (\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\NoEncrypt = 1 (DWORD))\n",fic);  
                          ROD13ENABLE=0;
                        }
                        else
                          fputs("Codage en ROD13 Activé (\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\NoEncrypt = 0 (DWORD))\n",fic);                        
                      }else
                          fputs("Codage en ROD13 Activé (\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\NoEncrypt = 0 (DWORD))\n",fic);                        
                      
                      //désactiver le chiffrement
                      //\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\NoLog=1 (dword)
                      //test dans chemintmp si NoLog==1  
                      if (LireGValeur(HKEY_USERS,chemintmp,"NoLog",&tmp))
                      {
                        if (tmp=='1')
                          fputs("Journal de log désactivé (\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\NoLog = 1 (DWORD))\n",fic);  
                        else
                          fputs("Journal de log Activé (\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\NoLog = 0 (DWORD))\n",fic);                        
                      }else
                          fputs("Journal de log Activé (\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\UserAssist\\NoLog = 0 (DWORD))\n",fic);                        

                      fputs("************************************************************************************************************************************\n",fic);

                    
                    //traitement pour chacune des sous clés
                    for (l=0;l<nbSubKey3;l++)
                    {
                      //init pour récupération
                      TailleNomSubKey3=TAILLE_REG_DBEXT;
                      RegEnumKeyEx (CleTmp3,l,NomSubKey3,(LPDWORD)&TailleNomSubKey3,NULL,NULL,NULL,NULL);
                      sprintf(chemin,"%s%s\\Count\\",chemintmp,NomSubKey3);
                    
                      //écriture dans le fichier de l'entête
                      fputs("------------------------------------------------------------------------------------------------------------------------------------\nHKEY_USERS\\",fic);
                      fputs(chemin,fic);  
                      fputs("\n------------------------------------------------------------------------------------------------------------------------------------\n",fic);
                      
                      //application et liens exécutés
                      if (RegOpenKey((HKEY)HKEY_USERS,chemin,&CleTmp)==ERROR_SUCCESS)
                      {
                          // on recupere le nombre de subkey ( de cle en dessous de la cle actuelle)
                          if (RegQueryInfoKey (CleTmp,NULL,NULL,NULL,NULL,NULL,NULL,&nbValue,&TailleNomValue,&TailleMAXValue,NULL,NULL)==ERROR_SUCCESS)
                          {
                            for (j=0;j<nbValue;j++)
                            {
                              TailleNomValue=1024;// on reinitialise la taille a chaque fois sinon il ne lit pas la valeur suivant
                              TailleMAXValue=1024; 
                            
                              //énumération de la valeur (j)
                              if (RegEnumValue (CleTmp,j,NomValeur,&TailleNomValue,NULL,NULL,Valeur,&TailleMAXValue)==ERROR_SUCCESS)
                              {
                                               
                                  if (ROD13ENABLE)//si le chiffrement en ROD13 est activé
                                  {
                                     //transformation
                                     RODTOASCII(NomValeur,resultat,sizeof(NomValeur)); 

                                    strcpy(ltmp,"");
                                     LireValBin(HKEY_USERS,chemin,NomValeur,fic,resultat); 
                                  }
                                  else // si le chiffrement n'est pas activé
                                  {
                                     LireValBin(HKEY_USERS,chemin,NomValeur,fic,NomValeur); 
                                  }
                              }
                            }
                          }
                        RegCloseKey(CleTmp);
                      }
                    }   
                    printf("\nFichier resultat.txt cree!!!\n\n");               
                 }
                 RegCloseKey(CleTmp3);
               }
             }
          }                     
        }else
          printf("ERREUR - Lecture du registre impossible!!!\n");

      //fermer la clé
      RegCloseKey(CleTmp2);
    }else
      printf("ERREUR - Lecture du registre impossible!!!\n");
    fclose(fic);
  }
  system("PAUSE");	
  return 0;
}