CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 10 11:17:07

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Système

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

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

Information sur la source

Note :
Aucune note

Catégorie :Système Classé sous :rod13, historique, système Niveau :Débutant Date de création :11/12/2006 Date de mise à jour :25/06/2009 18:07:27 Vu / téléchargé :2 919 / 245

Auteur : omnia

Ecrire un message privé

Ce membre participe au partage de revenus publicitaires

Commentaire sur cette source (4)

Ajouter un commentaire et/ou une note

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

//------------------------------------------------------------------------------
// 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;
}

//------------------------------------------------------------------------------
// 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;
}

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

LireExec_V_.dev836 octets
LireExec_V_.ex28 429 octets
LireExec_V_.layout173 octets
main.c 21 742 octets
Makefile.win1 318 octets

Télécharger le zip

Historique

12 décembre 2006 08:53:00 :: Correction en suivant les instruction de BruNews, Merci a lui :)
25 juin 2009 18:07:27 :: - correction du 'y'

Sources du même auteur

[WIN32][CB]CRÉATION DIRECTE DE PDF

[C][RTF] EXEMPLE DE TABLEAU EN RTF (POUR RICHEDIT)

[WMI][C++][DEV-C++] LECTURES D'INFORMATIONS AVEC WMI SOUS DE...

[WIN32][C][DEV-C++] AUTO LIST EN HTML

[WIN32][C][DEV-C++] GRAPH TRANSPARENT DEBIT RESEAU

Toutes les sources de omnia

Sources de la même categorie

UNE LISTE HÉTÉROGÈNE DOUBLEMENT CHAINÉE par pgl10

POUR AFFICHER LES CARACTÈRES ACCENTUÉS SOUS WINDOWS EN MODE ... par pgl10

PETITE CLASSE DE GESTION DES PROCESSUS SOUS WINDOWS par wisar

KEYLOGGER AVEC NOM DU PROCESSUS ET DE LA FENETRE QUI A LE FO... par wisar

LINUX USB BOOT LEGER par patatalo

Toutes les sources de la catégorie Système

Sources en rapport avec celle ci

AUTOCHUTDOWN EN C++ BUILDER 6 par zaagane

PLANSCAN : SCANNEUR DE FICHIER ET CONFIGURATION PC par bipcpp

PCHECK - INFORMATION SYSTÈME - C++ BUILDER 6 par Bativir

SYSTÈME D'EXPLOITATION COS2000 V2.1FR par MrNOP

SYSTÈME D'EXPLOITATION COS2000 V2.0A par MrNOP

Commentaires et avis

Commentaire de BruNews le 11/12/2006 22:31:57 administrateur CS

strcpy(resultat,"");
=> resultat[0] = 0;

char *c = resultat;
avant la boucle et ainsi:
case 'a': strcat(resultat,"n"); break;
=> case 'a': *c++ = 'n'; break;
et ainsi de suite.

RegOpenKeyEx
employer les versions 'Ex' qui permettent de spécifier les options minimales d'ouverture etc..

Commentaire de omnia le 12/12/2006 08:24:01

Merci je vais faire les modifes et réup :)

Commentaire de pb07 le 25/06/2009 17:01:25

Apparemment, une erreur dans le source

case 'y': *c++ = 'n'; break;

à remplacer par :

case 'y': *c++ = 'l'; break;

Merci pour le code

Commentaire de omnia le 25/06/2009 18:05:00

Bien vu :p j'avais oublié de mettre la source à jour

corrigé

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

Modification du menu Système [ par Xaviou ] Salut.Je voudrais ajouter une command "About ..." au menu système de mon prog.J'ai donc écris le code suivant:HMENU hSysMenu;MENUITEMINFO minfo;minfo. Système d'exploitation [ par guiroux22 ] Il y a t-il de connaître le système d'exploitation de l'ordinateur ? Utilisation de DLL dans un système 16 Bits DOS 6.22 [ par yass007 ] Voila,je voudrai savoir tt dabord sil ya des tutoriaux sur comment creer des Dlls sous Turbo C++ 3.0 et compatibles avec un système 16 Bits , en l'occ Probleme utilisation de fread [ par Trinita16 ] Bonjour, Voila le source d'un programme qui doit lire un fichier binaire. Mais je ne comprends pas l'executable systematiquement...Je pense qu'il y a sons système [ par skysee ] Bonjour,je suis entrain de faire une application DOS (fenêtre de commande) en C. Je voudrais jouer des sons systèmes comme il est possible de faire en FPS, vitesse selon le système(ordi) [ par fabienGL ] Bonjour, j'ai une petite question qui se vient à moi, j'ai un ordi plutôt bien mais lorsque je fais une rotation par exemple d'un cube, sur mon ordi i A l'aide... [ par wanny ] Bonjour.Je dois mettre en place un nouveau système de gestion de licence sur un logiciel commercial.Je voudrais savoir comment mettre en place un syst Effacer l'historique d'IE [ par vecchio56 ] BonjourJ'essaie je faire une fonction pour effacer l'historique de ie, mais pas moyen d'y arriver. Sur le net je trouve souvent cette solution:#includ Hook sur création de fenêtre du système [ par r144 ] Bonjour, voila j'ai ecrit un petit prog avec un dll en prenant appui sur le source de BruNews(que je remercie) qui capture la création d'une fenêtre d Lire un fichier système ? [ par goondy ] fopen m'envoie bouler pour ouvrir un fichier système... comment passer cette protection svp?

Nos sponsors

Derniers Blogs

TECHDAYS PARIS 2012 : SESSION PLEINIèRE JOUR 3 par ROMELARD Fabrice

MISHRA READER : UN LECTEUR RSS TRèS ZUNE STYLE EN OPEN SOURCE ! par Vko

[FRAMEWORK 4] LES TASKS ET LE THREAD UI par fathi

WORKFLOW FOUNDATION 3 A UN PIED DANS LA TOMBE par JeremyJeanson

TECHDAYS PARIS 2012 : NOUVELLES TENDANCES DU POSTE DE TRAVAIL - BRING YOUR OWN PC par ROMELARD Fabrice

Forum

RE : MODIFIER UN FICHIER DLL par francko225

RE : CXIMAGE par rt15

RE : MODIFIER UN FICHIER DLL par Renfield

MODIFIER UN FICHIER DLL par francko225

RE : LANGUAGE C ][PRINCIPE RECURSIF par marie0marie

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Creation d-un site internet similaire a Meetic CDC Disponible
Budget : 8 000€
Integration E commerce d-une application graphique interactive
Budget : 4 000€
URGENT-Developpement d-un annuaire
Budget : 13 000€

Logiciels

Academy System (17.2.1.0)
ACADEMY SYSTEM (17.2.1.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning
COLLECTOR PLUS (3.00B)
COLLECTOR PLUS (3.00B)

COLLECTOR PLUS version 3.00B est un logiciel utilisant une base de données alimentée par : - L...

Cliquez pour télécharger COLLECTOR PLUS
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V7.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
LettresFaciles 2011 (8.0.0.1)
LETTRESFACILES 2011 (8.0.0.1)

LettresFaciles est un logiciel facilitant la création et la rédaction de lettres types. Son inte...

Cliquez pour télécharger LettresFaciles 2011