[c/devcpp]lireexec (lecture dans la base de registre de l'historique windows codé en rod 13 avec gestion de la date)

Télécharger le projet
Commenter

Description

Il faut être administrateur sur la machine,

Pour chacun des comptes de la machine il récupère l'historique (si il n'est pas désactivé) codé en ROD13 (césar),
Il récupère la date de dernière utilisation, le numéro de session, et le nombre de fois d'exécution pour les applications, liens, etc ...

Codé en C sous DEVCPP.

L'exécutable est dans le zip, renommer "LireExec_V_.ex" en "LireExec_V_.exe".

Bon voilà ma première source j'espère qu'elle vous plaira,
tous les commentaires sont les bienvenus :)

Source / Exemple : 


//------------------------------------------------------------------------------
// 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;
}
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_omnia)