• Cours appronfondie n°3

    // Code source : crack en C++ \\

    //---------------------------------------- Licence ------------------------------------------
    //
    //Auteur : Pifoman
    //Email : pifoman@yahoo.com
    //Adresse site : http://crackinfrance.free.fr
    //Url redirection : www.geocities.com/mitonnes
    //Première source : version 1.0 du 13/10/2004
    //Dernière source : version 1.1 du 06/01/2004
    //Langage : C++
    //Compilateur : dev C++ 4 build 10/09/2000 (gratuit)
    //Adresse téléchargement : http://www.telecharger.com ou http://www.bloodshed.net/devcpp.html
    //Compilation : Windows XP édition familiale
    //Tests : Windows XP édition familiale / Windows 98
    //Type licence : libre. Vous pouvez copier et distribuer cette source
    // si vous laissez les lignes concernant la licence.
    // //------------------------------------------------------------------------------------------- //------------------------------ Instructions de compilation -------------------------------- // // Avant compilation du code // // 1/ Ouvrez STARTCLN.EXE dans Resource Hacker (version 3.4) // Faites action->Enregistrer toutes les ressources pour récupérer l'icône du programme Start clean // // 2/ Définissez un nouveau projet vide dans dev c++ // File->New Project->Empty Project // // 3/ Définissez un répertoire de travail au lancement de DevCpp.exe (dev c++) // Par exemple C:/Documents and Settings/inconnu/Bureau/Start Clean/ // // 4/ Copiez cette page (CTRL A CTRL C) dans Untitled1 (le fichier ouvert qui est vide) // // 5/ Définissez le fichier de resources // Vous devez définir un fichier de ressources dans lequel vous spécifiez l'icône à utiliser et le chemin du fichier info.htm // Ce fichier s'appelle par défaut Rsrc.rc et vous y accéder dans le menu Project->Edit Resource File de dev c++. // Copiez le contenu suivant en adaptant le chemin (supprimez les // devant 500 et texte pas devant BINAIRE1) // // 500 ICON "C:/Documents and Settings/inconnu/Bureau/Start Clean/icon.ico" // TEXTE BINARY "C:/Documents and Settings/inconnu/Bureau/Start Clean/infos_original.htm" // //BINAIRE1 BINARY "C:/Documents and Settings/inconnu/Bureau/Start Clean/ressource/ressource.exe" // // Faites ensuite une compilation de la ressource en cliquant sur le bouton "Build resource" accessible depuis le menu Projetc->Edit resource file // // 6/ Cocher l'option "Do not create a console" dans Project->Project option // // 7/ Compilez et lancez par CTRL F10 // //------------------------------------------------------------------------------------------- //---------------------------- Compression de l'exécutable compilé -------------------------- // // 1/ Après compilation avec dev c++ vous obtenez Project 1.exe // 2/ Téléchargez UPX (j'utilise la version 0.72) sur http://www.exetools.com/compressors.htm // 3/ Mettez upx.exe dans votre répertoire de travail // 4/ Créez un fichier compress.bat dans votre répertoire de travail (enlevez les //) // // @echo off // del Crack.exe // upx -9 -oCrack.exe "Project 1.exe" // echo Crack pour Start Clean v1.2>file_id.diz // pause // // 5/ Double-cliquez sur compress.bat // 6/ Votre crack est maintenant de taille réduite (vous divisez la taille du crack par 4) // 7/ Vous pouvez le zipper et le diffuser sur internet :) // //------------------------------------------------------------------------------------------- //------------------------------------- Rendu graphique -------------------------------------

    <script type="text/javascript">document.write("")</script>

    //-------------------------------------------------------------------------------------------- //--------------------------------- Commentaires sur le code ---------------------------------- // // C'est le code de ce crack que j'utilise pour mes cracks depuis cloneCD 5.0.2.2 fr. // Il n'y a que la disposition graphique des composants qui change sinon tout le reste est identique // Le code de ce crack est efficace en terme de résultat et de rapidité mais fût assez long à programmer.Ses particularités // // ->Il possède une fonction d'installation de fichiers à partir de ressources (fichiers de la version complète du programme que l'on stocke au préalable dans le crack) // Cette fonction d'installation effectue une opération de création/copie de fichiers et porte sur l'intégralité du fichier. // Cette fonction peut se combiner avec la procédure classique de craquage qui ne porte elle que sur quelques octets // // ->Il possède un contrôle d'erreur assez poussé qui rétabli l'ensemble des fichiers originaux dans le répertoire // en cas d'erreur rencontré pendant le processus de craquage. // // ->L'interface du crack comporte plus de commandes que l'ancienne version (un lien vers le téléchargement du programme // et un bouton caché pour lancer le programme inntallé sur le PC ont été ajoutés). // // // Fonctionnement de la procédure de craquage. // // Quand on appuie sur le bouton crack la fonction ecrire_en_boucle() est invoquée et on va // // -> Effectuer une copie temporaire sous forme de fichier .exe.temp et .bak.temp des fichiers .exe et .bak existant dans le répertoire. C'est la fonction sauver_fichiers() // // -> Appeler la fonction booléenne ecrire(int numero_fichier_a_craquer,int numero_boucle) sur chaque fichier à modifier et identifié par son numéro dans le tableau liste_identifiants_fichiers. // x Cette fonction crée d'abord les chemins d'accès (au fichier à craquer ainsi qu'à sa sauvegarde éventuelle) // x Cette fontion examine ensuite si le mode restauration est activé (checkbox3 à true) // Si C'est le cas la fonction écrase le fichier .exe par le fichier correspondant d'extension .bak // x Sinon on passe en mode craquage // On vérifie si le fichier existe => si le fichier n'existe pas => erreur déclenchée et fin de la focntion ecrire() qui renvoie un message et faux // On vérifie la taille du fichier à partir du tableau taille_somme => si pas bonne => erreur déclenchée et fin de la fonction ecrire() qui renvoie un message et faux // On vérifie l'intégrité du fichier à craquer à partir du tableau taille_somme si la case checkbox2 est cochée => si somme pas bonne => erreur déclenchée et fin de la fonction ecrire() qui renvoie un message et faux // On fait la copie de sauvegarde si la case checkbox1 activée => si erreur de copie => erreur déclenchée et fin de la fonction ecrire() qui renvoie un message et faux // On regarde si le fichier à modifier est une ressource à copier ou bien un craquage classique (test sur le 4ième paramètre du tableau d'information du fichier dans liste_fichiers) // On effectue la copie ou le craquage => si erreur => erreur déclenchée et fin de la fonction ecrire() qui renvoie un message et faux // On renvoie true si aucune erreur apparue sinon false à la fonction appelante ecrire_en_boucle() // // -> Si resultat des différentes écritures pendant le craquage a donné true tout le temps (valeur de la variable etat_ecriture) // x On coche la case nommée restaure // x On remplace le texte du bouton "Crack" par "Restaurer" // x On efface tous les fichiers temporaires crées (fichiers d'extension .temp) // x On affiche dans une boîte à message le message de réussite // // -> Si resultat des différentes écritures pendant le craquage a donné au moins un résultat faux (valeur de la variable etat_ecriture) // x On renomme les fichiers d'extension .exe.temp en .exe et les .bak.temp en .bak // x on efface les fichiers d'extension *.bak crées (il n'ont pas de .bak.temp puisque c'est nous qui l'avons crée sur demande) // x On affiche dans une boîte à message le message d'erreur // // //-------------------------------------------------------------------------------------------- //----------------------------------- Mise à jour du code ------------------------------------ // // // 06/01/2005 Version 1.1 : correction d'un bug dans la fonction calculer_taille_sous_matrice // Le processus de craquage sur les octets définis dans le tableau nommé matrice // s'arrêtait prématurément si un octet à patcher recevait la valeur hexadécimale 00. // // //-------------------------------------------------------------------------------------------- //--------------------------------------- Code source ---------------------------------------- //Inclusion des bibliothèques #include <windows.h> // Accès aux API windows #include <stdio.h> // Pour avoir sprintf : la fonction de traitement sur les chaînes // Déclaration des fonctions (autres que winmain) // Ici c'est inutile car winmain est à la fin du fichier // Quand on entre dedans il connaît les fonctions définies avant puisque le fichier est lu de haut en bas // Variables globales char * nom_application = "Start Clean v 1.2"; char * titre_application = "Start Clean v 1.2"; char cle_registre[] = "Start Clean"; char * date_crack = "12/10/2004"; char adresse_site_editeur[] = "http://www.adresse_editeur_fictive.com"; char adresse_site_telechargement[] = "http://membres.lycos.fr/pifoman/cours_cracking/cours_telechargements.htm"; char adresse_site_cracker[] = "http://www.geocities.com/mitonnes/"; char adresse_mail[] = "pifoman@yahoo.com"; char titre_mail[] = "Remarques sur votre crack "; char corps_mail[] = "Bonjour"; char * fichier_infos = "infos.htm"; char * titre_boite_dialogue = "Sélectionnez le fichier"; char message_reussite[] = "Le programme est maintenant cracké.\nVous pouvez saisir n'importe quel code d'enregistrement."; // Dimensions long largeur_fenetre = 350; long hauteur_fenetre = 245; long ordonnee_checkbox = 120; long ordonnee_edit = 156; long ordonnee_bouton = 180; long hauteur_bouton = 23 ; long largeur_bouton = 100; long abscisse_text = 16 ; long abscisse_static = 85 ; long ordonnee_static1 = 15 ; long ordonnee_static2 = 37 ; long ordonnee_static3 = 59 ; long ordonnee_static4 = 81 ; long hauteur_groupe = 210; long hauteur_static = 17 ; long largeur_static = 245; long hauteur_static4 = 73 ; long largeur_icone = 32 ; long hauteur_icone = 32 ; // Définition de zone rectangulaires RECT cracker = {largeur_fenetre * 4 / 100 ,38,largeur_fenetre * 4 / 100 + 38,50}; //left,top,right,bottom de la zone rectangulaire RECT auteur = {largeur_fenetre * 52 / 100 ,38,largeur_fenetre * 52 / 100 + 38,50}; //left,top,right,bottom de la zone rectangulaire RECT message_date = {largeur_fenetre * 48 / 100 ,62,largeur_fenetre * 48 / 100 + 60,70}; //left,top,right,bottom de la zone rectangulaire RECT icone = {largeur_fenetre * 4 / 100 ,hauteur_fenetre * 28 / 100,largeur_fenetre * 4 / 100+largeur_icone ,hauteur_fenetre * 28 / 100+hauteur_icone}; RECT lancement = {largeur_fenetre * 95 /100 ,ordonnee_edit, largeur_fenetre * 99 /100,ordonnee_edit+18}; //left,top,right,bottom de la zone rectangulaire // Position de la fenêtre affichant le crack long point_gauche_fenetre = (GetSystemMetrics(SM_CXFULLSCREEN)-largeur_fenetre)/2; long point_haut_fenetre = (GetSystemMetrics(SM_CYFULLSCREEN)-hauteur_fenetre)/2; // Etat initial des boutons checkbox bool checkbox1 = true; // Etat coché du bouton checkbox1 (sauve) bool checkbox2 = true; // Etat coché du bouton checkbox2 (Vérifie) bool checkbox3 = false; // Etat décoché du bouton checkbox3 (restaure) //Paramétrages de l'application // Tableau représentatif des fichiers à craquer // et des ressources à copier stockées dans le crack. // Mettre les fichier à craquer avant les ressources à cause de la matrice // 1 ière variable = nom affiché dans le crack // 2 ième variable = nom de l'exécutable à craquer correspondant au nom donné dans la 1 ière variable // 3 ième variable = chemin d'accès relatif du fichier à craquer sans / initial mais un / final depuis le chemin calculé dans la zone edit ; "" => chemin calculé dans la zone edit = chemin de l'exe donnée en 2 ième variable // 4 ième variable = type du fichier : "" = pas une ressource; "r"=ressource // 5 ième variable = filtre utilisé dans la boîte de sélection de fichiers char * liste_fichiers[][5] = { {"Start Clean v1.2","StartCln.exe","","","Start Clean v1.2 (StartCln.exe)\0STARTCLN.EXE\0\0"}, //{"BINAIRE1","Ressource.exe","","r",""}, }; //Liste des modifications offset / valeur pour chaque fichier qui n'est pas une ressource //Chaque sous-liste délimitée par des {} de la liste principale correspond aux modifications à apporter à un seul fichier //Le fichier à modifier est celui indiqué dans liste_fichiers dont le numéro d'ordre correspond à celui de la sous-liste //Attention : si 5 offsets et 5 octets soient 10 valeurs il faudra mettre au moins 11 pour la dimension long matrice[][11] = { { 0x5DE,0x50, 0x5DF,0x90, 0x5E0,0x90, 0x5E1,0x90, 0x5E2,0x90, }, }; //Tableau des tailles et des sommes des fichiers et des resssources //1 ier élément de chaque sous-liste : taille attendue du fichier à craquer ou de la ressource nommé dans liste_fichiers //2 ième élément de chaque sous-liste : somme des octets du fichier à craquer ou taille de la ressource à écrire //3 ième élément de chaque sous-liste : taille de la ressource si le fichier est une ressource long taille_somme[][3] = { {31744,2151373,0}, //{0,0,6144}, }; //Numéro du fichier à craquer int numero_fichier_a_craquer = 0; //Liste des identifiants de fichiers //Taille du tableau = nb identifiants +1 long liste_identifiants_fichiers[2] = {0}; //Liste des états des fichiers bool etat_craquage[]={false}; //Pour le debug bool afficher_somme = 0; // Fin des paramétrages de l'application // Déclarations nécessaires pour le choix de la police HDC hdc; LOGFONT lf; HFONT hfont; HFONT hfontOld; // Type de police choisie char f[32]={"ARIAL"}; // Déclarations des composants pour pouvoir les utiliser dans tout le programme HWND hwnd; /* Pointeur vers notre fenêtre */ HWND hwndEdit1; /* La zone de texte */ HWND hwndButton1; /* 1 ier bouton */ HWND hwndButton2; /* 2 ieme bouton */ HWND hwndButton3; /* 3 ieme bouton */ HWND hwndCheckBox1; /* 1 iere boite à cocher */ HWND hwndCheckBox2; /* 2 ieme boite à cocher */ HWND hwndCheckBox3; /* 3 ieme boite à cocher */ char chemin_registre[100]; char chemin_registre_edit[100]; char chaine[100]; char res[100],res2[100],res3[100]; char premier_fichier[100]; char chemin_nom_fichier [100] =""; char chemin_nom_fichier2[100] =""; char chemin_nom_fichier3[100] =""; char chemin_nom_fichier4[100] =""; char derniere_erreur[200]; // chaine contenant la dernière erreur rencontrée pour l'écriture char * fichier_courant; static HINSTANCE hGlobInstance = NULL; // Pour le traitement des ressources static HGLOBAL hresource; // Pour le traitement des ressources HINSTANCE hThisInstance; /***********************************************************
    * *
    * Les fonctions *
    * *
    ***********************************************************/
    // Fonction qui ouvre le site web donné dans la variable adresse // Retour : aucun void site(char adresse[], bool mon_site) { // Si l'adresse à charger dans le navigateur web est celle de mon site // j'ajoute un paramètre supplémentaire pour signifier à mon site qu'on y vient // suite à un clic sur une zone de mon crack. if (mon_site) {sprintf(adresse,"%s?Crack pour %s",adresse,nom_application);} // J'ouvre l'adresse du site web demandée dans le navigateur web ShellExecute(NULL,"open",adresse,NULL,NULL,SW_SHOWNORMAL); } // Fonction qui envoie un mail au destinataire désigné par adresse_mail // Retour : aucun void mail() { // On ré-initialise la variable chaine en mettant un caractère de fin de chaine // en première position chaine[0]='\0'; // On crée la chaine de connexion pour le logiciel de messagerie // sprintf permet de formater des expressions suivant des commutateurs %s,%ld ... sprintf(chaine, "mailto:%s?subject=%s%s&body=%s",adresse_mail,titre_mail,nom_application,corps_mail); // On lance le logiciel de messagerie ShellExecute(NULL,"open",chaine,NULL,NULL,SW_SHOWNORMAL); } // Fonction qui lance le programme de la zone EDIT // Retour : aucun void lancer_programme() { GetWindowText(hwndEdit1,chaine,100); ShellExecute(NULL,"open",chaine,NULL,NULL,SW_SHOWNORMAL); } // Fonction qui affiche les informations // Retour : aucun void infos() { // On crée et on ouvre le fichier nommé fichier_infos en mode write (écriture) FILE * pFile = fopen(fichier_infos,"w"); if (pFile!=NULL) { // On copie la ressource correspondant au fichier d'informations // dans un fichier d'infos static char *ptexte; // On charge la ressource nommé TEXTE de type BINARY dans la variable pTexte hresource=LoadResource(hGlobInstance,FindResource(hGlobInstance,"TEXTE","BINARY")); ptexte=(char*) LockResource(hresource); // On écrit le contenu de la variable ptexte dans le fichier // représenté par le pointeur pFile fputs(ptexte,pFile); // On ferme le fichier fclose(pFile); // On lance le fichier d'infos dans le navigateur web ShellExecute(NULL,"open",fichier_infos,NULL,NULL,SW_SHOWNORMAL); } else { // Si on n'a pas réussi à créer et ouvrir le fichier d'infos // On affiche le message d'erreur suivant sprintf(chaine, "Impossible de créer le fichier %s dans le répertoire courant.",fichier_infos); MessageBox(hwnd, chaine, nom_application, MB_OK|MB_ICONERROR); } } // Fonction d'extraction du chemin de désinstallation de l'éxécutable à partir de la clé trouvée dans le registre // Retour : chemin de l'éxécutable formaté char * formater_chemin_registre(char * ch) { int k=0; int debut=0,fin=0,guillemet_suivant=1; for (int i=0 ;ch[i] ;i++) { //if (ch[i]==' ') {debut=i+1;} //if ((ch[i]=='"' || ch[i]=='\'') && guillemet_suivant) {debut=i+1;guillemet_suivant=0;} //if (ch[i]=='\\') {fin=i;} //if (ch[i]=='\\' || ch[i]=='/') {fin=i;} fin=i; } for (int i=debut ;i<=fin ;i++) { res[k]=ch[i]; k++; } // On ajoute ce caractère terminal pour pouvoir // ensuite ajouté derrière le nom de l'executable res[k]='\\'; return res; } // Fonction d'extraction du chemin d'accès dans une chaîne // Retour : chemin de l'éxécutable char * extraire(char* ch2) { int i=0,k=0,fin=0; // Boucle qui lit la chaine ch2 pour trouver le caractère \ ou / du chemin d'accès for(i;ch2[i]!='\0' ;i++) { if (ch2[i]=='\\' || ch2[i]=='/') {fin=i;} } // Boucle qui construit le chemin extrait for(i=0;i<=fin ;i++) { res2[k]=ch2[i]; k++; } // On termine la chaine res2 par le caractère de fin de chaine // Cela evite une erreur dans l'extraction du chemin dans la fonction ecrire // si on extrait successivement 2 chemins de longueur différents (le premier plus // long que le deuxième). res2[k]='\0'; return res2; } // Fonction d'extraction du nom de fichier dans une chaîne // Retour : chemin de l'éxécutable char * extraire_nom_fichier(char* ch3) { int i=0,k=0; for(i=strlen(ch3)-2;ch3[i]!='\\' && ch3[i]!='/' ;i--) {;} for(i=i+1;i<=strlen(ch3)-1;i++) { res3[k]=ch3[i]; k++; } // On termine la chaine res2 par le caractère de fin de chaine // Cela evite une erreur dans l'extraction du chemin dans la fonction ecrire // si on extrait successivement 2 chemins de longueur différents (le premier plus // long que le deuxième). res3[k]='\0'; return res3; } // Fonction qui lit le chemin d'accès de l'application exécutable depuis la clé uninstall du registre // Retour : valeur du chemin char * lire_registre() { HKEY hKey; DWORD dwLen = 255; char dwKeyEn[255]={'\0'}; sprintf(chaine,"SOFTWARE\\Microsoft\\windows\\CurrentVersion\\Uninstall\\%s",cle_registre); // On ouvre la clé uninstall du registre RegOpenKey(HKEY_LOCAL_MACHINE,chaine,&hKey); // On récupère dans dwKeyEn la valeur associée au nom InstallLocation RegQueryValueEx(hKey,"InstallLocation", NULL, NULL, (LPBYTE)&dwKeyEn, &dwLen); RegCloseKey(hKey); // On met le chemin trouvé dans chemin_registre sprintf(chemin_registre,"%s", formater_chemin_registre(dwKeyEn)); return chemin_registre; } // Fonction qui dessine des objets sur la fenêtre principale // Retour : aucun void dessiner() { PAINTSTRUCT ps; // Début du dessin hdc = BeginPaint (hwnd, &ps); // Initialisation de la structure LOGFONT ZeroMemory(&lf, sizeof(LOGFONT)); // On met le nom de la police dans la propriété lfFaceName de lf strcpy(lf.lfFaceName,f); lf.lfHeight = 14; // hauteur des caractères lf.lfWeight = 0; // épaisseur des caractères lf.lfItalic = 0; // caractères en italique ou non lf.lfUnderline = 0; // caractères soulignés ou non // Création de la police hfont = CreateFontIndirect(&lf); hfontOld = (HFONT)SelectObject(hdc, hfont); // Arrière plan du dessin où l'on va écrire le texte // de la même couleur que le fond de la fenêtre SetBkMode(hdc,TRANSPARENT); // On écrit en bleu navy SetTextColor(hdc, RGB(0,0,128)); //DrawText(hdc, date_crack, -1, &message_date, DT_SINGLELINE); // On écrit le texte à partir des coordonnées d'un point // strlen calcule la taille d'une chaine TextOut (hdc, abscisse_text,15,"Programme",strlen("Programme")); TextOut (hdc, abscisse_text,38,"Cracker" ,strlen("Cracker")); TextOut (hdc, largeur_fenetre * 10 / 100,ordonnee_checkbox ,"Sauve",strlen("Sauve")); TextOut (hdc, largeur_fenetre * 10 / 100,ordonnee_checkbox+20,"Vérifie",strlen("Vérifie")); TextOut (hdc, largeur_fenetre * 10 / 100,ordonnee_checkbox+40,"Restaure",strlen("Restaure")); // Charger une icône située dans les ressource sous le numéro 500 // Remplacer le mot ICON par BITMAP pour charger une image de type bitmap HICON hBmp = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(500), IMAGE_ICON, largeur_icone, hauteur_icone, 0); DrawState(hdc,NULL,NULL,(LPARAM)hBmp,(WPARAM)NULL,icone.left,icone.top,0,0,DST_ICON); // Fin du dessin EndPaint (hwnd, &ps); } // Fonction qui calcule la somme tous les octets du fichiers // Retour : booléen qui dit si la somme est égale à celle attendue bool verification_integrite_fichier(char * f,int numero_fichier_a_craquer) { // On ouvre le fichier f en mode read binary (lecture binaire) FILE * pFile=fopen(f,"rb"); // On initilaise les variables long i=0; long somme=0; bool resultat=false; long taille = taille_somme[numero_fichier_a_craquer][0]; //On fait la somme des octets du fichier f while(i<taille) { somme+=fgetc(pFile); i++; } fclose(pFile); // Si on a demandé l'affichage de la somme. // On ne l'utilise une seule fois que pour le debugging if(afficher_somme) { chaine[0]='\0'; sprintf(chaine, "Somme octets de %s = %ld.", liste_fichiers[numero_fichier_a_craquer][1] , somme); MessageBox(hwnd, chaine , nom_application ,MB_OK|MB_ICONINFORMATION); } return (somme==taille_somme[numero_fichier_a_craquer][1]); } // Fonction qui calcule la taille d'une sous-matrice du tableau matrice // Retour : nombre d'octets à craquer pour le fichier considéré long calculer_taille_sous_matrice(long sous_matrice[]) { long i=0; //On evite avec i%2==1 l'arrêt prématuré sur un offset recevant la valeur 0x00 //La boucle while parcourt en effet toutes les valeurs du tableau offset/valeur //nommé sous_matrice mais elle peut s'arrêter avant le fin du tableau si un 0 est //trouvé dans les valeurs du tableau. while(sous_matrice[i] || i%2==1) i++; return i; } // Fonction qui écrit dans les fichiers listés dans liste_fichiers. // Retour : booléen. Vrai si aucune erreur rencontrée faux sinon. bool ecrire(int numero_fichier_a_craquer,int numero_boucle) { FILE * pFile; int nb_erreurs=0; GetWindowText(hwndEdit1,chemin_nom_fichier,100); // Si c'est la première boucle on vérifie le nom du fichier donné par la zone EDIT // Sinon on prend sans vérifier le nom du fichier à craquer dans la liste_fichiers if(numero_boucle==1) { fichier_courant = extraire_nom_fichier(chemin_nom_fichier); // On concatène le chemin de la zone edit et le nom de l'exécutable à craquer sprintf(chemin_nom_fichier, "%s%s", extraire(chemin_nom_fichier),fichier_courant); // On sauvegarde le nom du premier fichier ouvert pour le nom à afficher en // cas de restauration sprintf(premier_fichier,"%s",fichier_courant); } else { fichier_courant = liste_fichiers[numero_fichier_a_craquer][1]; // On concatène le chemin de la zone edit,le chemin relatif du fichier et // le nom de l'exécutable à craquer sprintf(chemin_nom_fichier, "%s%s%s", extraire(chemin_nom_fichier),liste_fichiers[numero_fichier_a_craquer][2],fichier_courant); } // Le nom donné au fichier de sauvegarde est d'extension .bak sprintf(chemin_nom_fichier2, "%s.bak", chemin_nom_fichier); // Le nom donné au fichier temporaire .exe est d'extension .temp sprintf(chemin_nom_fichier3, "%s.temp", chemin_nom_fichier); // Si le fichier existe et est en lecture seule // on enlève la protection en écriture if (GetFileAttributes(chemin_nom_fichier) | FILE_ATTRIBUTE_READONLY) { SetFileAttributes(chemin_nom_fichier, FILE_ATTRIBUTE_NORMAL); } // Si la case checkbox 3 est cochée on restaure if (checkbox3) { // On ouvre les fichiers en lecture pour voir s'ils existent FILE * pFile2=fopen(chemin_nom_fichier2,"r"); //Si le fichier .bak existe on effectue la restauration if(pFile2!=NULL) { // On remplace le fichier modifié par sa copie if(!CopyFile(chemin_nom_fichier2,chemin_nom_fichier,0)) { // Si une erreur est constatée sprintf(derniere_erreur,"Impossible de restaurer le fichier %s depuis %s.bak",fichier_courant); nb_erreurs++; } // On ferme le fichier ouvert avec succès fclose(pFile2); } else { // On lève une exception nb_erreurs++; // On empile l'erreur rencontrée sprintf(derniere_erreur, "Le fichier %s.bak à restaurer est introuvable !",fichier_courant); } } else { // Sinon on craque le fichier ou on copie la ressource pFile = fopen(chemin_nom_fichier,"rb+"); // Si l'ouverture en mode lecture binaire a réussi if (pFile!=NULL) { // Obtenir la taille du fichier. fseek (pFile , 0 , SEEK_END); long Taille_reelle_fichier = ftell (pFile); rewind (pFile); if (Taille_reelle_fichier==taille_somme[numero_fichier_a_craquer][0]) { bool erreur_somme=false; // Si la case est cochée on vérifie l'intégrité des fichiers if(checkbox2) { if (!verification_integrite_fichier(chemin_nom_fichier,numero_fichier_a_craquer)) { nb_erreurs++; // Si le fichier a déja été modifié ou cracké on arrête le craquage. sprintf(derniere_erreur, "Le fichier %s est déja cracké ou a été modifié !",fichier_courant); erreur_somme=true; } } // On écrit dans le fichier // -> si on ne demande pas de vérification d'intégité du fichier // -> s'il n'y a pas d'erreurs une fois la vérification de la somme du fichier effectuée // -> si c'est une ressource du crack if(!checkbox2 || (checkbox2 && erreur_somme==0) || liste_fichiers[numero_fichier_a_craquer][3]=="r") { // On fait une copie de sauvegarde du fichier // si le bouton checkbox1 est coché if(checkbox1) { if(!CopyFile(chemin_nom_fichier,chemin_nom_fichier2,0)) { sprintf(derniere_erreur, "Impossible de créer une copie de sauvegarde du fichier %s.",fichier_courant); nb_erreurs++; } } if(nb_erreurs==0) { //si c'est un fichier à craquer if(liste_fichiers[numero_fichier_a_craquer][3]=="") { for(int j=0;j<calculer_taille_sous_matrice(matrice[numero_fichier_a_craquer]);j=j+2) { //on se positionne sur l'offset à modifier du fichier à craquer fseek(pFile,matrice[numero_fichier_a_craquer][j],SEEK_SET); // On écrit le nouvel octet à l'offset fputc(matrice[numero_fichier_a_craquer][j+1],pFile); } // On ferme le fichier ouvert avec succès en mode écriture fclose(pFile); // Si aucune erreur d'écriture if(nb_erreurs==0) { etat_craquage[numero_fichier_a_craquer]=true; } } else { // Alors c'est une ressource à copier // On ferme le fichier ouvert avec succès en mode lecture fclose(pFile); if(nb_erreurs==0) { // On ouvre en mode écriture un nouveau fichier // dans lequel on va mettre tout le contenu de la ressource pFile = fopen(chemin_nom_fichier,"wb"); // Si l'ouverture en mode lecture binaire a réussi if (pFile!=NULL) { // On charge la ressource type binaire à partir de la liste des fichiers hresource=LoadResource(hGlobInstance,FindResource(hGlobInstance,liste_fichiers[numero_fichier_a_craquer][0],"BINARY")); char * contenu_ressource =(char*) LockResource(hresource); // On copie le contenu de la ressource dans le fichier crée fwrite(contenu_ressource,1,taille_somme[numero_fichier_a_craquer][2],pFile); // On ferme le fichier ouvert avec succès en mode écriture fclose(pFile); } else { // Si l'ouverture en écriture a échoué on lève une exception nb_erreurs++; // On empile l'erreur dans la pile nommée derniere_erreur sprintf(derniere_erreur, "Impossible d'écrire dans la ressource %s.",fichier_courant); } } //Fin du nb_erreurs=0 } //Fin des ressources à copier } //Fin du nb_erreurs=0 } //Fin du test sur checkbox2 //On ferme le fichier ouvert avec succès car il n'est pas fermé fclose(pFile); } // Fin du test sur les tailles else { //Si la taille n'est pas bonne nb_erreurs++; // On empile l'erreur dans la pile nommée derniere_erreur sprintf(derniere_erreur, "La taille du fichier est incorrecte.\n%s aurait dû faire %ld octets.\nCe n'est probablement pas la bonne version.",fichier_courant,taille_somme[numero_fichier_a_craquer][0]); //On ferme le fichier ouvert avec succès car il n'est pas fermé fclose(pFile); } } //Fin du test sur l'ouverture de fichier else { // Si une erreur apparaît à l'ouverture du fichier nb_erreurs++; if(GetFileAttributes(extraire(chemin_nom_fichier)) != FILE_ATTRIBUTE_DIRECTORY) { // Si le chemin d'accès du fichier est introuvable on renvoie une erreur sprintf(derniere_erreur, "Le chemin d'accès spécifié est introuvable.");} else { FILE * pFile = fopen(chemin_nom_fichier,"r"); // On teste l'existence du fichier chemin_nom_fichier if(pFile==NULL) { // Le chemin existe mais pas le répertoire sprintf(derniere_erreur, "Le fichier %s n'existe pas dans le répertoire spécifié.",fichier_courant); } else { // Sinon le fichier est déja utilisé auquel cas il est inaccessible. On renvoie à ce moment une erreur sprintf(derniere_erreur, "Le fichier %s est inaccessible\nIl est déja ouvert par un autre processus.",fichier_courant); // On ferme le fichier ouvert avec succes en mode lecture fclose(pFile); } } } } // Fin du test sur la restauration // On retourne l'état de l'écriture if(nb_erreurs==0) {return true;} else {return false;} } void effacer(long identifiants[],long nombre_id,bool erreurs) { GetWindowText(hwndEdit1,chemin_nom_fichier,100); for(int i=0;i<nombre_id;i++) { fichier_courant = liste_fichiers[identifiants[i]][1]; // On concatène le chemin de la zone edit,le chemin relatif du fichier et // le nom de l'exécutable à craquer sprintf(chemin_nom_fichier, "%s%s%s", extraire(chemin_nom_fichier),liste_fichiers[liste_identifiants_fichiers[i]][2],fichier_courant); // Le nom donné au fichier de sauvegarde est d'extension .bak sprintf(chemin_nom_fichier2, "%s.bak", chemin_nom_fichier); // Le nom donné au fichier temporaire est d'extension .temp sprintf(chemin_nom_fichier3, "%s.temp", chemin_nom_fichier); // Le nom donné au fichier temporaire .bak est d'extension .temp sprintf(chemin_nom_fichier4, "%s.temp", chemin_nom_fichier2); if(erreurs) { // On restitue le fichiers .exe original CopyFile(chemin_nom_fichier3,chemin_nom_fichier,0); // On restitue le fichiers .bak original CopyFile(chemin_nom_fichier4,chemin_nom_fichier2,0); //Si un fichier .bak existait avant la sauvegarde un .bak.temp a été crée //Donc on n'efface pas la sauvegarde qui existait avant FILE * pFile = fopen(chemin_nom_fichier4,"r"); if(pFile!=NULL) {fclose(pFile);} else {DeleteFile(chemin_nom_fichier2);} } //Si restauration activée // ->pas d'erreur on efface le .bak // ->erreur on ne touche pas au .bak if(checkbox3 && !erreurs) DeleteFile(chemin_nom_fichier2); DeleteFile(chemin_nom_fichier3); DeleteFile(chemin_nom_fichier4); } } // Effectue une copie préventive des fichiers .exe et .bak éventuels sous forme de fichiers // exe.temp et .bak.temp indiqués dans la liste des identifiants de fichiers liste_identifiants_fichiers. // Cela permet de rétablir facilement tous les fichiers originaux en cas d'erreur. // Retour rien (void = rien) void sauver_fichiers() { int i=0; GetWindowText(hwndEdit1,chemin_nom_fichier,100); // On sauve les fichiers identifiés dans liste_identifiants_fichiers // avec leur .bak éventuel. // En C tout ce qui différent de 0 est true => pb si indentifiant i vaut 0 => test du while lourd à écrire while(liste_identifiants_fichiers[i] || (liste_identifiants_fichiers[i]==0 && i==0)) { fichier_courant = liste_fichiers[liste_identifiants_fichiers[i]][1]; // On concatène le chemin de la zone edit,le chemin relatif du fichier et // le nom de l'exécutable à craquer sprintf(chemin_nom_fichier, "%s%s%s", extraire(chemin_nom_fichier),liste_fichiers[liste_identifiants_fichiers[i]][2],fichier_courant); // On enlève l'attribut en lecture seule sur le fichiers // car au moment de l'effacement le fichier .temp correspondant // qui aura été crée ne pourra être effacé if (GetFileAttributes(chemin_nom_fichier) | FILE_ATTRIBUTE_READONLY) { SetFileAttributes(chemin_nom_fichier, FILE_ATTRIBUTE_NORMAL); } // Le nom donné au fichier de sauvegarde est d'extension .bak sprintf(chemin_nom_fichier2, "%s.bak", chemin_nom_fichier); // Le nom donné au fichier temporaire est d'extension .temp sprintf(chemin_nom_fichier3, "%s.temp", chemin_nom_fichier); // Le nom donné au fichier temporaire .bak déja existant sera d'extension .temp sprintf(chemin_nom_fichier4, "%s.temp", chemin_nom_fichier2); // On fait une copie temporaire du fichiers .exe. // 0 dans CopyFile pour l'overwrite si le fichier .temp existe déja (normalement il n'y en a pas => mais prudence oblige) CopyFile(chemin_nom_fichier,chemin_nom_fichier3,0); // On fait une copie temporaire du fichiers .bak CopyFile(chemin_nom_fichier2,chemin_nom_fichier4,0); i++; } } // On écrit tous les fichiers et les ressources inscrits sous forme de numéro dans // liste_identifiants_fichiers en appelant la fonction ecrire pour chaque fichier à traiter // Retour : rien void ecrire_en_boucle() { bool etat_ecriture=true; int numero_boucle=1; int k=0; bool etat_checkbox3=checkbox3; //On sauve tous les fichiers avant d'effectuer les opérations d'écriture ou d'effacement sauver_fichiers(); //On balaie la liste des identifiants de fichiers //Attention : si un identifiant vaut 0 on sort de la boucle => il faut éviter ce pb par ce test dans le while. while(liste_identifiants_fichiers[k] || (liste_identifiants_fichiers[k]==0 && k==0)) { etat_ecriture = etat_ecriture & ecrire(liste_identifiants_fichiers[k],numero_boucle); numero_boucle++; k++; } // Si aucune erreur constatée sur tous les fichiers écrits if(etat_ecriture) { if(!checkbox3) { // Si on n'est pas en mode restauration // on affiche le message correspondant sprintf(chaine,message_reussite); //Si une copie de sauvegarde a été demandée on active la case checkbox3 //pour la restauration if(checkbox1) { SetWindowText(hwndButton1,"Restaurer"); } } else { // Si on était dans l'état restauration on affiche le message correspondant // et on repasse dans l'état initial if(k>1) { sprintf(chaine, "Tous les fichiers ont été restaurés. "); } else { sprintf(chaine, "Le fichier %s a été restauré. ",premier_fichier); } // On change le nom du bouton et on coche ou non la case checkbox3 SetWindowText(hwndButton1,"Crack"); } //On efface tous les fichiers temporaires crées effacer(liste_identifiants_fichiers,numero_boucle-1,false); //On modifie l'état coché ou non de checkbox3 si la sauvegarde a été demandée //Ne pas permuter avec ligne du dessus sinon pb sur état checkbox3 dans effacer if(checkbox1) { if(!checkbox3) {checkbox3=true;} else {checkbox3=false;} SendMessage(hwndCheckBox3, BM_SETCHECK, checkbox3, 0); } MessageBox(hwnd,chaine,nom_application,MB_OK|MB_ICONINFORMATION); } else { //On renomme tous les fichiers .temp crées en .exe //On efface tous les fichiers .bak crées effacer(liste_identifiants_fichiers,numero_boucle-1,true); //On renvoie la dernière erreur MessageBox(hwnd,derniere_erreur,nom_application,MB_OK|MB_ICONERROR); } } // Fonction qui ouvre la boite de dialogue de sélection de fichiers // Retour : rien char * selection_fichier(long numero_fichier) { OPENFILENAME ofn; char szFileName[MAX_PATH]; ZeroMemory(&ofn, sizeof(ofn)); szFileName[0] = '\0'; ofn.lStructSize = sizeof(ofn); ofn.hwndOwner = hwnd; ofn.lpstrFilter = liste_fichiers[numero_fichier][4]; ofn.lpstrTitle = titre_boite_dialogue; // szFileName = le fichier avec son chemin qui a été sélectionné // dans la boite de dialogue ofn.lpstrFile = szFileName; // Si on n'a pas trouvé le chemin d'insatllation dans le registre // On positionne la boîte de sélection de fichiers sur C:\Program Files if(chemin_registre[0]=='\0') {ofn.lpstrInitialDir = "C:\\Program Files";} else {ofn.lpstrInitialDir = chemin_registre;} ofn.nMaxFile = MAX_PATH; ofn.lpstrDefExt = "exe"; ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY; //Ouverture de la boîte de dialogue avec les paramètres précédents GetOpenFileName(&ofn); //Chemin + nom du fichier sélectionné sprintf(chaine, "%s", szFileName); // Si aucun fichier n'a été sélectionné on restitue la chaîne qui est dans le edit if (chaine[0]=='\0') GetWindowText(hwndEdit1,chaine,200); return chaine; } // Fonction qui désactive hwndButton1 quand la zone de texte hwndEdit1 est vide // ou qui le réactive sinon // Retour : aucun void controler_contenu_edit() { //Si le contenu de la zone edit est vide on désactive hwndButton3 GetWindowText(hwndEdit1,chaine,100); bool bouton_actif; if (chaine[0]=='\0') {bouton_actif=false;} else {bouton_actif=true;} EnableWindow(hwndButton1,bouton_actif); } // Fonction qui retourne le contenu de la zone edit // Retour : contenu de la zone edit char * contenu_edit() { GetWindowText(hwndEdit1,chaine,100); return chaine; } // Fonction qui change le chemin et de l'exe dans la zone edit quand on clique sur un bouton radio // Retour : aucun void changer_edit(char * chaine_chemin,char * nom_de_l_exe) { //On met le chemin suivi du nom de l'exe dans la zone edit sprintf(chaine,"%s\%s", chaine_chemin,nom_de_l_exe); SetWindowText(hwndEdit1,chaine); } /***********************************************************
    * *
    * Composants minimum de l'application graphique *
    * *
    ***********************************************************/
    // Cette fonction est appelée par la fonction windows DispatchMessage( ) LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { HDC hdcStatic = (HDC)wParam; HDC hdc = (HDC)wParam; HBRUSH g_hbrBackground; switch (message) /* pointeur des messages */ { // Evénement déclenché lors du coloriage des composants statics du groupe case WM_CTLCOLORSTATIC: { // On fixe la couleur de fond des composants de type static g_hbrBackground = CreateSolidBrush(RGB(0xEC,0xE9,0xD8)); // On fixe la couleur du texte du premier composant static if (GetWindowLong((HWND)lParam, GWL_ID) == 11) { // On écrit en marron SetTextColor(hdcStatic, RGB(128,00,00)); } else { // On fixe la couleur du texte du deuxième composant static
    if (GetWindowLong((HWND)lParam, GWL_ID) == 12) { // On met la police en gras lf.lfWeight = FW_BOLD; // Création de la police hfont = CreateFontIndirect(&lf); hfontOld = (HFONT)SelectObject(hdc, hfont); // On écrit en vert SetTextColor(hdcStatic, RGB(0,128,128)); } else { // Sinon les autres composants static seront de couleur navy
    SetTextColor(hdcStatic, RGB(0,0,128)); } } SetBkMode(hdcStatic, TRANSPARENT); return (LONG)g_hbrBackground; } break; // Evénement déclenché lors du coloriage de la zone edit case WM_CTLCOLOREDIT: // On fixe la couleur de fond du composant EDIT g_hbrBackground = CreateSolidBrush(RGB(0xEE,0xEE,0xEE)); // On écrit en violet
    SetTextColor(hdc, RGB(128,0,128)); // L'arrière plan du rectangle dans lequel on écrit sera de la même // couleur que le fond SetBkMode(hdc, TRANSPARENT); return (LONG)g_hbrBackground; break; // Evénement déclenché quand la fenêtre doit être redessinée case WM_PAINT: dessiner(); break; // Evénement déclenché lorsque la souris bouge sur le fenêtre case WM_MOUSEMOVE: // Déclaration d'un point static POINT MousePos; // Récupération de la position du pointeur de la souris GetCursorPos(&MousePos); // Transformation des coordonnées absolues de la souris en coordonnées relatives à la fenêtre ScreenToClient(hwnd,&MousePos); // Si l'utilisateur passe au dessus d'une des zones "icone","cracker","auteur","message_date" on change le curseur par une main if( MousePos.x>=icone.left && MousePos.x<=icone.right && MousePos.y<=icone.bottom && MousePos.y>=icone.top || MousePos.x>=cracker.left && MousePos.x<=cracker.right && MousePos.y<=cracker.bottom && MousePos.y>=cracker.top || MousePos.x>=auteur.left && MousePos.x<=auteur.right && MousePos.y<=auteur.bottom && MousePos.y>=auteur.top || MousePos.x>=message_date.left && MousePos.x<=message_date.right && MousePos.y<=message_date.bottom && MousePos.y>=message_date.top || MousePos.x>=lancement.left && MousePos.x<=lancement.right && MousePos.y<=lancement.bottom && MousePos.y>=lancement.top ) { // Le curseur en forme de main est identifié par windows comme ayant le numéro 32649 const long HandCursor = 32649; // On charge le curseur HCURSOR hCursor = SetCursor(LoadCursor(hThisInstance,MAKEINTRESOURCE(HandCursor))); // On affiche le curseur en forme de main ShowCursor(TRUE); } break; // Evénement déclenché lorsque le bouton gauche de la souris est pressé case WM_LBUTTONDOWN: // Si l'utilisateur clique sur l'icône if(MousePos.x>=icone.left && MousePos.x<=icone.right && MousePos.y<=icone.bottom && MousePos.y>=icone.top) {site(adresse_site_editeur,false);} // Si l'utilisateur clique sur le nom du cracker qui correspond au rectangle "auteur" if(MousePos.x>=auteur.left && MousePos.x<=auteur.right && MousePos.y<=auteur.bottom && MousePos.y>=auteur.top) {site(adresse_site_cracker,true);} // Si l'utilisateur clique sur l'auteur du crack qui correspond à la zone nommée cracker if(MousePos.x>=cracker.left && MousePos.x<=cracker.right && MousePos.y<=cracker.bottom && MousePos.y>=cracker.top) {mail();} // Si l'utilisateur clique sur la zone message_date if(MousePos.x>=message_date.left && MousePos.x<=message_date.right && MousePos.y<=message_date.bottom && MousePos.y>=message_date.top) {site(adresse_site_telechargement,false);} // Si l'utilisateur clique sur la zone de lancement if(MousePos.x>=lancement.left && MousePos.x<=lancement.right && MousePos.y<=lancement.bottom && MousePos.y>=lancement.top) {lancer_programme();} break; // Evénement déclenché lorsque l'on ferme la fenêtre case WM_DESTROY: // Fermeture de la fenêtre DeleteFile(fichier_infos); // On efface le fichier d'infos PostQuitMessage(0); // On envoie un message WM_QUIT à la pile break; // Evénement déclenché lorsqu'une commande est envoyée case WM_COMMAND: // si l'utilisateur fait un clic sur le bouton checkbox1 on transforme en coché on non l'état du bouton. if ((LOWORD(wParam) == 31)) { if(SendMessage(hwndCheckBox1,BM_GETCHECK,checkbox1,0)==BST_CHECKED) {checkbox1=true;} else {checkbox1=false;} } // si l'utilisateur fait un clic sur le bouton checkbox2 on transforme en coché on non l'état du bouton. if ((LOWORD(wParam) == 32)) { if(SendMessage(hwndCheckBox2,BM_GETCHECK,checkbox2,0)==BST_CHECKED) {checkbox2=true;} else {checkbox2=false;} } // si l'utilisateur fait un clic sur le bouton checkbox3 on transforme en coché on non l'état du bouton. if ((LOWORD(wParam) == 33)) { if(SendMessage(hwndCheckBox3,BM_GETCHECK,checkbox3,0)==BST_CHECKED) {checkbox3=true;} else {checkbox3=false;} } // Clic sur le edit if (LOWORD(wParam) == 15) {controler_contenu_edit();} //Clic sur le bouton crack if ((LOWORD(wParam) == 21) && (HIWORD(wParam) == BN_CLICKED)) {ecrire_en_boucle();} //Clic sur le bouton infos if ((LOWORD(wParam) == 22) && (HIWORD(wParam) == BN_CLICKED)) {infos();} //Clic sur le bouton chercher if ((LOWORD(wParam) == 23) && (HIWORD(wParam) == BN_CLICKED)) {SetWindowText(hwndEdit1,selection_fichier(numero_fichier_a_craquer));controler_contenu_edit();} //Clic sur le bouton checkbox3 if ((LOWORD(wParam) == 33) && (HIWORD(wParam) == BN_CLICKED)&& checkbox3) {SetWindowText(hwndButton1,"Restaurer");} if ((LOWORD(wParam) == 33) && (HIWORD(wParam) == BN_CLICKED)&& !checkbox3) {SetWindowText(hwndButton1,"Crack");} break; // Evénement déclenché lorsqu'une touche du clavier est pressée case WM_KEYDOWN: switch (wParam) { case VK_ESCAPE: // Si la touche échappe est pressée DeleteFile(fichier_infos); // On efface le fichier d'infos PostQuitMessage(0); // On ferme le programme } break; // Pour les messages qu'on ne traite pas default: return DefWindowProc(hwnd, message, wParam, lParam); } return 0; } //Point d'entrée du programme (équivaut à la procédure main en C) int WINAPI WinMain(HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil) { MSG messages; /* Variable contenant les messages de l'application */ WNDCLASSEX wincl; /* Structure de données pour windowclass */ /* Structure de la fenêtre */ wincl.hInstance = hThisInstance; wincl.lpszClassName = "WindowsApp"; wincl.lpfnWndProc = WindowProcedure; /* Cette fonction est appelée par windows */ wincl.style = CS_HREDRAW|CS_VREDRAW; /* Réagir au demande de redessinage */ wincl.cbSize = sizeof(WNDCLASSEX); /* Utilisons l'icône par défaut et la flèche de la souris */ wincl.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(500)); wincl.hIconSm = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(500), IMAGE_ICON, 16, 16, 0); wincl.hCursor = LoadCursor(NULL, IDC_ARROW); wincl.lpszMenuName = NULL; /* Pas de menu */ wincl.cbClsExtra = 0; /* Pas d'octets supplémentaires après la classe window */ wincl.cbWndExtra = 0; /* structure or the window instance */ // Fixons la couleur de fond de la fenêtre wincl.hbrBackground = CreateSolidBrush(RGB(0xCC, 0xCC, 0xCC)); // 0xEC,0xE9,0xD8 par défaut // Enregistrons la classe window, si échec quitons le programme if(!RegisterClassEx(&wincl)) return 0; // Initialisation de la structure LOGFONT ZeroMemory(&lf, sizeof(LOGFONT)); strcpy(lf.lfFaceName,f); lf.lfHeight = 14; // Taille des caractères dans la police choisie lf.lfWeight = 0; // Epaisseur de la police (Gras ou non) lf.lfItalic = 0; // Police en italic lf.lfEscapement = 0; // Espacement des caractères dans la police
    lf.lfQuality = PROOF_QUALITY; // Qualité de la police // Création de la fonte hfont = CreateFontIndirect(&lf); hfontOld = (HFONT)SelectObject(hdc, hfont); // La classe est enregistrée , créons le programme // Créons la fenêtre principale hwnd = CreateWindowEx( 0, /* Extended possibilites for variation */ "WindowsApp", /* Nom de la classe */ nom_application, /* Titre de la fenêtre */ WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, /* Style de la fenêtre */ point_gauche_fenetre, // coordonnée gauche du coin supérieur gauche de la fenêtre point_haut_fenetre, // coordonnée du haut du coin supérieur gauche de la fenêtre //CW_USEDEFAULT, /* Ou bien Windows decide automatiquement du coin supérieur gauche de la fenêtre */ //CW_USEDEFAULT, /* Ou bien Windows decide automatiquement du coin supérieur haut de la fenêtre */ largeur_fenetre, /* Largeur de la fenêtre en pixels */ hauteur_fenetre, /* hautre de la fenêtre en pixels */ HWND_DESKTOP, /* La fenêtre est fille du bureau */ NULL, /* Pas de menu */ hThisInstance, /* Pointeur de l'instance du programme */ NULL /* Pas de données pour la création de la fenêtre */ ); // Définition du cadre qui enveloppe toutes les zone de la fenêtre // C'est en fait un bouton transparent dont on ne voit que le contour (propriété BS_GROUPBOX) HWND hwndCadre1 = CreateWindow( "BUTTON", //Type BUTTON du composant à créer "", //Texte écrit sur le bouton (dans le cas des GROUPBOX c'est juste au dessus du cadre à gauche sinon c'est sur le bouton directement) WS_CHILD|WS_VISIBLE|BS_GROUPBOX, //Styles associés au bouton largeur_fenetre* 2 / 100 , 0,largeur_fenetre * 95 / 100,hauteur_groupe, //Coordonnées du point supérieur gauche et du point inférieur droit qui délimitent le bouton (abscisse,ordonnée,abscisse,ordonnée) hwnd, //Le bouton fait partie de la fenêtre repérée par le pointeur hwnd (WiNDow Handle) (HMENU)10, //10 est l'identifiant que nous allons donner à ce composant hThisInstance, /* Pointeur de l'instance du programme */ NULL); /* Pas de données pour la création de la fenêtre */ // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant
    SendMessage(hwndCadre1,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée une zone static d'identifiant 11 HWND hwndStatic1 = CreateWindow ( "STATIC", titre_application, WS_CHILD | WS_VISIBLE | SS_CENTER | SS_SUNKEN, // SS_SUNKEN pour avoir un static de forme enfoncée dans la fenêtre abscisse_static , ordonnee_static1 , largeur_static, hauteur_static, hwnd, (HMENU) 11, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndStatic1,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée une zone static d'identifiant 12 HWND hwndStatic2 = CreateWindow ( "STATIC", "Pifoman", WS_CHILD | WS_VISIBLE | SS_CENTER | SS_SUNKEN, abscisse_static , ordonnee_static2 , largeur_static, hauteur_static, hwnd, (HMENU) 12, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndStatic2,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée une zone static d'identifiant 13 qui contient la date du crack HWND hwndStatic3 = CreateWindow ( "STATIC", date_crack, WS_CHILD | WS_VISIBLE | SS_CENTER | SS_SUNKEN, abscisse_static , ordonnee_static3 , largeur_static, hauteur_static, hwnd, (HMENU) 13, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndStatic3,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée une zone static d'identifiant 14 qui contiendra les commentaires HWND hwndStatic4 = CreateWindow ( "STATIC", /* Type de composant à créer */ "\r\nCommentaires", WS_CHILD | WS_VISIBLE | SS_CENTER | SS_SUNKEN, abscisse_static , ordonnee_static4, largeur_static, hauteur_static4, /* Dimensions du composant */ hwnd, /* Le parent de ce composant est cette fenêtre */ (HMENU) 14, /* Identifiant de contrôle = 14 */ hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndStatic4,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On cherche le chemin d'accès par défaut de l'application dans le registre avec lire_registre(). // Et on l'écrit dans la zone d'édition le rséultat de cette interrogation. // On lit la valeur de la clé uninstall du registre sprintf(chemin_registre,"%s",lire_registre()); // Si on a trouvé le chemin dans le registre (ie chaine non nulle) on ajoute le nom de l'exe au chemin trouvé dans le registre avec la fonction sprintf if(chemin_registre[0]!='\0') sprintf(chemin_registre_edit,"%s%s",chemin_registre,liste_fichiers[numero_fichier_a_craquer][1]); // On crée une zone d'édition de texte d'identifiant 15 qui contiendra le chemin d'accès de l'exécutable à craquer hwndEdit1 = CreateWindow ( "EDIT", chemin_registre_edit, WS_CHILD | WS_VISIBLE | ES_LEFT | ES_AUTOHSCROLL, abscisse_static+1 , ordonnee_edit, largeur_static-1, hauteur_static, hwnd, (HMENU) 15, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndEdit1,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // Limiter le texte tapé à 100 caractères dans la zone edit SendMessage(hwndEdit1, EM_LIMITTEXT,100, true) ; // On crée le bouton Crack avec l'identifiant 21 hwndButton1 = CreateWindow ( "button", "Crack", WS_CHILD | WS_VISIBLE | BS_FLAT, largeur_fenetre* 5 / 100 , ordonnee_bouton , largeur_bouton , hauteur_bouton, hwnd, (HMENU) 21, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndButton1,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée le bouton infos avec l'identifiant 22 hwndButton2 = CreateWindow ( "button", "Infos", WS_CHILD | WS_VISIBLE | BS_FLAT, 124, ordonnee_bouton, largeur_bouton, hauteur_bouton, hwnd, (HMENU) 22, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndButton2,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée le bouton chercher avec l'identifiant 23 hwndButton3 = CreateWindow ( "Button", "Chercher", WS_CHILD | WS_VISIBLE | BS_FLAT, largeur_fenetre* 66 / 100 , ordonnee_bouton, largeur_bouton, hauteur_bouton, hwnd, (HMENU) 23, hThisInstance, NULL ); // On envoie un message au dispatcher : la fonction DispatchMessage() pour spécifier la police d'écriture qu'on va utiliser dans le composant SendMessage(hwndButton3,WM_SETFONT,(WPARAM)CreateFontIndirect (&lf),MAKELPARAM (TRUE,0)); // On crée une case à cocher avec l'identifiant 31 hwndCheckBox1 = CreateWindow ( "button", "", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, largeur_fenetre* 5 / 100 , 120, 13, 13, hwnd, (HMENU) 31, hThisInstance, NULL ); // On envoie un message pour spécifier l'état coché ou non du bouton
    SendMessage(hwndCheckBox1, BM_SETCHECK, checkbox1, 0); // On crée une case à cocher avec l'identifiant 32 hwndCheckBox2 = CreateWindow ( "button", "", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, largeur_fenetre* 5 / 100 , 140, 13, 13, hwnd, (HMENU) 32, hThisInstance, NULL ); // On envoie un message pour spécifier l'état coché ou non du bouton SendMessage(hwndCheckBox2, BM_SETCHECK, checkbox2, 0); // On crée une case à cocher avec l'identifiant 33 hwndCheckBox3 = CreateWindow ( "button", "", WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, largeur_fenetre* 5 / 100 , 160, 13, 13, hwnd, (HMENU) 33, hThisInstance, NULL ); // On envoie un message pour spécifier l'état coché ou non du bouton SendMessage(hwndCheckBox3, BM_SETCHECK, checkbox3, 0); //Si la zone edit est vide on désactive le bouton crack controler_contenu_edit(); // Rendre la fenêtre visible à l'écran ShowWindow(hwnd, nFunsterStil); // Démarrer la boucle de messages // Elle fonctionnera jusqu'à ce que GetMessage( ) retourne 0 while(GetMessage(&messages, NULL, 0, 0)) { // Traduire les messages clé virtuel en messages avec caractères TranslateMessage(&messages); // Envoyer les messages à la fonction WindowProcedure DispatchMessage(&messages); } // Le programme retourne la valeur 0 // C'est la valeur donnée par la fonction PostQuitMessage( ) return messages.wParam; } //--------------------------------------------------------------------------------------------


    <script language="JavaScript" type="text/javascript"> document.write(""); </script>


  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :