Mensajes

[Selecionando texto]

Gracias


Selecionando texto, si se hacerlo y veo los codigos, pero pegar codigo directamente como se hace?

Solucionado, donde pone "Código GeShi"  cuando pegamos código selecionamos otro codigo.

 

Código [Seleccionar] Expandir

var filePath = string.Empty;

           saveFileDialog1.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*";  
           saveFileDialog1.FilterIndex = 2;
           saveFileDialog1.RestoreDirectory = true;

           if (  _ = saveFileDialog1.ShowDialog() == DialogResult.OK) {


               filePath = saveFileDialog1.FileName;


              Testamento.............................


           }

Aca comparto una opcion de como guardar una imagen: https://www.youtube.com/watch?v=lQl54poTQH4&t=1s

Seguramente te muestra el índice de la BD como un registro

Muy buen aporte

https://www.supportrix.com/kb/how-to-install-unsigned-drivers-in-windows-10/



Espero te sirva..

[Estructuras PE Windows]

Estructuras PE  Windows

Código (cpp) [Seleccionar] Expandir


using System;
using System.Collections.Generic;
using System.Linq;
public class PE_Formato
{
   
   public static string[] IMAGE_DOS_HEADER_64(string[] DosHeader)

   { // 64 bytes

       string[] Retorno = new string[19];

       Retorno[0] = "e_magic, Firma MZ" + ";" + TotalConversor.HextoStringASCII(DosHeader[0] + DosHeader[1]);

       Retorno[1] = "e_cblp, Bytes Codigo Ultima Pagina" + ";" + TotalConversor.ConVertBaseDecimal( DosHeader[3] + DosHeader[2],16); ;

       Retorno[2] = "e_cp, paginas en archivo" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[5] + DosHeader[4], 16); ;

       Retorno[3] = "e_crlc, reubicación" + ";" + DosHeader[7] + DosHeader[6];

       Retorno[4] = "e_cparhdr, Tamaño del encabezado en  párrafos" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[9] + DosHeader[8], 16);  // paragraphs (16 byte chunks)

       Retorno[5] = "e_minalloc, Mínimos párrafos adicionales necesarios" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[11] + DosHeader[10], 16);

       Retorno[6] = "e_maxalloc, Máximo de párrafos adicionales necesarios" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[13] + DosHeader[12], 16);

       Retorno[7] = "e_ss, Valor inicial (relativo) SS" + ";" + DosHeader[15] + DosHeader[14];

       Retorno[8] = "e_sp, Valor inicial del SP" + ";" + DosHeader[17] + DosHeader[16];

       Retorno[9] = "e_csum, Checksum" + ";" + DosHeader[18] + DosHeader[19];  //++

       Retorno[10] = "e_ip, Valor IP inicial" + ";" + DosHeader[21] + DosHeader[20];

       Retorno[11] = "e_cs, Valor inicial (relativo) CS" + ";" + DosHeader[23] + DosHeader[22];

       Retorno[12] = "e_lfarlc, Dirección de archivo de la tabla de reubicación INICIO STUB??" + ";" + DosHeader[25] + DosHeader[24];

       Retorno[13] = "e_ovno, Número de superposición" + ";" + DosHeader[27] + DosHeader[26];

       Retorno[14] = "e_res[4]" + ";" + DosHeader[29] + DosHeader[28]; //  34-35

       Retorno[15] = "e_oemid, OEM identificador (para e_oeminfo)" + ";" + DosHeader[37] + DosHeader[36];

       Retorno[16] = "e_oeminfo,  OEM información específico e_oemid " + ";" + DosHeader[39] + DosHeader[38];

       Retorno[17] = "e_res2[10]" + ";" + DosHeader[41] + DosHeader[40];  // 58-59

       Retorno[18] = "Puntero Encabezado PE RVA" + ";" + DosHeader[63] + DosHeader[62] + DosHeader[61] + DosHeader[60];
     

       return Retorno;
   }

   public static string[] IMAGE_FILE_HEADER_24(string[] FileHeader)
   { //

       string[] Retorno = new string[8];

       Retorno[0] = "Signature, firma del archivo en este caso PE00 PE 90 0" + ";" + TotalConversor.HextoStringASCII(FileHeader[0] + FileHeader[1] + FileHeader[2] + FileHeader[3]);

       Retorno[1] = "Machine, Procesador Arquitectura 014C–X86-32 8664-X86-64  0000–todos 0200-IA64" + ";" + FileHeader[5] + FileHeader[4]; //++

       Retorno[2] = "NumberOfSections, Número de secciones" + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[7] + FileHeader[6], 16);

       Retorno[3] = "TimeDateStamp, Los 32 bits bajos del número de segundos desde las 00:00 del 1 de enero de 1970" + ";" + TotalConversor.ConvertExaFechaEsamblado(FileHeader[11] + FileHeader[10] + FileHeader[9] + FileHeader[8]); //++

       Retorno[4] = "PointerToSymbolTable, Pointer A la tabla de símbolos  OBSOLETO IMG 00000000 RVA" + ";" + FileHeader[15] + FileHeader[14] + FileHeader[13] + FileHeader[12];

       Retorno[5] = "NumberOfSymbols, Número de símbolos OBSOLETO IMG 00000000" + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[19] + FileHeader[18]+ FileHeader[17] + FileHeader[16], 16);

       Retorno[6] = "SizeOfOptionalHeader, Tamaño del encabezado opcional  Para archivo de imagen " + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[21] + FileHeader[20], 16);

       Retorno[7] = "Characteristics, Características  ****" + ";" + FileHeader[23] + FileHeader[22]; //++


      return Retorno;
   }  /* TOTAL 24 BYTES */

   public static string[] IMAGE_OPTIONAL_HEADER64_112(string[] OpHeader)
   {
       string[] Retorno = new string[29];

       Retorno[0] = "Magic, 010B -32  020B -64   0107 -ROM  0000 -dual" + ";" + OpHeader[1] + OpHeader[0];

       Retorno[1] = "MajorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[2],16);

       Retorno[2] = "MinorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[3],16);

       Retorno[3] = "SizeOfCode, tamaño del codigo maquina en todas las secciones" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[7] + OpHeader[6] + OpHeader[5] + OpHeader[4],16);

       Retorno[4] = "SizeOfInitializedData, tamaño de la sección de datos iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[11] + OpHeader[10] + OpHeader[9] + OpHeader[8],16);

       Retorno[5] = "SizeOfUninitializedData, tamaño de la sección de datos no iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[15] + OpHeader[14] + OpHeader[13] + OpHeader[12],16);

       Retorno[6] = "AddressOfEntryPoint, dirección de la primera instrucion que se ejecuta en memoria RVA" + ";" + OpHeader[19] + OpHeader[18] + OpHeader[17] + OpHeader[16];

       Retorno[7] = "BaseOfCode,dirección relativa de la base del código RVA" + ";" + OpHeader[23] + OpHeader[22] + OpHeader[21] + OpHeader[20];

       Retorno[8] = "ImageBase,dirección base preferida RVAbp" + ";" + OpHeader[31] + OpHeader[30] + OpHeader[29] + OpHeader[28] + OpHeader[27] + OpHeader[26] + OpHeader[25] + OpHeader[24];

       Retorno[9] = "SectionAlignment, alineación de las secciones >= a FileAlignment Pagina32-4096bytes" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[35] + OpHeader[34] + OpHeader[33] + OpHeader[32],16);

       Retorno[10] = "FileAlignment,factor de alineación 512Bytes-64K potencias de 2" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[39] + OpHeader[38] + OpHeader[37] + OpHeader[36],16);

       Retorno[11] = "MajorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[41] + OpHeader[40],16);

       Retorno[12] = "MinorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[43] + OpHeader[42],16);

       Retorno[13] = "MajorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[45] + OpHeader[44],16);

       Retorno[14] = "MinorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[47] + OpHeader[46],16);

       Retorno[15] = "MajorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[49] + OpHeader[48],16);

       Retorno[16] = "MinorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[51] + OpHeader[50],16);

       Retorno[17] = "Win32VersionValue," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[52] + OpHeader[53] + OpHeader[54] + OpHeader[55],16);

       Retorno[18] = "SizeOfImage,un múltiplo de SectionAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[59] + OpHeader[58] + OpHeader[57] + OpHeader[56],16);

       Retorno[19] = "SizeOfHeaders,tamaño de todos los encabezados redondeado a un múltiplo de FileAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[63] + OpHeader[62] + OpHeader[61] + OpHeader[60],16);

       Retorno[20] = "CheckSum,algoritmo utilizado se toma de la librería IMAGEHELP.DLL" + ";" + OpHeader[67] + OpHeader[66] + OpHeader[65] + OpHeader[64]; //++

       Retorno[21] = "Subsystem, tipo de subsistema necesario" + ";" + OpHeader[69] + OpHeader[68];

       Retorno[22] = "DllCharacteristics, punto de entrada para las DLL" + ";" + OpHeader[71] + OpHeader[70];

       Retorno[23] = "SizeOfStackReserve, tamaño que se debe reservar en la pila" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[79] + OpHeader[78] + OpHeader[77] + OpHeader[76] + OpHeader[75] + OpHeader[74] + OpHeader[73] + OpHeader[72],16);

       Retorno[24] = "SizeOfStackCommit, Tamaño utilizado por la pila en men" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[87] + OpHeader[86] + OpHeader[85] + OpHeader[84] + OpHeader[83] + OpHeader[82] + OpHeader[81] + OpHeader[80],16);

       Retorno[25] = "SizeOfHeapReserve, tamaño reservado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[95] + OpHeader[94] + OpHeader[93] + OpHeader[92] + OpHeader[91] + OpHeader[90] + OpHeader[89] + OpHeader[88],16);

       Retorno[26] = "SizeOfHeapCommit, tamaño utilizado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[103] + OpHeader[102] + OpHeader[101] + OpHeader[100] + OpHeader[99] + OpHeader[98] + OpHeader[97] + OpHeader[96],16);

       Retorno[27] = "LoaderFlags, tamaño de los loaderFlags. Su valor es reservado y siempre es cero." + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[107] + OpHeader[106] + OpHeader[105] + OpHeader[104], 16);

       Retorno[28] = "NumberOfRvaAndSizes, Cantidad de DataDirectory" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[111] + OpHeader[110] + OpHeader[109] + OpHeader[108],16);

       return Retorno;
   }    /* TOTAL 112 BYTES */

   public static string[] IMAGE_OPTIONAL_HEADER32_96(string[] OpHeader)
   {
       string[] Retorno = new string[30];

       Retorno[0] = "Magic, 010B -32  020B -64   0107 -ROM  0000 -dual" + ";" + OpHeader[1] + OpHeader[0];

       Retorno[1] = "MajorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[2],16);

       Retorno[2] = "MinorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[3],16);

       Retorno[3] = "SizeOfCode, tamaño del codigo maquina en todas las secciones" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[7] + OpHeader[6] + OpHeader[5] + OpHeader[4], 16);

       Retorno[4] = "SizeOfInitializedData, tamaño de la sección de datos iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[11] + OpHeader[10] + OpHeader[9] + OpHeader[8], 16);

       Retorno[5] = "SizeOfUninitializedData, tamaño de la sección de datos no iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[15] + OpHeader[14] + OpHeader[13] + OpHeader[12], 16);

       Retorno[6] = "AddressOfEntryPoint, dirección de la primera instrucion que se ejecuta en memoria RVA" + ";" + OpHeader[19] + OpHeader[18] + OpHeader[17] + OpHeader[16];

       Retorno[7] = "BaseOfCode,dirección relativa de la base del código RVA" + ";" + OpHeader[23] + OpHeader[22] + OpHeader[21] + OpHeader[20];

       Retorno[8]= "campo+ Base de datos ,La dirección relativa a la base de la imagen de la sección de principio de datos cuando se carga en la memoria RVA" + ";" + OpHeader[27] + OpHeader[26] + OpHeader[25] + OpHeader[24];

       Retorno[9] = "ImageBase,dirección base preferida RVAbp" + ";"  + OpHeader[31] + OpHeader[30] + OpHeader[29] + OpHeader[28];

       Retorno[10] = "SectionAlignment, alineación de las secciones >= a FileAlignment Pagina32-4096bytes" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[35] + OpHeader[34] + OpHeader[33] + OpHeader[32], 16);

       Retorno[11] = "FileAlignment,factor de alineación 512Bytes-64K potencias de 2" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[39] + OpHeader[38] + OpHeader[37] + OpHeader[36], 16);

       Retorno[12] = "MajorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[41] + OpHeader[40],16);

       Retorno[13] = "MinorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[43] + OpHeader[42],16);

       Retorno[14] = "MajorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[45] + OpHeader[44],16);

       Retorno[15] = "MinorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[47] + OpHeader[46],16);

       Retorno[16] = "MajorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[49] + OpHeader[48],16);

       Retorno[17] = "MinorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[51] + OpHeader[50],16);

       Retorno[18] = "Win32VersionValue," + ";" + OpHeader[52] + OpHeader[53] + OpHeader[54] + OpHeader[55];

       Retorno[19] = "SizeOfImage,un múltiplo de SectionAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[59] + OpHeader[58] + OpHeader[57] + OpHeader[56], 16);

       Retorno[20] = "SizeOfHeaders,tamaño de todos los encabezados redondeado a un múltiplo de FileAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[63] + OpHeader[62] + OpHeader[61] + OpHeader[60], 16);

       Retorno[21] = "CheckSum,algoritmo utilizado se toma de la librería IMAGEHELP.DLL" + ";" + OpHeader[64] + OpHeader[65] + OpHeader[66] + OpHeader[67];

       Retorno[22] = "Subsystem, tipo de subsistema necesario" + ";" + OpHeader[68] + OpHeader[69];

       Retorno[23] = "DllCharacteristics, punto de entrada para las DLL" + ";" + OpHeader[71] + OpHeader[70];

       Retorno[24] = "SizeOfStackReserve, tamaño que se debe reservar en la pila" + ";" + TotalConversor.ConVertBaseDecimal( OpHeader[75] + OpHeader[74] + OpHeader[73] + OpHeader[72], 16);

       Retorno[25] = "SizeOfStackCommit, Tamaño utilizado por la pila en men" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[79] + OpHeader[78] + OpHeader[77] + OpHeader[76], 16);

       Retorno[26] = "SizeOfHeapReserve, tamaño reservado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[83] + OpHeader[82] + OpHeader[81] + OpHeader[80], 16);

       Retorno[27] = "SizeOfHeapCommit, tamaño utilizado para la asignación dinámica de memoria" + ";" + TotalConversor.ConVertBaseDecimal( OpHeader[87] + OpHeader[86] + OpHeader[85] + OpHeader[84], 16);

       Retorno[28] = "LoaderFlags, tamaño de los loaderFlags. Su valor es reservado y siempre es cero." + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[91] + OpHeader[90] + OpHeader[89] + OpHeader[88], 16);

       Retorno[29] = "NumberOfRvaAndSizes, Cantidad de DataDirectory" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[95] + OpHeader[94] + OpHeader[93] + OpHeader[92], 16);

       return Retorno;
   }    /* TOTAL 96 BYTES */

   public static string[] IMAGE_SECTION_HEADER_40(string[] SeHeader)
   {
       string[] Retorno = new string[10];

       Retorno[0] = "Name[IMAGE_SIZEOF_SHORT_NAME], 8-byte ANSI name" + ";" + TotalConversor.HextoStringASCII( SeHeader[0] + SeHeader[1] + SeHeader[2] + SeHeader[3] + SeHeader[4] + SeHeader[5] + SeHeader[6] + SeHeader[7]);

       Retorno[1] = "Misc, PhysicalAddress dirección física o VirtualSize tamaño de la sección antes del redondeo" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[11] + SeHeader[10] + SeHeader[9] + SeHeader[8],16);

       Retorno[2] = "VirtualAddress, dirección del primer byte de la sección RVA" + ";" + SeHeader[15] + SeHeader[14] + SeHeader[13] + SeHeader[12];

       Retorno[3] = "SizeOfRawData, tamaño de los datos inicializados" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[19] + SeHeader[18] + SeHeader[17] + SeHeader[16],16);

       Retorno[4] = "PointerToRawData, puntero a la primera pagina RVA" + ";" + SeHeader[23] + SeHeader[22] + SeHeader[21] + SeHeader[20];

       Retorno[5] = "PointerToRelocations, puntero a la primera if reubicación RVA" + ";" + SeHeader[27] + SeHeader[26] + SeHeader[25] + SeHeader[24];

       Retorno[6] = "PointerToLinenumbers, puntero a la primer if numerado RVA" + ";" + SeHeader[31] + SeHeader[30] + SeHeader[29] + SeHeader[28];

       Retorno[7] = "NumberOfRelocations" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[33] + SeHeader[32],16);

       Retorno[8] = "NumberOfLinenumbers" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[35] + SeHeader[34],16);

       Retorno[9] = "Characteristics" + ";" + SeHeader[39] + SeHeader[38] + SeHeader[37] + SeHeader[36]; //++

       return Retorno;
   } // 40 bytes


   public static string[] IMAGE_DATA_DIRECTORY_8(string[] DiHeader)
   {
       string[] Retorno = new string[2];

       Retorno[0] = "VirtualAddress RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];

       Retorno[1] = "Size" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4], 16); //  TamañoDirectorio / bytes de la estructura del mismo = numero de estructuras  que apuntan a funciones de las dll(s)

       return Retorno;

   } // 8 bytes ojo hay 16 definidos total 128 bytes

   public static string[] IMAGE_EXPORT_DIRECTORY_40(string[] DiHeader) // The .edata Section (Image Only)  ojo   TamañoDirectorio / 40 = X estructuras, cada una apunta a una matriz de  funciones  de una dll, la ultima estructura es null
   { //  DataDirectory

       string[] Retorno = new string[11];


       Retorno[0] = "Characteristics, Export Flags Reserved, must be 0" + ";" + DiHeader[0] + DiHeader[1] + DiHeader[2] + DiHeader[3];

       Retorno[1] = "TimeDateStamp," + ";" + TotalConversor.ConvertExaFechaEsamblado(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);

       Retorno[2] = "Major Version," + ";" + DiHeader[9] + DiHeader[8];

       Retorno[3] = "Minor Version," + ";" + DiHeader[11] + DiHeader[10];

       Retorno[4] = "Name, RVA La dirección de la cadena ASCII que contiene el nombre de la DLL RVA" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];

       Retorno[5] = "Base, El número ordinal inicial DE LAS FUNCIONES" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16],16);

       Retorno[6] = "NumberOfFunctions, El número de funciones exportadas por nombre u ordinal" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20],16);

       Retorno[7] = "NumberOfName, número de nombres exportados" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24],16);

       Retorno[8] = "AddressOfFunctions, RVA apunta a una matriz de valores de 32 bits RVA" + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];

       Retorno[9] = "AddressOfName, RVA apunta a una matriz de valores de 32 bits RVA" + ";" + DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32];

       Retorno[10] = "AddressOfNameOrdinal, RVA apunta a una matriz de valores de 16 bits RVA" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];

       return Retorno;

   } // 40 Bytes The .edata Section (Image Only)


   public static string[] IMAGE_IMPORT_DESCRIPTOR_20(string[] DiHeader) // The .idata Section              ojo   TamañoDirectorio / 20 = X estructuras, cada una apunta a una matriz de  funciones  de una dll, la ultima estructura es null
   { //  DataDirectory

       string[] Retorno = new string[5];


       Retorno[0] = " ImportLookup, Table RVA *Original apunta a una matriz de nombres ú ordinal y termina en puntero nulo RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // apunta a 32 o 64 bits

       Retorno[1] = "TimeDateStamp, valor=  0 o F si es importacion " + ";" + TotalConversor.ConvertExaFechaEsamblado(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);

       Retorno[2] = " ForwarderChain, El índice de la primera redirección de la cadena obsoleto" + ";" + DiHeader[11] + DiHeader[10]+ DiHeader[9] + DiHeader[8] ;

       Retorno[3] = " Name,  RVA-base ASCII string, nombre de la DLL importada, null-terminated  RVA" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];

       Retorno[4] = "PIMAGE_THUNK_DATA ,Table RVA *Actual apunta a un matriz de punteros VA de las funciones importadas y termina en un puntero nulo dentro del PE OJO_VA" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16]; // apunta a 32 o 64 bits
       // una vez cargado apuntan a la misma estructura(original y actual)
       return Retorno;

   } // 20 Bytes The .idata Section (Image Only)

   public static string Import_String_ASCII(string[] DiHeader) // The .idata Section
   { //  DataDirectory

       string Retorno;

       Retorno = TotalConversor.HextoStringASCII(string.Concat (DiHeader));

       return Retorno;

   } // Nº ? Bytes import name



   public static string[] IMAGE_IMPORT_Lookup_8_4(string[] DiHeader) // The .idata Section
   { //  DataDirectory_Import  ordinal o nombre de la funcion importada de la DLL, Bits 63 to 32 are zero. se importa por nombre

       string[] Retorno = new string[3];



       if (DiHeader.Length > 4) { Retorno[0] = " OrdinalNameFlag,  Ordinal/Name Flag bit field " + ";" + DiHeader[7]; } else { Retorno[0] = " OrdinalNameFlag,  " + ";" + DiHeader[3]; }


       Retorno[1] = "OrdinalNumber, Ordinal Flag bit field is 1" + ";"  + TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16); // 63 to 16 must be 0.  or 31 to 16 must be 0, SOLO SI EL BIT MAS SIGNIFICATIVO ES 1.  nos da directamente el ordinal de la funcion importada.
       // investigando la DLL obtenemos la función utilizada
       Retorno[2] = "HintName, Table RVA  Ordinal/Name Flag bit field is 0 RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // if 64 bits los Bits 63 to 32 are zero. se importa por nombre Ordinal/Name Flag bit field is 0


       return Retorno;

   } // 8_4 Bytes The .idata. storted in r.data Section (Image Only)
 

   public static string[] IMAGE_RESOURCE_DIRECTORY_NODE_HEADER_16(string[] DiHeader) // The .rsrc Section  
   {

       string[] Retorno = new string[6];

       Retorno[0] = "DWORD Characteristics" + ";" + DiHeader[0] + DiHeader[1] + DiHeader[2] + DiHeader[3]; // Flags Unknown
       Retorno[1] = "DWORD TimeDateStamp" + ";" + TotalConversor.ConvertExaFechaEsamblado( DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
       Retorno[2] = "WORD MajorVersion" + ";" + TotalConversor.ConVertBaseDecimal( DiHeader[9] + DiHeader[8],16);
       Retorno[3] = "WORD MinorVersion" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[11] + DiHeader[10],16);
       Retorno[4] = "WORD NumberOfNamedEntries" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[13] + DiHeader[12],16); // El número de entradas de directorio inmediatamente después de la tabla que utilizan cadenas para identificar las entradas de Tipo, Nombre o Idioma
       Retorno[5] = "WORD NumberOfIdEntries" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[15] + DiHeader[14],16); // El número de entradas del directorio inmediatamente después de las entradas de Nombre, que utilizan ID numéricos para las entradas de Tipo, Nombre o Idioma.

       return Retorno;

   } // 16 bytes

   public static string[] Resource_Directory_Node_Entry_8(string[] DiHeader) // Resource data descriptor  The .rsrc Section
   {

       string[] Retorno = new string[3];

       Retorno[0] = "DWORD Name Offset or Integer ID" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // determinado anteriormente  mirar???????
       
       string Binario = TotalConversor.ConVertByteExaBinary(DiHeader[7]);

     if (Binario.Substring(0, 1) == "1") { Retorno[2] = "NewDirectory"; DiHeader[7] = TotalConversor.HexQuitarBitAlto(DiHeader[7]) ; } else { Retorno[2] = "DataEntry"; }

       Retorno[1] = "DWORD Data Entry Offset or Sudirectory Offset" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];  // Bit alto 1. Los 31 bits inferiores son la dirección de otra tabla de directorio de recursos (el siguiente nivel hacia abajo).Bit alto 0. Dirección de una entrada de datos de recursos (una hoja).

       return Retorno;

   } // 8 bytes

   public static string[] Resource_Data_Entry_16(string[] DiHeader)  // The .rsrc Section
   {

       string[] Retorno = new string[4];

       Retorno[0] = "Data RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // La dirección de una unidad de datos de recursos en el área de datos de recursos
       Retorno[1] = "Size" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4],16);  // El tamaño, en bytes, de los datos de recursos a los que apunta el campo Data RVA.
       Retorno[2] = "Codepage" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8],16);  // La página de códigos que se utiliza para decodificar valores de puntos de código dentro de los datos de recursos. Normalmente, la página de códigos sería la página de códigos Unicode.
       Retorno[3] = "Reserved, must be 0" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];

       return Retorno;

   } // 16 bytes

                                                // String resource data
  // The string resource data consists of 16 string descriptors per section.Strings whose identifiers differ only in the bottom 4 bits are placed in the same section.
   public static string[] Resource_Directory_Node_Name_o_Data_String_2_64(string[] DiHeader) // Resource node name string The .rsrc Section
   {

       string[] Retorno = new string[3];

       int Longitud = 2 * (Convert.ToInt32(TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16)));  // este es un recuento de "WORD = 2" bytes X longitud
       Retorno[0] = "WORD Lenght" + ";" + Longitud.ToString(); // El tamaño de la cadena en bytes, sin incluir el campo de longitud en sí.
       if (Longitud > 62) { Retorno[2] = "Nombre mas grande que 62"; Longitud = 62; } else { Retorno[2] ="Ok"; }
       ArraySegment<String> myArrSegMid = new ArraySegment<String>(DiHeader, 2, Longitud); ////  48
      //  Retorno[1] = "Unicode String" + ";" + TotalConversor.ConVertByteExaCadena(myArrSegMid.ToArray()); ;  // The variable-length Unicode string data, word-aligned.
     
       Retorno[1] = "? Unicode String" + ";" + TotalConversor.HextoStringUnicode(string.Concat (myArrSegMid.ToArray()));   // The variable-length Unicode string data, word-aligned. UTF-16 little-endian sin carácter de fin de cadena.


       return Retorno;

   } // 64 bytes












   public static string[] RESOURSE_VS_VERSIONINFO_CABEZERA_6(string[] DiHeader) // //  30  VS_VERSIONINFO "VS_VERSION_INFO",StringFileInfo "StringFileInfo",StringTable "<language ID Un número hexadecimal de 8 dígitos unicode +4 idioma -4 página de códigos formato>",String ex:"ProductName",VarFileInfo "VarFileInfo",Var idioma y  página de códigos varios DWORDs COMPATIBLES.
   { //  DataDirectory

       string[] Retorno = new string[3];    

       Retorno[0] = "Long-" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16);  //  WORD La longitud, en bytes, de la estructura VS_VERSIONINFO
       string LongHija = TotalConversor.ConVertBaseDecimal(DiHeader[3] + DiHeader[2], 16); //
       if (LongHija == "0") { LongHija = "LongHija 0" + ";" + LongHija; } else { LongHija = "LongHija-" + ";" + LongHija; }  //
       Retorno[1] = LongHija; // La longitud, en bytes, del VS_FIXEDFILEINFO y hijas  // WORD
       Retorno[2] =  TotalConversor.ConVertBaseDecimal( DiHeader[5] + DiHeader[4],16); // Es 1 si datos de texto y 0 si datos binarios

       return Retorno;

   } //




   // Obtenemos el string y...  con 64 bytes creo que cubrimos casi todos
   // hemos separado la estructura original para controlar las longitudes variables de los string(s), a la vez que obtenemos el puntero a la siguiente estructura.
   public static string[] RESOURSE_VS_VERSIONINFO_Unicode_string_L_64(string[] DiHeader, int Inicio) //
   { //  DataDirectory
       string[] Retorno = new string[3];
       string[] paso= TotalConversor.StringPading(DiHeader, Inicio);

       Retorno[0] = paso[0] +";-UnicodeL" ;  //  30  VS_VERSIONINFO "VS_VERSION_INFO",StringFileInfo "StringFileInfo",StringTable "<language ID Un número hexadecimal de 8 dígitos unicode +4 idioma -4 página de códigos formato>",String ex:"ProductName",VarFileInfo "VarFileInfo",Var idioma y  página de códigos varios DWORDs COMPATIBLES.
       Retorno[1] = "Puntero-;" + TotalConversor.ConvertStrimDecExa( paso[1]); // puntero a la siguiente estructura
       Retorno[2] = paso[2];  // si es igual a "ok"  todo salio perfecto....jeje
       return Retorno;

   } //



   public static string[] RESOURSE_VS_VERSIONINFO_VS_FIXEDFILEINFO_52(string[] DiHeader) //
   { //  DataDirectory

       string[] Retorno = new string[13];

       Retorno[0] = "DWORD dwSignature (FEEF04BD)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //
       Retorno[1] = "DWORD dwStrucVersion" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   //El número de versión binaria  PRIMARIA Y SEGUNDARIA WORD WORD  / Version  Stored as 2 x 16 - bit values, e.g.  "00 00 01 00" ⇒ 1.0
       Retorno[2] = "DWORD dwFileVersionMS" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //versiónMS binaria del archivo. se usa con dwFileVersionLS para formar un valor de 64 bits que se usa para comparaciones numéricas. / File version (upper 32-bit) Stored as 2 x 16-bit values, e.g. "00 00 06 00" ⇒ 6.0
       Retorno[3] = "DWORD dwFileVersionLS" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //versiónLS binaria del archivo. se usa con dwFileVersionMS para formar un valor de 64 bits que se usa para comparaciones numéricas. / File version (lower 32-bit) Stored as 2 x 16-bit values, e.g. "02 40 70 17" ⇒ 6000.16386
       Retorno[4] = "DWORD dwProductVersionMS" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //Los 32 bits más significativos del número de versión binaria del producto con el que se distribuyó este archivo. Este miembro se usa con dwProductVersionLS para formar un valor de 64 bits que se usa para comparaciones numéricas.
       Retorno[5] = "DWORD dwProductVersionLS" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  //Los 32 bits MENOS significativos del número de versión binaria del producto con el que se distribuyó este archivo. Este miembro se usa con dwProductVersionMS para formar un valor de 64 bits que se usa para comparaciones numéricas.
       Retorno[6] = "DWORD dwFileFlagsMask" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];  //Contiene una máscara de bits que especifica los bits válidos en dwFileFlags. Un bit es válido solo si se definió cuando se creó el archivo.File flags bitmask 0x0000003f
       Retorno[7] = "DWORD dwFileFlags" + ";" + RESOURSE_VS_FIXEDFILEINFO_dwFileFlags(DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28]);  //Contiene una máscara de bits que especifica los atributos booleanos del archivo. Este miembro puede incluir uno o más de los siguientes valores.
       Retorno[8] = "DWORD dwFileOS" + ";" + RESOURSE_VS_FIXEDFILEINFO_dwFileOS(DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32]);  //El sistema operativo para el que se diseñó este archivo. Este miembro puede tener uno de los siguientes valores.
       Retorno[9] = "DWORD dwFileType" + ";" + RESOURSE_VS_FIXEDFILEINFO_dwFileType(DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36]);  //El tipo general de archivo. Este miembro puede tener uno de los siguientes valores. Los demás valores están reservados.
       Retorno[10] = "DWORD dwFileSubtype" + ";" + (DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]);  //La función del archivo. Los valores posibles dependen del valor de dwFileType. Para todos los valores de dwFileType que no se describen en la siguiente lista, dwFileSubtype es cero.
       if (Retorno[9].Contains("VFT_DRV")){Retorno[10] = "DWORD dwFileSubtype" + ";" + RESOURSE_VS_FIXEDFILEINFO_VFT_DRV_dwFileSubtype_(DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]); }
       if (Retorno[9].Contains("VFT_FONT")) { Retorno[10] = "DWORD dwFileSubtype" + ";" + RESOURSE_VS_FIXEDFILEINFO_VFT_FONT_dwFileSubtype_(DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]); }
       Retorno[11] = "DWORD dwFileDateMS" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //Los 32 bits más significativos de la fecha y hora de creación binaria de 64 bits del archivo.
       Retorno[12] = "DWORD dwFileDateLS" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //Los 32 bits menos significativos de la fecha y hora de creación binaria de 64 bits del archivo.

       return Retorno;

   } //

   public static string[] RESOURSE_VS_VERSIONINFO_VS_MUI_(string[] DiHeader) // UNICODE Literal TXT
   { //  DataDirectory

       string[] Retorno = new string[13];

       Retorno[0] = "DWORD Signature (FECDFECD)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //
       Retorno[1] = "DWORD Size" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   //
       Retorno[2] = "DWORD RC Config Version 10000 " + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //
       Retorno[3] = "DWORD Unknown" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //
       Retorno[4] = "DWORD File type 0x00000011 = normal 0x00000012 = MUI file" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //
       Retorno[5] = "DWORD System attributes" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  //
       Retorno[6] = "DWORD Ultimate fallback location 0x01 = internal 0x02 = external" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];  //
       Retorno[7] = "OWORD Service Checksum" + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];  // 16 BYTES 8 WORD
       Retorno[8] = "OWORD Checksum" + ";" + DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32];  // 16 BYTES 8 WORD
       Retorno[9] = "DOWORD Unknown" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 24 BYTES 12 WORD
       // Value descriptors
       Retorno[10] = "DWORD Main name type data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //AVI FTR ORDERSTREAM TYPELIB UIFILE XML MUI      
       Retorno[11] = "DWORD Main name type data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
       Retorno[12] = "DWORD Main ID types data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //      1-24                                                  Retorno[13] = "DWORD Main ID types data size" + ";" DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  //
       Retorno[14] = "DWORD MUI name type data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //   MOFTYPE MUI WEVT_TEMPLATE
       Retorno[15] = "DWORD MUI name type data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
       Retorno[16] = "DWORD MUI ID types data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
       Retorno[17] = "DWORD MUI ID types data size" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 24 BYTES 12 WORD
       Retorno[18] = "DWORD Language data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //    
       Retorno[19] = "DWORD Language data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
       Retorno[20] = "DWORD Ultimate fallback language data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
       Retorno[21] = "DWORD Ultimate fallback language data size" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
       // VALUE DATA 64-bit aligned

       return Retorno;

   } //


   public static string[] RESOURSE_VS_VERSIONINFO_VS_WEVT_TEMPLATE_(string[] DiHeader) // UNICODE Literal TXT
   { //  DataDirectory
       string[] Retorno = new string[6];

       Retorno[0] = "DWORD Signature (CRIM)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //
       Retorno[1] = "DWORD Size" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   // Including the compiled resource instrumentation manifest header
       Retorno[2] = "WORD Major version 3" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //
       Retorno[3] = "WORD Minor version 1" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //
       Retorno[4] = "DWORD Number of event providers" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //
       Retorno[5] = "DEWORD*Number Array of event provider descriptors" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  // 20 BYTES  10 WORD


       return Retorno;

   } //

   public static string[] RESOURSE_VS_VERSIONINFO_TABLA_WEVT_TEMPLATE_(string[] DiHeader) // UNICODE Literal TXT
   { //  DataDirectory
       string[] Retorno = new string[2];
       Retorno[0] = "ODWORD  Contains a GUID" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  // 16 BYTES 8 WORD
       Retorno[1] = "DWORD  data offset " + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   // start of the instrumentation manifest


       return Retorno;

   } //

   public static string[] Resource_MESSAGE_Table_Header_4(string[] DiHeader)  // The .rsrc Section The message-table header (MESSAGE_RESOURCE_DATA) is variable of size and consists of
   {

       string[] Retorno = new string[1];

       Retorno[0] = "NumberNodeTabla" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // Number of message-table entry descriptors

       return Retorno;

   } // 4 bytes

   public static string[] Resource_MESSAGE_Table_Entry_12(string[] DiHeader)  // The .rsrc Section The message-table entry descriptor (MESSAGE_RESOURCE_BLOCK) is 12 bytes of size and consist of
   {

       string[] Retorno = new string[12];

       Retorno[0] = "DWORD IdPrimer" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // Identificador del primer mensaje
       Retorno[1] = "DWORD IdUltimo" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]; // Identificador del último mensaje
       Retorno[2] = "DWORD OffsetPrimer" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8]; // Offset of the first message

       return Retorno;

   } // 12 bytes

   public static string[] Resource_MESSAGE_Entry_4_(string[] DiHeader)  // The .rsrc Section The message-table string entry (MESSAGE_RESOURCE_ENTRY) is variable of size and consists of:
   {

       string[] Retorno = new string[3];

       Retorno[0] = "WORD Size" + ";" + DiHeader[1] + DiHeader[0]; //
       Retorno[1] = "WORD Flags" + ";" + DiHeader[3] + DiHeader[2]; // 0x00 = extended ASCII string with codepage /  0x01 = UTF-16 string
       Retorno[2] = "? String_L_Padin32" + ";" + "?"; //
       return Retorno;

   } // 4 + ?








   public static string[] IMAGE_DELAY_IMPORT_DESCRIPTOR_32(string[] DiHeader) // The .idata Section (Image Only)
   { //  DataDirectory

       string[] Retorno = new string[8];

       Retorno[0] = "Attributes,Must be zero." + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  // 1  31 reservado
       Retorno[1] = "Name RVA,of the name of the DLL" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];
       Retorno[2] = "Module Handle RVA, of the module handle ." + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];
       Retorno[3] = "Delay Import Table RVA, of the delay-load import address table IAT." + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
       Retorno[4] = "Delay Import Name Table RVA, de la tabla de nombres  Esto coincide con el diseño de la tabla de nombres de importación." + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];
       Retorno[5] = "Bound Delay Import Table RVA, of the bound delay-load address table, if it exists." + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];
       Retorno[6] = "Unload Delay Import Table RVA, tabla de direcciones de carga , si existe. copia exacta de la tabla de direcciones de importación" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];
       Retorno[7] = "Time Stamp,The timestamp of the DLL." + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];

       return Retorno;

   } // 32 Bytes
}


SPLIT ";"

Obtienes 3 campos por servidor a vista de pajaro.

Luego trabajas los campos  y ordena la información.

Bonito tema la inteligencia artificial, la usan mucho con nuestros hábitos en internet.
Lo más básico sería un entrenador matemático, basado en memoria aleatoria, entrelazando unas funciones para localizar cualquier resultado.
Si nuestro programa es torpe .............  a la larga aprenderá (memorizando todas las respuestas conocidas.  Claro solo contestara a lo que conoce.
Si le añadimos conocimiento de secuencia que el uno viene antes que el dos .... Etc. ...
Ya podrá decirte ante cualquier número cual viene después.
Si le enseñamos a comparar, si no encuentra la respuesta la comparara con preguntas semejantes y puede darte una respuesta, acertada o equivoca.

[Muchas gracias]

Para comprender esto debes tener una idea del formato PE. Este formato establece que por regla general un .exe (PE) esta conformado por muchas estructuras, algunas de estas son las denominadas "sections". Un ejecutable contiene varias secciones, cada sección con sus atributos y su contenido especifico (datos, codigo, recursos, etc). Se supone que la sección "code" es la sección que contiene codigo ejecutable o instrucciones, aunque puedes tener otras secciones fuera de la sección "code" que tambien contengan codigo ejecutable. La primera instruccion que se ejecuta esta alojada en el campo AddressOfEntryPoint de la estructura _IMAGE_OPTIONAL_HEADER. Este valor indica la primera instruccion del codigo que se ejecuta una vez el loader de windows ha cargado el binario en memoria.

En esta imagen tienes muchos mas detalles al respecto




Muchas gracias, muy útil la información ya se por donde seguir, no encontraba nada en mis búsquedas............................    


Ya encuentro cosas para entretenerme.........................

https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/corkami/PE102posterV1.pdf

Hola! y no podes ver el desensamblado en ASSEMBLER? si o si en binario tiene que ser?

Cómo abrís en binario el *.exe?

El tema es que los EXEs Y DLLs, si están hechos con un compilador conocido, podemos conocer su encabezado "TIPO", aquí hay datos de la compilación, declaraciones, constantes, llamadas al sistema operativo, etc....       Supongamos que es  "void Main()"     ¿cómo sabe el procesador donde poner el puntero inicial?

Además todo lo que aparece en el encabezado, lo carga en memoria y el sistema operativo sabe donde ubicar el programa y como tratarlo(Ej:32 o 64 bits)

en ASSEMBLER tambien vale........................gracias


http://www.openrce.org/reference_library/files/reference/PE%20Format.pdf