home *** CD-ROM | disk | FTP | other *** search
/ Programming Win32 Under the API / ProgrammingWin32UnderTheApiPatVillani.iso / pedasm.zip / ExeRep.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-23  |  11.1 KB  |  380 lines
  1. /*        fichier exeRep.h : fichier header
  2.  *
  3.  *    descr : classe qui represente un executable binaire et gere la memoire associee
  4.  *
  5.  *    projet : PEDasm
  6.  *    
  7.  *    rq:
  8.  *    Ce programme est libre de droits. Il peut etre distribue et/ou modifie
  9.  *  selon les termes de la licence 'GNU General Public License version 2'.
  10.  *    
  11.  *    Ce programme est distribue sans aucunes garanties, y compris d'utilite 
  12.  *    ni de risques encouru, quelle que soit son utilisation.
  13.  *
  14.  *    lire le fichier licence.txt fourni ou bien ecrire a :
  15.  *    the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16.  *    pour recevoir une copie de la licence.
  17.  *
  18.  *    Copyright (C) 1997 - 1998 Nicolas Witczak <witczak@geocities.com>
  19.  */
  20.  
  21. #ifndef EXE_REP_H
  22.     #define EXE_REP_H
  23.  
  24. #include <cstdlib>
  25. #include <cstdio>
  26. #include <vector>
  27. #include <set>
  28. #include <map>
  29. #include <string>
  30. #undef va_end
  31. #include "Symbol.h"
  32.  
  33.  
  34.  
  35. class CExeRep ;
  36.  
  37.  
  38. ///////////////////////////////////////////////////////////////
  39. // struct dll_fun represente 1 fct d'une dll 
  40. //: assocition nom , ordinal , existence du nom
  41. struct dll_fun 
  42. {
  43.     const char*    m_pszName ;
  44.     const char*    m_pszDllName ;
  45.     int     m_iOrdinal ;
  46.     bool    m_bHasName ;
  47.  
  48. // fct GetName :retourne le vrai nom ou un nom decore
  49.     const char* GetName()
  50.     {
  51.         static char_buff    m_psztmp ;
  52.         if( m_bHasName )
  53.             return m_pszName ;
  54.         else
  55.             sprintf( m_psztmp , "%s_ord%i"
  56.                 , GetBaseName(m_pszDllName) , m_iOrdinal ); 
  57.         return m_psztmp ;
  58.     };
  59. };
  60.  
  61.  
  62. ///////////////////////////////////////////////////////////////
  63. /** class CSection : represente une section
  64.  */
  65. class CSection
  66. {
  67. public:
  68. // init
  69.     /** ctor : attache une section a sa zone memoire
  70.      * param : idSection : index de section 
  71.      */
  72.     CSection( int idSection ) ;
  73.  
  74. // attributs
  75.     /** index de la section */
  76.     int                        m_idSection ;
  77.  
  78.     /** ptr sur notre header , appartient a la classe CExeRep */
  79.     IMAGE_SECTION_HEADER*    m_pHeader ;
  80.  
  81.     /** donnes de la partie initialisee de cette section , appartient a la classe CExeRep */
  82.     BYTE*                    m_pRawData ;
  83.  
  84.     /** image directory si il y a lieu */
  85.     IMAGE_DATA_DIRECTORY*    m_pImageDir ;
  86.  
  87. // information
  88.     /** size , init_size : retourne taille  */
  89.     unsigned int size()    ;    
  90.     unsigned int init_size();
  91.     
  92.     /** begin end : retourne ptr memoire relle de la section ,fin ,fin initialisee */
  93.     BYTE* begin()    ;    
  94.     BYTE* end();        
  95.     BYTE* init_end();    
  96.  
  97.     /** va_begin va_end va_initend : retourne debut fin, fin initialisee en adr virt de la section */
  98.     unsigned int va_begin()    ;
  99.     unsigned int va_end();    
  100.     unsigned int va_init_end();
  101.  
  102.     /** retourne les flags de section*/
  103.     DWORD GetFlags();
  104.  
  105.     /** IsCode : indique si c'est une section code */
  106.     bool IsCode(); 
  107.     
  108.     /** IsCode : indique si c'est une section de donnee ordinaire */    
  109.     bool IsData();
  110. };
  111.  
  112. //////////////////////////////////////////////////////////////////
  113. /** class CExeRep
  114.  *    descr : representation d'un fichier binaire 
  115.  *    en cours de desassemblage : classe singleton
  116.  */
  117. class CExeRep
  118. {
  119. public:
  120. // donnees fichiers
  121.     /** path de l'exe */
  122.     string                            m_strPath ;
  123.  
  124.     /** nom sans extension */
  125.     string                            m_strBaseName ;
  126.  
  127.     /** fichier de sortie du .asm */
  128.     string                            m_strOutput ;
  129.  
  130.     /** header dos*/
  131.     _IMAGE_DOS_HEADER*                m_pDosHeader ;
  132.  
  133. // gestion du bloc de memoire brut
  134.     /** bloc de memoire contenant tt les sections du prg */
  135.     BYTE*                            m_pRawData ;
  136.  
  137.     /** offset V.A -> ptr memoire */
  138.     unsigned int                    m_vaOffset ;
  139.  
  140. // donnees image PE    decortiquees
  141.     /** signature */
  142.     DWORD                            m_dwNTSign ;
  143.     
  144.     /** header NT */
  145.     _IMAGE_FILE_HEADER*                m_pNTHeader ;
  146.     IMAGE_OPTIONAL_HEADER*            m_pNTOptHeader ;
  147.     
  148.     /** headers des sections */
  149.     vector< IMAGE_SECTION_HEADER* >    m_arSectHeader ;
  150.     
  151.     /** liste des sections  */
  152.     vector< CSection* >                m_arRawSections ;
  153.     
  154.     /** type liste de symbols */
  155.     typedef    set< CSymbol* , symb_less >    CSymbolColl ;
  156.     typedef CSymbolColl::iterator        symb_iterator ;
  157.  
  158.     /**liste des symbols  */
  159.     CSymbolColl                        m_arSymbols ;
  160.  
  161.     /**liste des symbols inutilises */
  162.     CSymbolColl                        m_arUnusedSymbols ;
  163.  
  164.     /** table de relocation 
  165.      *    si l'adresse est ds du code -> rep symbol donnee
  166.      *    si l'adresse est ds des donnees -> rep symbol type pointeur
  167.      */
  168.     CSymbolColl                         m_arRelocSymbols;
  169.  
  170.     /** liste des dll importees
  171.      *    nom dll -> ( ordinal -> nom fonction )
  172.      */
  173.     typedef vector< dll_fun >                                    dllname_coll ;
  174.     typedef dllname_coll::iterator                                dllfun_iterator ;
  175.     typedef map< const char* , dllname_coll , psz_less_nocase >    dll_coll ;
  176.     typedef dll_coll::iterator                                    dll_iterator ;
  177.  
  178.     dll_coll        m_arDll ;
  179.  
  180. public:
  181. // parametrage
  182.     /** m_bRawData : var de config : rajoute les donnees dans le source desassemble */
  183.     bool            m_bRawData;
  184.  
  185.     /** m_bLineNum : ajoute les numero de ligne dans le source desassemble */
  186.     bool            m_bLineNum  ;
  187.  
  188.     /** m_iPassNum : specifie le nombre de passes a effectuer sur le binaire */
  189.     int                m_iPassNum ;
  190.  
  191. // fonctions d'aide
  192.  
  193. // initialisation , destruction
  194.     CExeRep();    
  195.     ~CExeRep();
  196.     
  197.     /** genere les noms de fichiers */
  198.     void SetFileName( const char* pszFileIn , const char* pszFileOut );
  199.  
  200. // etapes de traitement
  201.     /** fct ProcessExe : point d'entree: traite l'executable et produit les sources 
  202.      *        si pszFileOut : nom de sortie par defaut
  203.      */
  204.     void ProcessExe( const char* pszFileIn , const char* pszFileOut = 0 ) ;
  205.  
  206.     /**fct LoadBin : charge un binaire et remplit les donnees brutes 
  207.      *    retourne : etat de success
  208.      */
  209.     bool LoadBin( const char* pszName ) ;
  210.     
  211.     /** fct ScanConfFile : analyse le fichier passe en entree et rajoute les
  212.      *    symbols correspondants dans la table des symbols
  213.      *    format du fichier de config
  214.      *        0xadresse  [ data | funct | ptr ] opt nom
  215.      */
  216.     bool ScanConfFile( FILE* pFile ) ;
  217.  
  218.     /** fct AddDirEntrySymb :marque comme symbols non utiles les zones 
  219.      *        de directory entry inclu dans les differentes sections
  220.      */
  221.     void AddDirEntrySymb() ;
  222.  
  223.     /** AddDllSymb : importe les symboles fct dll d'import
  224.      */
  225.     void AddDllSymb();
  226.  
  227.     /** AddExportSymb : ajoute les symboles exportes ds le binaire 
  228.      *    sert principalement pour les dll
  229.      */
  230.     void AddExportSymb();
  231.  
  232.     /** AddRelocSymb : importe les symboles trouves dans la table de relocation
  233.      *        genere un fichier include des references externes
  234.      */
  235.     void AddRelocSymb();
  236.  
  237.  
  238.     /** AddEntryPoint : ajoute le point d'entree du binaire    
  239.      */
  240.     void AddEntryPoint();
  241.  
  242. // fonctions d'aides
  243.     
  244.     /** fct IsExeBin : retourne true si c'est un exe 0 si c'est une dll */
  245.     bool IsExeBin();
  246.  
  247.     /** fct HasReloc : retourne true si le binaire a une table de relocation */
  248.     bool HasReloc();
  249.  
  250.     /** GetSectFromVA : retourne la section qui contient l'adresse abs 
  251.      *        passee en parametre ou 0 si non trouve
  252.      */
  253.     CSection* GetSectFromVA( unsigned int uAdresse );
  254.     
  255.     /** fct de conversion ptr <-> va <-> rva
  256.      */
  257.     BYTE* CExeRep::rva2ptr( unsigned int uRVA )    
  258.     {    return  m_pRawData + uRVA ; }
  259.  
  260.     BYTE* CExeRep::va2ptr( unsigned int uVA )
  261.     {    return reinterpret_cast< BYTE* >( uVA + m_vaOffset ) ; }
  262.  
  263.     unsigned int CExeRep::ptr2va( BYTE* p ) 
  264.     {    return reinterpret_cast< unsigned int >(p - m_vaOffset); }
  265.  
  266.     unsigned int CExeRep::ptr2rva( BYTE* p ) 
  267.     {    return ( unsigned int )(p - m_pRawData ) ; }
  268.  
  269.     unsigned int CExeRep::rva2va( unsigned int uRVA ) 
  270.     {    return uRVA + m_pNTOptHeader->ImageBase ; }
  271.  
  272. // gestion des dll d'import
  273.  
  274.     /** fct LoadimpDll : charge les symbol (nom ordinal) d'une dll
  275.      */
  276.     bool LoadImpDll(const char* pszName );
  277.  
  278.     /** fct GetNameFromOrd : retourne le nom d'une dll a partir d'un ordinal 
  279.      *    PARAM : pszDllName : nom de la dll
  280.      *            int           : ordinal  
  281.      *            sortie pbNoName : false -> indique qu'un nom n'a pas ete trouve
  282.      *    RETOUR : une chaine temporaire sur le nom de dll ou un nom genere si le nom
  283.      *    n'est pas exporte , retourne 0 en cas d'echec
  284.      */
  285.     const char* GetNameFromOrd( const char* pszDllName ,int iOrdinal,bool* pbHasName );
  286.     
  287.     /**    fct GetOrdFromName : retourne l'ordinal a partir du nom de fct ds une dll
  288.      *    ou -1 en cas d'echec
  289.      */
  290.     int GetOrdFromName( const char* pszDllName , const char* pszFunName );
  291.  
  292. // interface
  293.     /** GetSymbol : retourn un pointeur sur 1 symbol ou 0 si aucuns symbols 
  294.      *    param uVA : adresse absolue 
  295.      */
  296.     CSymbol* GetSymbol( unsigned int uVA );
  297.  
  298.     /** FindSymbol : cherche le prochain symbol satisfaisant au mask
  299.      *        donne par ordre d'adresse croissant a partir de l'adresse uVA incluse
  300.      * retourne 0 si non trouve
  301.      *    rq : DEPRECIE
  302.      */
  303.     CSymbol* FindSymbol( unsigned int uVA , unsigned int uMask );
  304.  
  305.     /** FindSymbol : cherche le 1er symbol disponible
  306.      *        donne par ordre d'adresse croissant a partir de l'adresse uVA incluse
  307.      * retourne 0 si non trouve
  308.      */
  309.     CSymbol* FindSymbol( unsigned int uVA );
  310.  
  311.     /** AddSymbol : appele par le desassembleur pour rajouter ou preciser 
  312.      *    un symbol 
  313.      *    param uVA : adresse de location du symbol
  314.      *        pRefPoint : adresse mem ou a ete reference le symbol     
  315.      *        bTrust : niveau de confiance (ne requiert pas la table de reloc )
  316.      *        SymbolCat : type reconnu
  317.      */
  318.     void AddSymbol( unsigned int uVA,unsigned int uRefVA, bool bTrust , unsigned int SymbolCat   );
  319.  
  320.     /** GetSymbName : retourne le nom d'un symbol a partir de 
  321.      * l'adresse virtuelle uVA ou la valeur si non trouve
  322.      *    PARAM : uVA      : valeur a traduire
  323.      *            refVA : adresse ou a ete trouve ce symbol
  324.      *            bTrust : niveau de confiance (ne requiert pas la table de reloc )
  325.      *            uflags   : format d'affichage
  326.      */
  327.     const char* GetSymbName( unsigned int uVA , unsigned int refVA , bool bTrust , unsigned int uflags ) ;
  328.  
  329.     /** GetValue : retourne la valeur chaine d'une cte
  330.      *        param uVal : valeur a traiter         
  331.      *        iflags : spec de formatage
  332.      */
  333.     const char* GetValue( unsigned int uVal , int uflags ) ;    
  334.  
  335. //    fonction de sorties fichier
  336.     /** genere le commentaire header du fichier asm principale */
  337.     void OutputMainHeader( FILE* pFile );
  338.  
  339.     /** genere le commentaire du header de section pSection
  340.      *    sortie sur le stream pFile
  341.      */
  342.     void OutputSectionHeader( CSection* pSection , FILE* pFile );
  343.  
  344. };
  345.  
  346. /** format d'affichage de valeurs */
  347. const unsigned int cteFmtInteger    = 1 ; // format decimal, hexa sinon
  348. const unsigned int cteFmtSign        = 2 ; // format nbr signe avec sign
  349. const unsigned int cteDecorate        = 4 ; // decore avec ( [] ou offset si besoin ) , pas de decoration sinon
  350. const unsigned int cteDecOffset        = 8 ; // decore avec offset si ==1 , [] sinon
  351.  
  352. /** format de sortie de desassemblage */
  353. const int cteMASM        = 0 ;
  354. const int cteListing    = 1 ;
  355. const int cteInlineC    = 2 ;
  356.  
  357. //////////////////////////////////////////////////////////////////
  358. // fonctions globales
  359.  
  360. /** acces au singleton exe */
  361. extern CExeRep    m_theExe ;
  362. inline CExeRep* GetExe()
  363. {    return &m_theExe ;    }
  364.  
  365. /** GetImageSize : retourne la taille d'un binaire en mem vive */
  366. unsigned int GetImageSize( const char* pszStr );
  367.  
  368. /** indique si un ensemble d'instructions est disponible*/
  369. bool IsBank( const char* pszBankName ) ;
  370.     
  371. /** si bLoad == true : marque comme candidat le groupe de modele d'instructions , 
  372.  * l'enleve sinon 
  373.  */
  374. void LoadBank( const char* pszBankName , bool bLoad ) ;
  375.  
  376. /** Genere la liste des modeles d'instruction utilisees durant la decompilation */
  377. void InitBanks() ;
  378.  
  379.  
  380. #endif //EXE_REP_H