---

code.cpp

Go to the documentation of this file.

/*
PeRdr - PE file disassembler
Copyright (C) 1999-2003 Frediano Ziglio
-----

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-----

INFORMATION
  www: https://freddy77.tripod.com/perdr/
  e-mail: freddy77@angelfire.com
*/
#include "global.h"
#ifdef HAVE_HDRSTOP
#pragma hdrstop
#endif

#include "signfile.hpp"
#include "module.h"
#include "code.h"
#include "codeglob.h"
#include "x86istr.h"
#include "heuristic.h"
#include "codescan.h"
#ifdef DEBUG
#include <cctype>
#endif
#include "utils/f77auto_ptr"

using namespace std;

#ifdef DEBUG
static unsigned long int bytes;           // bytes processati
static unsigned long int jumps;           // salti ancora da processare
static unsigned long int calls;           // chiamate da processare
static unsigned long int loopCount;       // contatore ciclo per non visualizzare
                              // continuamente valori
#endif

void WriteInstruction(const Instruction& instruction,FILE* file)
{
  char buffer[80];
  instruction.Write(buffer);
  fprintf(file,"%s\n",buffer);
}

// verifica se esiste un riferimento a dati o codice
void CodeParser::CheckForAddress(vma_t instAddress,const Instruction& instruction,enum ByteInfo::TPriority priority)
{
  for (int n=0; n < instruction.numArg; ++n)
  {
    const Param *param = &instruction.Args[n];
    switch (param->type)
    {
    case Param::t_literal:
          if (param->GetLiteralSize() != addr_bytes)
          break;
      // testa indirizzo
      if (!ContainValidAddress(*param))
        break;
      // inserisci indirizzo corrente
                  addrGeneral.insert(param->literal);
      break;
    case Param::t_memory:
      // testa indirizzo
      if (!ContainValidAddress(*param))
        break;
      // testa indirizzamento diretto
      if (param->mem_reg1 == null_reg && param->mem_reg2 == null_reg)
      {
        // verifica che la memoria punti effettivamente a qualcosa,
        // altrimenti e' solo un riferimento
        if ( param->GetMemSize() != 0 )
        {
          varReferences.Add(instAddress,param->literal,FLOW_NONE);

          // !!! se priorita' piu alta ?
          if (!byteInfo.IsOccupied(param->literal,param->GetMemSize()))
          {
            ByteInfo& info = byteInfo[param->literal];
            if (info.GetPriority() < priority)
            {
              info.len = param->GetMemSize();
              // !!! not only Integer, can be float or a structure (for save state)
              info.SetType(ByteInfo::typeInteger);
              info.SetPriority(priority);
              info.SetIsLabel();
            }
          }
          break;
        }
      }
      // inserisci indirizzo corrente
                  addrGeneral.insert(param->literal);
      break;
    }
  }
}

// verifica se esiste una costante che punta a del codice
void CodeParser::CheckImmediateCodeAddress(const Instruction& instruction)
{
  vma_t address;
  const Param *param;
  switch(instruction.instruction)
  {
  // solo mov e push dato che il parametro non e' usato per operazioni
  // (presuppongono assegnazione o copia)
  // !!! non portatile
  case istr_mov:
    _PRG_ASSERT(instruction.numArg >= 2);
    _PRG_ASSERT(instruction.Args[1].type != Param::t_literal || instruction.Args[1].GetLiteralSize() != 0);
        param = &instruction.Args[1];
    goto addr_ok;
  case istr_push:
        param = &instruction.Args[0];
  addr_ok:
    // verifica dimensione e
        if ( param->type != Param::t_literal || param->GetLiteralSize() != addr_bytes )
        break;
    address = param->literal;

    // testa codice
    if (!ContainValidAddress(*param))
      break;
    // inserisci indirizzo corrente
                addrConstants.insert(address);
        break;
  }
}

void CodeParser::AddTempFlow(enum FlowTypes flow,vma_t from,vma_t to,
  enum ByteInfo::TPriority priority)
{
  if (flow == FLOW_NONE || flow == FLOW_RET)
    return;

  // non aggiungere se usato solo per check
#ifdef DEBUG
  int inc = (priority == ByteInfo::priCheckOnly)?0:1;
#endif

  TempReference tempRef;
  tempRef.from     = from;
  tempRef.type     = flow;
  tempRef.to       = to;
  tempRef.priority = static_cast<uchar>(priority);

  if (istrReferences.IsPresent(tempRef.from,tempRef.to))
    return;

        switch(flow)
  {
  case FLOW_CALL:
        pTempRefs->push(tempRef);
#ifdef DEBUG
        calls += inc;
#endif
        break;
  case FLOW_CJUMP:
  case FLOW_JUMP:
        pTempRefs->push(tempRef);
#ifdef DEBUG
        jumps += inc;
#endif
        break;
  }
}

// !!! convertire TempRefs in contenitore per poterlo usare con STL ??
bool CodeParser::AddTempFlow(enum FlowTypes flow,vma_t from,
  const Instruction& instruction,vma_t instAddress,
  enum ByteInfo::TPriority priority,bool bAddComplex)
{
  if (flow == FLOW_NONE || flow == FLOW_RET)
    return true;

  const Param &param = instruction.Args[0];
  if (param.type != Param::t_literal)
  {
    // se memoria e solo offset registra indirizzo, vedi se chiamata DLL
    if (param.type == Param::t_memory)
      if (param.mem_reg1 == null_reg && param.mem_reg2 == null_reg)
      {
        if ( ContainValidAddress(param) )
        {
          pair<Symbols::iterator,Symbols::iterator> sym = module->GetSymbols()[param.literal];
          if ( sym.first != sym.second )
          {
            if (flow == FLOW_JUMP)
            {
              apiAlias[from] = param.literal;
            }
            return true; // ok! chiamata/salto a DLL
          }
        }
      }

    // !!! finish
    // se registro scandire indietro e vedere possibili valori
    //   (se costanti o variabili caricate)
    // se memoria del tipo [4*reg+const] provare tabella
    if (bAddComplex && priority != ByteInfo::priCheckOnly)
      complexReference.insert(instAddress);
#if 0
#ifdef DEBUG
    fprintf(stderr,"Debug: (Flow) ");
    WriteInstruction(instruction,stderr);
#endif
#endif
    return false;
  }

  // !!! check relocation ??
  // !!! se codice a 16 bit e chiamata far dovrebbe esserci rilocazione

  AddTempFlow(flow,from,instruction.Args[0].literal,priority);
  return true;
}

void CodeParser::AddExportTempFlow(vma_t to,enum ByteInfo::TPriority priority)
{
  _PRG_ASSERT(pTempRefs != NULL);

  // !!! funzione ??
  if ( istrReferences.beginReferenceTo(to) !=
       istrReferences.endReferenceTo(to) )
    return;

        TempReference tempRef;
  tempRef.from     = 0; // !!!
  tempRef.type     = FLOW_NONE;
  tempRef.to       = to;
  tempRef.priority = static_cast<uchar>(priority);

  pTempRefs->push(tempRef);
}

// Estrae un riferimento dallo stack temporaneo e lo salva definitivamente
bool CodeParser::ExtractTempRef(TempReference& tempRef)
{
        // assicurati che riferimenti sia inizializzato
  _PRG_ASSERT((pTempRefs!=NULL));

        if (pTempRefs->empty())
        return false;

  // estrae elemento
  tempRef = pTempRefs->top();
  pTempRefs->pop();

  // non aggiungere se usato solo per check
  if (tempRef.priority == ByteInfo::priCheckOnly)
    return true;

  // decrementa contatori e aggiungere reference fissi
  switch(tempRef.type)
  {
  case FLOW_CALL:
    istrReferences.Add(tempRef.from,tempRef.to,tempRef.type);
#ifdef DEBUG
        --calls;
#endif
        break;
  case FLOW_CJUMP:
  case FLOW_JUMP:
    istrReferences.Add(tempRef.from,tempRef.to,tempRef.type);
#ifdef DEBUG
        --jumps;
#endif
        break;
  }

  return true;
}

// !!! passare solo param ?? portatile ??
bool CodeParser::IsApiReference(const Param& arg) const
{
  // !!! aggiungere parametro *string e se valido e true settarlo
    if (arg.type == Param::t_memory)
    {
      // !!! function
      if (ContainValidAddress(arg))
                          if (arg.mem_reg1 == null_reg && arg.mem_reg2 == null_reg)
        {
          _PRG_ASSERT(module!=NULL);
          if (module->GetSymbols().IsValid(arg.literal))
            return true;
        }
      return false;
    }
    if (arg.type == Param::t_literal)
    {
      // salti a jmp ad api
      TApiAlias::const_iterator i = apiAlias.find(arg.literal);
                        if (i != apiAlias.end())
      {
        _PRG_ASSERT(module!=NULL);
        if (module->GetSymbols().IsValid((*i).second))
          return true;
      }
//
//      // salti a funzioni esportate
//      _PRG_ASSERT(exportedApi!=NULL);
//      std::string func = (*exportedApi)[arg.literal];
//      if (func != "")
//      {
//        printf("\n* Reference to %s\n|\n",func.c_str());
//      }
    }
  return false;
}

#ifdef DEBUG
static bool printIstr = false;
#endif

// Scandisce il codice iniziando da address
// Si ferma se trova un RET o un JUMP
// Ritorna un codice che ne determina l'errore
// La priorita' serve per settare le informazioni
// address al ritorno contiene l'indirizzo dell'ultima istruzione
//  (valida o no a seconda del risultato)
// bFirst vera se c'e' un'istruzione precedente
// !!! ottimizzare usi di inst_address
enum CodeParser::TScanCodeResult CodeParser::ScanCode(vma_t& address,ByteInfo::TPriority priority,bool bSetLabel)
{
  InstructionDecoder decoder(module->GetRelocationInfos());

  // verifica se la prima istruzione e' sovrapposta
  if ( priority != ByteInfo::priMax && byteInfo.GetIstrLen(address)==0
         && byteInfo.IsOccupied(address) )
  {
    return scanCodeOverlapped;
  }

  bool bFirst = true;
        ObjectModule::DataReader reader = module->GetDataReader(address);
  for(;;)
  {
#ifdef DEBUG
//    fprintf(stderr,"%08lX\t",address);
//    printIstr = (address >= 0x7FAC699Alu);
#endif

    ByteInfo &info = byteInfo[address];

    // !!! a volte e' utile non settare label anche se si analizza
    // setta label iniziale
    if (bFirst && bSetLabel)
      info.SetIsLabel();

    // check se l'istruzione e' gia' stata attraversata
    if ( info.len != 0 && priority <= info.GetPriority() )
    {
      // setta istruzione precedente
      // !!! priorita' per bCheckOnly
      if (!bFirst && priority != ByteInfo::priCheckOnly)
        info.SetIsPrevInstruction();
      if (bFirst)
        return scanCodeAlreadyProcessed;
                        if (info.GetType() != ByteInfo::typeInstruction)
                                return scanCodeInvalid;
        break; // !!! ritornare un valore diverso ??
    }

    // leggi successiva istruzione
    Instruction currInstruction;
    int result = decoder.Decode(currInstruction,reader);

    // !!!
//    if (result == 0 && priority == ByteInfo::priMax)
//      throw std::runtime_error("Unknown code in max priority");

    if (!result)
      return scanCodeInvalid;

#ifdef DEBUG
    if (printIstr)
      WriteInstruction(currInstruction);
#endif

    // non sovraporre a codice gia' esistente
    if ( priority != ByteInfo::priMax && byteInfo.GetIstrLen(address)==0
         && byteInfo.IsOccupied(address+result-1) )
    {
      // !!! sicuro di questo ? non invalidare precedenti ?
      return scanCodeOverlapped;
    }

    // calcola tipo istruzione
    enum FlowTypes flow = currInstruction.GetFlowType();

    // verifica che il salto sia corretto
    // !!! verificare solo che il codice sia esatto ??
    if ( priority <= ByteInfo::priConstant )
      if ( flow == FLOW_JUMP || flow == FLOW_CJUMP || flow == FLOW_CALL )
        if ( currInstruction.Args[0].type == Param::t_literal )
        {
          if (!module->GetSection(currInstruction.Args[0].literal)->IsCode())
            return scanCodeInvalidJump;
        }

    // aggiornamento processo
#ifdef DEBUG
    if ( ((++loopCount) & 0x3f) == 0 )
      fprintf(stderr,"Process: (Code) bytes: %lu calls: %lu jumps: %lu\n",
              bytes,calls,jumps);
#endif

      // aggiunge dati sulla lunghezza
      info.len      = (uchar)result;

      // setta priorita' massima
      if (info.GetPriority() < priority)
      {
          info.SetPriority(priority);
#ifdef DEBUG
        bytes += result;
#endif
      }

      // prima di questa esiste un'istruzione
      if (!bFirst)
        info.SetIsPrevInstruction();

      //bytes += result;

            // aggiungi istruzione di flusso
      // !!! un po' strano, o no ?
      AddTempFlow(flow,address,currInstruction,address,priority);

      // salva costanti che possano puntare al codice
      // !!!
      if (priority != ByteInfo::priCheckOnly)
      {
              CheckImmediateCodeAddress(currInstruction);
        CheckForAddress(address,currInstruction,priority);
      }

    // fermati se salto incondizionale o ritorno
    if (flow == FLOW_JUMP || flow == FLOW_RET)
    {
       break;
    }

    // va avanti
    address += result;
    bFirst = false;
  }
  return scanCodeNoError;
}

void CodeParser::ResetCodeRange(const range<vma_t>& r)
{
  for(vma_t address = r.begin;;)
  {
    _PRG_ASSERT(address <= r.end);
    ByteInfo& info = byteInfo[address];
    _PRG_ASSERT(info.len != 0 || address == r.end);
    _PRG_ASSERT(info.GetPriority() == ByteInfo::priCheckOnly || address == r.end);
    int len = info.len;
    if (info.GetPriority() == ByteInfo::priCheckOnly)
    {
      // se errore leva marcatura
      info.Reset();
    }
    if (address == r.end)
      break;
    address += len;
  }
}

void CodeParser::SetCodeRange(const range<vma_t>& r,ByteInfo::TPriority priority,bool bSetLabel)
{
  vma_t begin = r.begin;
#ifdef DEBUG
  // TScanCodeResult res =
#endif
  ScanCode(begin,priority,bSetLabel);

  // !!! per procedure che non ritornano puo' accadere un errore
  //_PRG_ASSERT(res <= scanCodeNoError);
  // !!! si processano prima export e poi heuristic,
  // ma priorita heuristic > priorita export
  //_PRG_ASSERT(begin == (*i).end);
}

// verifica il codice usando ScanCode
// address alla fine punta all'ultimo codice corretto
// !!! questo codice dovrebbe essere usato solo per la scansione di filler
// !!! in quanto non gestisce i salti dentro al codice scandito
bool CodeParser::CheckCode(vma_t& address,ByteInfo::TPriority priority,bool bSetLabel)
{
  _PRG_ASSERT(pTempRefs->size() == 0);
  TScanCodeResult lastResult = scanCodeNoError;

  // testa se il codice e' corretto
  vma_t start = address;
  vma_t scanAddress;
  try
  {
    scanAddress = start;
    lastResult = ScanCode(scanAddress,ByteInfo::priCheckOnly,bSetLabel);
  }
  catch(const ObjectModule::OutOfAddress&)
  {
    lastResult = scanCodeInvalid;
  }
  for (TempReference tempRef;ExtractTempRef(tempRef););

  // setta o resetta codice
  if (lastResult <= scanCodeNoError)
    SetCodeRange(range<vma_t>(start,scanAddress),priority,bSetLabel);
  else
    ResetCodeRange(range<vma_t>(start,scanAddress));
  {for (TempReference tempRef;ExtractTempRef(tempRef););}

  address = scanAddress;

  return (lastResult <= scanCodeNoError);
}

//class CodeCheck
//{
//public:
//  CodeCheck() {};
//  bool AddCheck(vma_t address,bool bOneLevel=false);
//  void ResetAddress();
//  void SetAddress();
//private:
//  range_set<vma_t> ranges;
//};

// verifica il codice ricorsivamente usando ScanCode
bool CodeParser::CheckCodeRecursively(vma_t address,ByteInfo::TPriority priority,bool _bSetLabel)
{
  _PRG_ASSERT(pTempRefs->size() == 0);

  // insieme di codice scannato
  range_set<vma_t> ranges;
  // handle one instruction (jmp/ret) process
  TAddresses addresses;
  TScanCodeResult lastResult = scanCodeNoError;
  bool bSetLabel = _bSetLabel;

  // scandisci a partire dall'entry
  AddExportTempFlow(address,ByteInfo::priCheckOnly);
  for (;;)
  {
    TempReference tempRef;
    if (!ExtractTempRef(tempRef))
      break;

    // scandisci il codice
    vma_t address = tempRef.to;
    try
    {
      lastResult = ScanCode(address,ByteInfo::priCheckOnly,bSetLabel);
    }
    catch(const ObjectModule::OutOfAddress&)
    {
      lastResult = scanCodeInvalid;
    }

    // solo al primo non marcare label
    bSetLabel = true;

    // marca il codice scandito
    _PRG_ASSERT(tempRef.to <= address);
    if ( tempRef.to == address)
      addresses.insert(tempRef.to);
    else
      ranges.insert(range<vma_t>(tempRef.to,address));

    // se errore fermati
    if (lastResult > scanCodeNoError)
      break;
  }

  // scandisce tutti i range possibili
  {
  typedef range_set<vma_t>::iterator iterator;
  iterator i   = ranges.begin();
  iterator end = ranges.end();
  for(;i!=end;++i)
  {
    if (lastResult <= scanCodeNoError)
      SetCodeRange(*i,priority,_bSetLabel || (*i).begin != address);
    else
      // !!! se il codice e' scandito con successo setta priorita' anche
      // nella cella end. Non inserisce inst_offset+1 in ranges altrimenti
      // se e' un ret ScanCode successivo si ferma a meta' range
      ResetCodeRange(*i);
  }
  }

  // scandisce tutti gli indirizzi possibili
  {
  typedef TAddresses::iterator iterator;
  iterator i   = addresses.begin();
  iterator end = addresses.end();
  for(;i!=end;++i)
  {
    if (lastResult <= scanCodeNoError)
      SetCodeRange(range<vma_t>(*i,*i),priority,_bSetLabel || (*i) != address);
    else
      // !!! se il codice e' scandito con successo setta priorita' anche
      // nella cella end. Non inserisce inst_offset+1 in ranges altrimenti
      // se e' un ret ScanCode successivo si ferma a meta' range
      ResetCodeRange(range<vma_t>(*i,*i));
  }
  }

  // estrae tutti i reference temporanei
  for (TempReference tempRef;ExtractTempRef(tempRef););

  return (lastResult <= scanCodeNoError);
}

int GetInstruction(ObjectModule& module,vma_t address,Instruction& instruction)
{
  // legge l'istruzione
  InstructionDecoder decoder(module.GetRelocationInfos());
        ObjectModule::DataReader reader = module.GetDataReader(address);
  return decoder.Decode(instruction,reader);
}

void CodeParser::ExcludeFileRange(CSignFile& _file,const RVAFileTranslator& rva,uint32_t imageBase)
{
  range_set<long> excludeRange = _file.GetRanges();
  range_set<long>::iterator i   = excludeRange.begin();
  range_set<long>::iterator end = excludeRange.end();
  for( ;i!= end; ++i)
  {
    // !!! troppo dipendente da formato Pe
    vma_t start;
    vma_t finish;
    try
    {
      start  = rva.File2RVASafe((*i).begin) + imageBase;
      finish = rva.File2RVASafe((*i).end-1) + imageBase;
    }
    catch(std::runtime_error&)
    { continue; }

//    _DEBUG_(fprintf(stderr,"start: %08lX end: %08lX\n",start,finish));

    range<long> r = *i;

    // !!! bug finire
    // testa per piu' sezioni
    while( (finish-start+1) != static_cast<unsigned long>(r.end - r.begin) )
    {
      // trova prima sezione
      const PeSection *p;
      for(unsigned n=0;; ++n)
      {
        p = rva.GetSection(n);
        if (p == NULL)
        {
          throw runtime_error("I think there is a bug inside");
        }
        if ((unsigned long)r.begin >= p->RawAddress && ((unsigned long)r.begin-p->RawAddress) < p->RawSize)
        {
          // elimina questa sezione
          ByteInfo& info = byteInfo[start];
          info.SetPriority(ByteInfo::priMax);
          info.SetType(ByteInfo::typeLoader);
          // setta la lunghezza lunga
//          _DEBUG_(fprintf(stderr,"len setted: %lX\n",p->RawSize - (r.begin-p->RawAddress)));
          byteInfo.SetLen(start,p->RawSize - (r.begin-p->RawAddress) );

          // vai alla prossima sezione
          r.begin = p->RawAddress+p->RawSize;
          start = rva.File2RVASafe(r.begin) + imageBase;
          break;
        }
      }
    }

    // setta informazioni
    ByteInfo& info = byteInfo[start];
    info.SetPriority(ByteInfo::priMax);
    info.SetType(ByteInfo::typeLoader);
    // setta la lunghezza lunga
//    _DEBUG_(fprintf(stderr,"len setted: %lX\n",finish-start+1));
    byteInfo.SetLen(start,finish-start+1);
  }
}

// imageBase, entryPoint, api, exportedApi servono solo per inizializzazioni
void CodeParser::Parse(CSignFile& _file,uint32_t imageBase,vma_t _entryPoint,
  const RVAFileTranslator& rva,const Symbols& _symbols,const Symbols& _exportedSymbols,
  bool hasRelocation,const RelocationInfos& relocationInfos)
{
//  istrReferences.insert(IstrReference(10,20,true,FLOW_CALL));
//  istrReferences.insert(IstrReference(10,20,false,FLOW_CALL));
//  if ( !(*istrReferences.begin()).direct )
//    printf("0\n");
//  istrReferences.insert(IstrReference(11,20,true,FLOW_CALL));
//  if (istrReferences.lower_bound(IstrReference(10,0)) ==
//      istrReferences.lower_bound(IstrReference(11,0)))
//    printf("1\n");
//  if (istrReferences.lower_bound(IstrReference(9,0)) !=
//      istrReferences.lower_bound(IstrReference(10,0)))
//    printf("2\n");
//  if (istrReferences.lower_bound(IstrReference(11,0)) ==
//      istrReferences.lower_bound(IstrReference(12,0)))
//    printf("3\n");
//  if (istrReferences.lower_bound(IstrReference(12,0)) !=
//      istrReferences.lower_bound(IstrReference(13,0)))
//    printf("4\n");
//  if (istrReferences.lower_bound(IstrReference(12,0)) !=
//      istrReferences.end())
//    printf("5\n");
//  if (!IsPresent(istrReferences,IstrReference(10,20)))
//    printf("6\n");

#ifdef DEBUG
  unsigned maxStringInCode = 0;
  unsigned currStringLen = 0;
  unsigned istrCount[num_instructions];
  memset(&istrCount,0,sizeof(istrCount));
#endif

  // escludi bytes letti da file
  ExcludeFileRange(_file,rva,imageBase);

  ObjectModule _module(_file,rva,imageBase,hasRelocation,relocationInfos,
                _symbols,_exportedSymbols,_entryPoint);
  // !!! creare interno classe
  this->module = &_module;

        vma_t end;

  // verifica che ci sia qualcosa da disassemblare
  int numCodeSections = 0;
  FOR_EACH_SECTION_CODE_BEGIN(module,p)
    if ( (*p).IsCode() )
      ++numCodeSections;
  FOR_EACH_SECTION_CODE_END(module,p)
  if (numCodeSections == 0)
    return;

#ifdef DEBUG
  bytes = 0;
  bytes = jumps = calls = 0;
  loopCount = 0;
#endif
  pTempRefs = new TTempRefs;

  // prima scansione, entrypoint ed Export
  // !!! solo se punta a codice
  for(vma_t address = module->GetExportSymbols().GetNextValid(0); !IsNullAddress(address); address = module->GetExportSymbols().GetNextValid(address))
    if (module->GetSection(address)->IsCode())
    {
      // scandisce testando (elimina export a dati)
      CheckCodeRecursively(address,ByteInfo::priExport);
    }
  if (!IsNullAddress(module->GetEntryPoint()))
          AddExportTempFlow(module->GetEntryPoint(),ByteInfo::priEntryPoint);

  bool bProcessed = false;  // processato del codice ?
  // ha scandito altro codice dal controllo dei reference??
  bool bFlowChangedSinceReference = false;
  // ha scandito altro codice dal controllo api??
  bool bFlowChangedSinceApi       = false;
  // c'e' qualcosa di incognito (reference, api) ?
  bool bSomeUnknown               = false;
  bool bUseConstantPrinted        = false;

  freddy77::auto_delete_ptr<THeuristicMotor> heuristics;


  // esegui finche' c'e' qualcos'altro da fare
  for(;;)
  {
    // !!! se processati heuristico o costanti i reference sono gia' eliminati,
    // non riprocessa jump complessi e API
    // scandisci codici da salti/chiamate incontrate
//    bProcessed = false;
    for(;;)
    {
      // estrae un reference
      TempReference tempRef;
      if (!ExtractTempRef(tempRef))
        break;

      // processa reference
      vma_t address = tempRef.to;

      if (ScanCode(address,static_cast<ByteInfo::TPriority>(tempRef.priority)) !=
          scanCodeAlreadyProcessed && address != tempRef.to)
//                      if (CheckCode(address,static_cast<ByteInfo::TPriority>(tempRef.priority)) && address != tempRef.to)
        bProcessed = true;
    }

    // se processato forza riscansione
    if (bProcessed)
    {
      bFlowChangedSinceApi       = true;
      bFlowChangedSinceReference = true;
      bSomeUnknown               = false;
    }

        // cerca di usare chiamate/salti complessi (indirizzo in memoria o registro)
                if (bFlowChangedSinceReference && !bSomeUnknown) for(bProcessed = false;;)
    {
      bFlowChangedSinceReference = false;

        // !!! la dimensione del container puo' variare dentro il loop
        // estrae reference complessi (non leverli dal container??)
      if ( complexReference.empty() )
        break;

#if 0
#ifdef DEBUG
      {
      TTempComplexReference::iterator i = complexReference.begin();
      for(int n=1;i != complexReference.end();++i,++n)
      {
        if ( (n%6) == 1 )
          fprintf(stderr,"Debug: (Complex) ");
        fprintf(stderr,(n%6==0)?"%08lX\n":"%08lX ",unsigned(*i));
      }
      fprintf(stderr,"\n");
      }
#endif
#endif

      // cerca di "eseguire" reference
      TTempComplexReference::iterator i = complexReference.begin();
#ifdef DEBUG
      unsigned numUnknown = 0;
      unsigned numKnown   = 0;
#endif
      for(;i != complexReference.end();++i)
      {
        if (!ExecuteComplexReference(*i))
        {
          // se non riuscito a processare tutti i salti possibili
          // segnalo
          bSomeUnknown = true;
          _DEBUG_(++numUnknown);
        }
        else
        {
          // se trova altri salti da fare aggiungili alla lista
          bProcessed = true;
          _DEBUG_(++numKnown);
        }
      }
#ifdef DEBUG
      if ( (numKnown+numUnknown) != 0 )
        fprintf(stderr,"Debug: (Complex) Perc %f\n",
          float(((double)numKnown*100)/(numKnown+numUnknown)));
#endif

      // se eseguito segna esecuzione e togli
      // !!! no, potrebbe variare il flusso del codice
      break;
    }
    if (bProcessed)
    {
      // !!! fa schifo
      bProcessed = false;
        continue;
    }

    // !!! finish !!!
    // cerca di avere tutte le info per il codice delle chiamate alle api
    // se c'e' gia' qualcosa di sbagliato alla fine ce ne sara' comunque
                if (bFlowChangedSinceApi && !bSomeUnknown) for(bProcessed = false;;)
    {
      bFlowChangedSinceApi = false;
        bSomeUnknown = true; // !!!
        // !!! la dimensione del container puo' variare dentro il loop
        // estrae reference complessi (non leverli dal container??)
      break;

      // cerca di "eseguire" api
/*
      // se trova altri indirizzi codice aggiungili alla lista
        bProcessed = true;

      // se non tolti tutti
        // segnalo
        bSomeUnknown = true;
*/
    }
    if (bProcessed)
    {
      // !!! fa schifo
      bProcessed = false;
        continue;
    }

/*
    // Il programma non e' abbastanza preciso per questo!!
    // non c'e' niente antro da scandire
    // !!! e le costanti puntate dal codice sopra ???
    if (!bSomeUnknown)
    {
#ifdef DEBUG
      {
      unsigned bytes = 0;
      FOR_EACH_SECTION_CODE_BEGIN(module,p)
              vma_t address = (*p).begin;
            end            = (*p).end;
              for(; address<end; )
        {
          int len = byteInfo.GetIstrLen(address);
          if (len != 0)
          {
            bytes += len;
            address += len;
          }
          else
            ++address;
        }
      FOR_EACH_SECTION_CODE_END(module,p)
      unsigned codeSize = 0;
      FOR_EACH_SECTION_CODE_BEGIN(module,p)
        codeSize += (*p).end - (*p).begin;
      FOR_EACH_SECTION_CODE_END(module,p)
      if (codeSize)
        fprintf(stderr,"\"Secure code\" %.1f%%\n",
          float(((double)bytes*100)/codeSize) );
      }
#endif
        break;
    }
*/

    // metodo euristico, migliore degli export
    // !!! solo se non processato tutto, fa un test globale
    if (!&*heuristics)
      heuristics = new THeuristicMotor(*this);
//      heuristics.reset(new THeuristicMotor());
    if ( (bProcessed=heuristics->ProcessSecure(*this)) != false )
      continue;

                if (!bUseConstantPrinted)
    {
#ifdef DEBUG
      {
      unsigned bytes = 0;
      FOR_EACH_SECTION_CODE_BEGIN(module,p)
              vma_t address = (*p).begin;
            end            = (*p).end;
              for(; address<end; )
        {
          int len = byteInfo.GetIstrLen(address);
          if (len != 0)
          {
            bytes += len;
            address += len;
          }
          else
            ++address;
        }
      FOR_EACH_SECTION_CODE_END(module,p)
      unsigned codeSize = 0;
      FOR_EACH_SECTION_CODE_BEGIN(module,p)
        codeSize += (*p).end - (*p).begin;
      FOR_EACH_SECTION_CODE_END(module,p)
      if (codeSize)
        fprintf(stderr,"\"Secure code\" %.1f%%\n",
          float(((double)bytes*100)/codeSize) );
      }
#endif
        // !!! log windows ??
        fprintf(stderr,"Warning: Constant processed\n");
      if (complexReference.empty())
        fprintf(stderr,"Wow: complex reference is empty\n");
      if (addrConstants.empty())
        fprintf(stderr,"Wow: Constants address empty\n");
        bUseConstantPrinted = true;
    }

    // unsafe heuristic code process
// !!! commented for priority reason purpose (less safe than constant??)
//    if ( (bProcessed=heuristics->ProcessUnsecure(*this)) != false )
//      continue;

          // cerca altro codice date le costanti salvate
          // questa e' l'ultima risorsa per riempire i buchi
          // testa prima che il codice sia valido
        for(;;)
          {
      if ( addrConstants.begin() == addrConstants.end() )
        break;

      vma_t address = *addrConstants.begin();
      addrConstants.erase(addrConstants.begin());

      // !!! aggiungere caso per indirizzo a dati non inizializzati

      // prova a vedere se e' una stringa
      unsigned len,printable;
      GetStringStats(address,len,printable);

      // se caratteri stampabili >= 75% assumi stringa
      if ( len >0 && printable>2 && printable*100 > (len-1)*75 )
      {
        ByteInfo& info = byteInfo[address];
        //info.len = len;
        info.SetPriority(ByteInfo::priConstant);
        info.SetType(ByteInfo::typeASCIIZ);
        // setta la lunghezza lunga
        byteInfo.SetLen(address,len);
        continue;
      }

      // prova a vedere se array di puntatori
      PointerArrayStat pStat;
      GetPointerArrayStats(address,pStat);
      // piu' di due puntatori non nulli, assumi array puntatori
      if ( pStat.nFirstNull >= 2 ) // !!! constant
      {
        // testa se puntatori a codice
        // !!! module non ammette Seek al byte subito dopo end
        if (pStat.nCodePointer >= pStat.nFirstNull)
        {
          for(unsigned n=0; n<pStat.nPointer;++n,address+=addr_bytes)
          {
            // marca come DWORD
            ByteInfo& info = byteInfo[address];
            info.len = addr_bytes;
            info.SetType(ByteInfo::typePointer);
            info.SetPriority(ByteInfo::priConstant);

            // "esegui" puntatore
                                                ObjectModule::DataReader reader = module->GetDataReader(address);
            vma_t addr = reader.ReadDword();
            if (IsNullAddress(addr)) // fermarsi a ptr nullo
            {
              // fermati al primo indirizzo non al codice
              if (!module->GetSection(addr)->IsCode())
                break;
              // !!! prima dovrebbe testarli tutti
              if (CheckCodeRecursively(addr,ByteInfo::priConstant))
                bProcessed = true;
            }
          }
        }
        continue;
      }

      // !!! aggiungere parte check bit & range
      //BitStat bitStat;
      //GetBitStat(address,16*11,bitStat);

      // !!! assume sia codice
      if (module->GetSection(address)->IsCode())
        if (CheckCodeRecursively(address,ByteInfo::priConstant))
        {
          bProcessed = true;
        }
          }

          if (bProcessed)
                continue;

    _PRG_ASSERT(pTempRefs->empty());
    _PRG_ASSERT(addrConstants.empty());

          // !!! testa istruzioni sovrapposte
    // !!! test overlapped instruction

    break;
  }

  // scandisce tutto il codice alla ricerca di codice non decompilato
  // salta bytes tutti a 0
  // scan all code for undisassembled code
  // skip zeroes bytes
  FOR_EACH_SECTION_CODE_BEGIN(module,p)
    vma_t address = (*p).begin;
    end            = (*p).end;
    for(; address<end; )
    {
                        ObjectModule::DataReader reader = module->GetDataReader(address);

      int len = byteInfo.GetIstrLen(address);

      // se gia' passato salta istruzione
            if (len != 0)
      {
#ifdef DEBUG
                                // capture some statistics on code
        // parse instruction
            Instruction currInstruction;
        int result = GetInstruction(*module,address,currInstruction);
        if (result)
        {
          _PRG_ASSERT(currInstruction.instruction>=0);
          _PRG_ASSERT(currInstruction.instruction<=num_instructions);
          ++istrCount[currInstruction.instruction];
                                        ObjectModule::DataReader reader = module->GetDataReader(address);
          for (int i=0;i<len;++i)
          {
            int c = reader.ReadByte();
            if (isprint(c))
            {
              ++currStringLen;
              if ( currStringLen > maxStringInCode )
              {
                maxStringInCode = currStringLen;
              }
            }
            else
              currStringLen = 0;
          }

        }
#endif
                address += len;
          continue;
          }
      _DEBUG_(currStringLen = 0);

                        // if relocation it must be a pointer to somewhere
                        const Relocation *rel = 
                                module->GetRelocationInfos().GetRelocation(address,addr_bytes);
                        if (rel && rel != &RelocationInfos::relError)
                        {
                                ByteInfo& info = byteInfo[address];
                                info.len = addr_bytes;
                                info.SetType(ByteInfo::typeInteger);
                                info.SetPriority(ByteInfo::priFiller);

                                address += addr_bytes;
                                continue;
                        }
                        
            // read next byte
          int c;
                        try {
                c = reader.ReadByte();
                        }
                        catch (ObjectModule::OutOfAddress&)
                        {
          return; // !!!
                        }

      // se 0 leggi fino a che sono zeri o istruzione occupata
                        _PRG_ASSERT(len ==0);
            if ( c==0 )
          {
        _DEBUG_(currStringLen = 0);
        do
              {
                                        try {
                                c = reader.ReadByte();
                                        }
                                        catch (ObjectModule::OutOfAddress&)
                                        {
                        c = -1;
                                        }
                  len = byteInfo.GetIstrLen(++address);
            } while ( c==0 && len==0 
                                                                && !module->GetRelocationInfos().GetRelocation(address) 
                                                                && address<end );
        continue;
      }

          // tutto ok , posso scandire il codice da qui
      vma_t checkAddr = address;
      if ( !CheckCode(checkAddr,ByteInfo::priFiller) )
      {
                                // try on next byte
                                // skipping all code that seam valid 
                                // (doing address = checkAddr+1) can skip relocation
                                ++address;
      }

        // se trova qualcosa di meglio da scandire ben venga
      // !!! non serve cercare la logica nell'illogico
    }
  FOR_EACH_SECTION_CODE_END(module,p)

  // estrae tutti i reference temporanei
  for (TempReference tempRef;ExtractTempRef(tempRef););

#ifdef DEBUG
  fprintf(stderr,"Stat: (Code) MaxStringLenInCode: %u\n",maxStringInCode);
  for (unsigned ni=0; ni<num_instructions; ++ni)
    if (istrCount[ni])
      fprintf(stderr,"Stat: (Instr) %s: %u\n",
        x86instructions_names[ni],istrCount[ni]);
#endif

  WriteCode();

  // mettere nel distruttore !!!
  delete pTempRefs;
  pTempRefs = NULL;
  // !!!
  this->module = NULL;
}

void ParseCode(CSignFile& file,uint32_t imageBase,vma_t entryPoint,const RVAFileTranslator& rva,const Symbols& symbols,const Symbols& exportedSymbols,bool hasRelocation,const RelocationInfos& relocationInfos)
{
  CodeParser* p = new CodeParser;
  p->Parse(file,imageBase,entryPoint,rva,symbols,exportedSymbols,hasRelocation,relocationInfos);
  delete p;
}

// vim:tabstop=2:mouse=a:

---