Introduction

 

1




Codage Assembleur Win32 pour Crackeurs

 


Mots clés Coding (codage), ASM, Win32, GUI
Niveau Débutant à Intermédiaire
Test OS Windows 10
Auteur

Adapté et traduit par
Goppit - 01/04/2006 - goppit@hotmail.com

sp0ke     - http://xtx.rf.gd/         Forum de la TEAM XTX  
      - http://xtxteam.free.fr  Site de la TEAM XTX - 2023  



Outils requis:
MASM32 v11r masm32v11r.zip
lib2inc v1.11 inclus dans ce Zip
WinAsm Studio Full v5.1.5.0 https://archive.org/WinAsm515Full.zip
WinAsm  v5.1.8.8 Update* https://archive.org/WinAsm5188Full.zip
https://winasm.org
WinAsm help file* https://archive.org/download/win-asm/WinAsm.chm
Win32.hlp file https://winasm.org
https://archive.org/Win32.hlp
OllyDbg v1.10 http://www.ollydbg.de/odbg110.zip
RGN Generator v1.01 RGNCreator_demo.zip
Table Extractor v1.34 inclus dans ce Zip
uFMOD inclus dans ce Zip
Extras:
M$ Platform SDK Kit de développement logiciel (SDK) pour Windows 11
H2 Viewer v1.3.5.0 http://helpware.net/downloads/H2Viewer135.zip
WinAsm MSDN h2help add-in* https://winasm.org
Winspector v1.0b build 35 Winspector_setupU.exe
SignFinder by Asterix inclus dans ce Zip

Veuillez noter que les liens ci-dessus vous donneront accès à différents outils, qui au moment où je rédige ce tutoriel sont encore fonctionnels, mais plusieurs d'entre eux sont susceptibles d'être souvent mis à jour.

Donc soyez prêt à faire des recherches sur Google si certains liens sont HS.
Le symbole ( * ) Indique que les mises à jour du forum 'WinAsm' exigent que vous soyez enregistré.

Je vous ai donc inclus un fichier qui regroupe tous les utilitaires.ici.
 


Introduction

Objectifs de cette série de tutoriels

La plupart voire la totalité des hackers, crackers et reversers aguerris savent également programmer dans un ou plusieurs langages.
Il est hélas quasimement impossible de suivre convenablement et d'apprendre le RE (Reverse Engineering), sans avoir un minimum de connaissance en programmation ASM.

D'ailleurs à ce sujet, les plus anciens se rappèleront probablement, que la majorité des tutoriels de l'époque sur l'apprentissage du cracking, était rédigée au format 'TXT', ça disait, je cite : "Avant de commencer et d'aller plus loin, je vous conseille fortement d'apprendre les bases de l'assembleur, et de revenir ensuite lire ce tutoriel..."

C'est encore plus vrai aujourd'hui que jamais, car beaucoup d'exécutables utilisent de nos jours des packers afin d'être mieux protégés du reverseur. Dautant que les protections sont de plus en plus complexes à analyser avec différentes méthodes d'approche sur l'unpacking, le déboguage et la reconstruction de l'IAT (Import Address Table) d'un programme.

Cette évolution permanente a fini par motiver des groupes (TEAM) de la scène RE à se coder des outils personnalisés, en se penchant de plus près sur le sujet avec leur débogueur, désassembleur et outils comme 'ImpREC'.
C'est ce qui a conduit à l'arrivée des loaders, qui sont d'ailleurs de plus en plus populaires.

Tout cela est le résultat de l'excellent travail accompli en cracking sur la série des loaders d'ARTeam. Ils ne sont cependant pas si faciles que ça à comprendre pour les débutants sans aucune connaissances en programmation assembleur.

En fait j'ai rédigé ce tutoriel dans l'objectif de combler le manque de connaissance du débutant, et ainsi faire un cours sur l'évolution des loaders, traceurs,… de même que sur les applications console(DOS).

Mais aussi pour montrer comment fonctionnent ces outils et surtout comment les utiliser. Le deuxième objectif était d'illustrer qu'il peut finalement être facile de créer des applications GUI(fenêtre) en assembleur (ASM).

C'est grâce à cet état d'esprit et le sens du partage, de reversers venant de différentes communautés de la programmation en assembleur, que j'ai pu adapter et réutiliser leur code provenant d'une grande variété de sources.

Par ailleurs, il va de soit que vous n'oublierez pas bien sûr de les remercier comme il se doit, lorsque cela vous sera possible, par les "Greetz" habituels que vous intégrerez dans vos futures applications codées grâce à leur aide.

Outils nécessaires

Il y a 4 outils principaux requis:

1. Un assembleur

2. Un IDE ou environnement de développement intégré

3. Un débogueur

4. Une source d'informations concernant la plate-forme (l'OS - WinXP dans mon cas) et son interface de programmation d'application (l'API Win32)

Le choix de l'assembleur et l'IDE est plutôt d'ordre personnel. Car le pack de MASM32 mis à disposition spécifiquement pour coder des applications graphiques pour Windows est assez complet.
L'avantage est que l'on trouve beaucoup plus de soutien et de fichiers sources disponibles sur Internet qui utilisent la syntaxe de MASM .

Bien que je lise souvent des critiques sur les lacunes et la lenteur de MASM par rapport à TASM, je trouve tout de même que la lecture du code dans TASM est beaucoup plus difficile à suivre, et c'est donc bien pour ses raisons que je reste fidèle à MASM.

Je suis favorable à l'utilisation de l'interface WinAsm Studio IDE, parce qu'elle offre d'excellentes fonctionnalités et est très compacte et conçue uniquement pour MASM32 .
Elle ne présente aucun désagrément ni la nécessité, ni l'appui d'autres assembleurs. La structure des répertoires créée par son Assistant de nouveau projet est également plus érgonomique et beaucoup plus simple d'utilisation que celle de RadASM par exemple.

L'annexe 1 contient par ailleurs l'installation et les réglages détaillés de MASM32 et WinAsm, plus quelques conseils pour les personnaliser.

Bien que le choix du débogueur soit également personnel, j'invite tous les débutants à commencer par Olly, car il est très convivial par rapport à SoftIce et dispose en plus de nombreux plugins très utiles.

L'exigence finale aux besoins cités ci-dessus s'obtient soit par l'ancien fichier Win32.hlp, ou soit par les bibliothèques MSDN beaucoup plus à jour et disponibles en ligne par la plate-forme SDK disponible en téléchargement libre sur le site M.i.c.r.o.s.o.f.t.

Toutes les Informations dont vous tirez profit dans ce tutoriel seront réparties en deux catégories principales:

1. MASM32 syntaxe -Comment écrire correctement les instructions en ASM sous MASM.

2. L'architecture Windows et ses API(s) - Toutes les choses dont le reverser a besoin.

Chaque nouveau concept de ces groupes sont mis en évidence en tête de chaque chapitre. Tout le code utilisé dans ces tutoriels est contenu dans des fichiers au format 'TXT', dans la section Code source afin de permettre un simple copié/collé dans WinAsm ou dans l'éditeur de votre choix.
Vous verrez, j'ai mis aussi des captures d'écran de l'éditeur de code WinAsm tout au long des tutoriels, car les couleurs de la syntaxe les rend plus lisibles. Divers autres éléments utilisés pour les projets, ex: (bitmaps, icônes et utilitaires), sont également inclus dans le fichier zip intégré dans ce volume ici. Juste un point à préciser sur le code, je l'ai codé pour WinXP, je n'ai donc fait aucun effort pour assurer la compatibilité pour des versions antérieures de Windows comme Win9x. Certaines des routines (comme par exemple, le truc alphablending dans le chapitre keygen), ne fonctionneront pas sur les anciennes versions de Windows.

Construire un exécutable

Avant de continuer, j'expliquerai brièvement le processus de création d'un exécutable. L'assembleur comprend en fait un package de plusieurs composants basés sur la console, comprend l'assembleur lui-même, un éditeur de liens (Linker), un compilateur de ressources et autres. L'avantage principal quant à l'utilisation d'un IDE, est qu'il alimente automatiquement les instructions de ligne de commande correctes (ce qui peut sembler parfois complexe) à ces composants et vous permet de voir les résultats à partir d'un environnement graphique.

Les instructions du langage assembleur sont saisies dans un simple fichier texte avec l'extension ".asm". L'assembleur traduit les instructions de ce code source en code machine compris par le CPU et convertit les valeurs numériques décimales en binaires. Cela produit alors un fichier objet (.obj) qui contient des instructions machine, des données et des informations nécessaires pour placer correctement les instructions en mémoire lorsque l'application est exécutée.

L'éditeur de liens (Linker) combine les fichiers objets et les fichiers de ressources (voir ci-dessous), pour créer le fichier exécutable final. Le Linker recherche les fichiers objets pour trouver les fonctions externes utilisées et les liens dans les bibliothèques d'importation pour ces fonctions. Le fichier résultant de cette compilation peut alors être exécuté par le système d'exploitation. Lorsque cela se produit, il est mappé en mémoire par le loader Windows, toutes les DLL dont il dépend sont alors chargées et l'instruction à son point d'entrée (Entry Point) est appelée.

1

Resources

Les ressources sont des données stockées dans l'exécutable, notamment les icônes, les chaînes, les menus, les boîtes de dialogue, les bitmaps, les données définies par l'utilisateur, etc. Les ressources d'un programme sont d'abord définies dans un script de ressources (fichier avec l'extension .rc). Il s'agit en fait d'un simple fichier texte qui peut être écrit manuellement ou à l'aide de l'éditeur de ressources visuelles de WinAsm. Les ressources sont ensuite compilées par le compilateur de ressources dans un fichier ressources binaire qui porte l'extension (.res) qui est lié à l'exécutable par le Linker. Les ressources sont accessibles par des numéros d'identification uniques définis dans le script de ressources. Dans le code source asm, les mêmes ID sont utilisés pour ainsi accéder à la ressource.

 


Copyright (C)- xtx Team (2023)

XHTML valide 1.1 CSS Valide !