elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


+  Foro de elhacker.net
|-+  Programación
| |-+  Ingeniería Inversa (Moderadores: karmany, .:UND3R:., MCKSys Argentina)
| | |-+  Estructuras Binarias x86-64
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Estructuras Binarias x86-64  (Leído 3,114 veces)
FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Estructuras Binarias x86-64
« en: 6 Junio 2020, 21:47 pm »

Primera parte:  
Este es un manual indirecto de las estructuras binarias del juego de instrucciones x86-64, está abierto a edición constructiva.
Este prefijo es opcional puede estar presente o no, se enumeran los casos en los que puede estar presente. De momento se representa la forma Hexadecimal del mismo.




// LEGANCY PREFIX

/*
0x66 h     ANULACION DEL TAMAÑO PREDETERMINADO DE OPERANDOS Operand-Size Override   IN 64   PREDETeRMINADO 32----------EFECTIVE 16

0x67h  Address-Size Overrides   IN 64  -----EFECTIVE 32

Ojo  In 64-bit mode, the CS, DS, ES, and SS segment overrides are ignored
0x2Eh  Forces use of current CS segment for memory operands.
0x3Eh Forces use of current DS segment for memory operands.
0x26h Forces use of current ES segment for memory operands.
0x64h Forces use of current FS segment for memory operands.
0x65h Forces use of current GS segment for memory operands.
0x36h Forces use of current SS segment for memory operands.
*/
/*
El prefijo LOCK solo se puede usar con las formas de las siguientes instrucciones que escriben una memoria y: ADC, ADD, AND, BTC, BTR, BTS, CMPXCHG, CMPXCHG8B, CMPXCHG16B, DEC, INC, NEG, NOT, OR, SBB, SUB, XADD, XCHG y XOR. Se produce una excepción de código de operación no válido si el prefijo LOCK se usa con cualquier otra instrucción.
0xF0h LOCK        El byte de prefijo de repetición / bloqueo garantiza que la instrucción tendrá uso exclusivo de toda la memoria compartida, hasta que la instrucción complete la ejecución:


BT, BTS, BTR, BTC                   mem, reg/imm
XCHG                                reg, mem
XCHG                                mem, reg
ADD, OR, ADC, SBB, AND, SUB, XOR    mem, reg/imm
NOT, NEG, INC, DEC                  mem


Prefijos de repetición

Instrucciones que no pueden usar prefijos de repetición. En general, los prefijos de repetición solo se deben usar en las instrucciones de cadena enumeradas en las tablas 1-6, 1-7 y 1-8 . Para otras instrucciones (principalmente instrucciones SIMD), los prefijos 66h, F2h y F3h se usan como modificadores de instrucciones para extender el espacio de codificación de instrucciones en los mapas de código de operación 0Fh, 0F_38h y 0F_3Ah




1-6

REP Prefix Opcodes  (0xF3h) también se usa como prefijo obligatorio para la instrucción POPCNT, LZCNT y ADOX.
Ejemplo: ADOX reg64, reg/mem64              F3 0F 38 F6 /r       Añadir sin firmar con indicador de desbordamiento

        



REP INS reg/mem8, DXREP INSB  F3 6C  
REP INS reg/mem16/32, DXREP INSWREP INSD F3 6D
REP LODS mem8 REP LODSB F3 AC
REP LODS mem16/32/64 REP LODSWREP LODSDREP LODSQ F3 AD
REP MOVS mem8, mem8REP MOVSB F3 A4
REP MOVS mem16/32/64, mem16/32/64 REP MOVSWREP MOVSDREP MOVSQ F3 A5
REP OUTS DX, reg/mem8 REP OUTSB F3 6E
REP OUTS DX, reg/mem16/32 REP OUTSWREP OUTSD F3 6F
REP STOS mem8REP STOSB F3 AA
REP STOS mem16/32/64 REP STOSWREP STOSDREP STOSQ  F3 AB

1-7

REPE and REPZ Prefix Opcodes  ( 0xF3h)
REPx CMPS mem8, mem8REPx CMPSB F3 A6
REPx CMPS mem16/32/64, mem16/32/64 REPx CMPSWREPx CMPSDREPx CMPSQ F3 A7
REPx SCAS mem8 REPx SCASB F3 AE
REPx SCAS mem16/32/64 REPx SCASWREPx SCASDREPx SCASQ F3 AF

1-8
REPNE and REPNZ Prefix Opcodes  (F2)
REPNx CMPS mem8, mem8REPNx CMPSB F2 A6
REPNx CMPS mem16/32/64, mem16/32/64 REPNx CMPSWREPNx CMPSDREPNx CMPSQ F2 A7
REPNx SCAS mem8REPNx SCASBF2 AEREPNx SCAS mem16/32/64 REPNx SCASWREPNx SCASDREPNx SCASQ F2 AF



*/

Segunda Parte


/*
// REX PREFIX
   0X40h a 0X4Fh

¡Este Prefijo no simpre esta presente!

      FORMATO  del Byte REX (0100 WRXB)

Hay que tener en cuenta que hablaremos de un procesador y sistema operativo de 64 bits.

En un sistema de 64 bits el operando predeterminado es de 32 bits.

Si W = 0  implica que no se cambia el tamaño del operando.
Si W= 1   implica que se cambia el tamaño del operando a 64 bits.

R es una extensión del REG del (Byte M0Dr/m)(*)
X es una extensión del Índice del (SIB Byte) ¿si existe? Sino es ignorado (*)
B es una extensión de la BASE del (SIB Byte) ¿si existe? En caso
Contrario es una extensión del r/m del (Byte M0Dr/m)(*)

RexPrefix (40,41,42,43,44,45,46,47,48,49,4A,4B,4C,4D,4E,4F)
Notación      Rex.w = 1        (48 49 4A 4B 4C 4D 4E 4F)  64 bits

    
    
Byte MOD r/m      (MOD 2 bits, REG 3 bits, r/m 3 bits)
SIB Byte                  (Escala 2 bits, Índice 3 bits, Base 3 bits)


Byte MOD r/m




MOD
(00)   direccionamiento indirecto  ojo. No hay desplazamiento
(01)   1 byte de desplazamiento
(10) 4 byte de desplazamiento
(11) direccionamiento directo a registro  ojo. No hay desplazamiento solo Imm...

En estos casos : { "C0", "C8", "D0", "D8", "E0", "EB", "F0", "F8", "C1", "C9", "D1", "D9", "E1", "E9", "F1", "F9", "C2", "CA", "D2", "DA", "E2", "EA", "F2", "FA", "C3", "CB", "D3", "DB", "E3", "EB", "F3", "FB", "C4", "CC", "D4", "DC", "E4", "EC", "F4", "FC", "C5", "CD", "D5", "DD", "E5", "ED", "F5", "FD", "C6", "CE", "D6", "DE", "E6", "EE", "F6", "FE", "C7", "CF", "D7", "DF", "E7", "EF", "F7", "FF" }


REG
de datos(000, 001,010,011)
Punteros de pila(100,101)
Registros de índices(110,111)

r/m                            Direccionamiento efectivo
de datos(000, 001,010,011)  + desplazamiento
(100) indica que existe el    SIB Byte  

SIB Presente { "04", "0C", "14", "1C", "24", "2C", "34", "3C", "44", "4C", "54", "5C", "64", "6C", "74", "7C", "84", "8C", "94", "9C", "A4", "AC", "B4", "BC" }


Si (101) solo hay desplazamiento
En estos casos: { "05", "00", "15", "1D", "25", "2D", "35", "3D" }  mod (00)  Ojo 32 Bits


 Registros de índices(110,111) + desplazamiento



  SIB Byte


Escala    (Índice * Escala)Valué          
(00)   =  1
(01)   = 2
(10)            = 4
(11)            = 8


Indece

de datos(000, 001,010,011)
Registros de índices(110,111)
Punteros de pila(101)
(100)      no hacer nada

BASE
de datos(000, 001,010,011)
Registros de índices(110,111)
Punteros de pila(100)
(101)    Solamente desplazamiento si MOD = (00), si MOD =(01) OR (10) Punteros de pila
MOD (11) no utilizado

Direccionamiento efectivo con el SIB Byte
[Índice * Escala]  + desplazamiento(viene predeterminado por MOD del Byte MOD r/m)




¡Ojo!

El direccionamiento de desplazamiento en modo de 64 bits utiliza codificaciones ModR / M y SIB existentes de 32 bits. Los tamaños de desplazamiento ModR / M y SIB no cambian. Permanecen 8 bits o 32 bits y se extienden a 64 bits.


Registros de segmento Predeterminados

El registro de segmento predeterminado es SS para las direcciones efectivas que contienen un índice BP, DS para otras direcciones efectivas

Si    r/m = (010) or (011)   el registro de segmento predeterminado es SS
Si     r/m =(000) or (001) or (100) or (101) or (110) or (111) el registro de segmento predeterminado es  DS

Ejemplo de Mnemonic  ADD  ( Z000 0XDS )

S=0 8bits Operando           S=1 16-32Bits Operando
D=1 Indica que el operando(destino) es el REG del MODr/m
D=0 Indica que el operando(destino) es el indicado por MOD......r/m del MODr/m
¿Si Z=1 y D=0 indica que el tamaño del imm..  esta establecido por S
¿Si Z=1 y D=1 indica que el tamaño de imm.. se extenderá al tamaño del operando
¿Si X=1  indica que el operando es un registro predeterminado Al, AX, EAX RAX segun el tamaño expresado por "S" con sus Prefijos correspondientes si es diferente a 8 o 32 Bits.

Hay que tener en cuenta que el operando predeterminado es de 32 bits
y el Direccionamiento se extiende a 64 bits en sistemas de 64.
imm…  Inmediato Valué
r… Registros generales     AL-8   AX- 16    EAX- 32  RAX- 64 bits    hay 8 en total (AL CL DL BL AH CH DH BH)  
(Inmediato)imm8 = 8 bits         imm16= 16 bits  imm32 = 32 bits etc.….



0x00h     0000 0000      [MOD=(11)  REG=(000)    r/m(000)]= 0x00h           ADD r/m, r8  *                00 (00) r.. variable

Longitud de esta instrucion     1 Byte del OpCode + 1 Byte del MODr/m  Total 2 Bytes

El destino de la operacion es el MODr/m porque lo indica el digito "D"=0
por lo tanto el origen es el REG


MOD =(11) indica que la operacion es de registro a registro.

0x01h     0000 0001        [MOD=(11)  REG=(000)    r/m(000)]= 0xC0h           ADD r/m, r16   *       66  01 (C0) r.. variable
0x02 h     0000 0010        [MOD=(11)  REG=(000)     r/m(000)]= 0xCOh           ADD r8, r/m  *               02  (C0) r .. variable  
0x03h      0000 0011       [MOD=(11)  REG=(000)    r/m(000)]= 0xCOh           ADD r16, r/m   *             66 03 C0  

X=1 Indica que el Operando(Destino) es el registro de uso general predeterminado (AL,AX,EAX,RAX,XMM0)

0x04h      0000 0100     (04) (imm8)         ADD AL, imm8                       modo directo    ok
0x05h     0000 0101           66 05   (imm16)    ADD AX, imm16           modo directo    ok
0x05h      0000 0101     05 (imm32)        ADD EAX, imm32                    modo directo     ok

En el caso Z = 1 el REG del Byte MODr/m (000) es una extensión del OpCODE Z.
El Operando(destino) es siempre el MOD......r/m.


0x80h      1000 0000         [MOD=(00)  REG=(000)   r/m(000)]= 0x00h           ADD r/m, imm8   *
0x81h      1000 0001        [MOD=(00)  REG=(000)     r/m(000)]          ADD r/m, imm16    *      66  81 (80) r..variable
0x81h      1000 0001         [MOD=(00)  REG=(000)    r/m(000)]          ADD r/m, imm32   *
0x83h      1000 0011      [MOD=(00)  REG=(000)     r/m(000)]           ADD r/m, imm8    *   se extiende imm8 a 32bits        


Esto se aplica a todas estas instrucciones aritméticas-lógicas

REG (000) ADD
REG  (001)  OR
REG  (010) ADC
REG  (011) SBB
REG  (100) AND
REG  (101) SUB
REG  (110) XOR
REG  (111) CMP





El byte SIB


Normalmente no está presente. Solo es necesario cuando una instrucción usa el formato de direccionamiento ( Scale * Index + Base). esto solamente lo indica en Byte MODr/m  si el Campo Registro = (100)=REG.
(Escala 2 BITS, Índice 3 bits, Base 3 Bits)


un ejemplo rápido

ADD ecx, [ebx + edi x 4]    = 0x030CBBh
ADD                        MODr/m            SIB
0 0000 0 1 1       00 001 100       10 111 011


Una parte importante es el desplazamiento, mejor un ejemplo:


ADD ebp,[disp32 + eax*1] = 0x03, 0x2C, 0x05, 0x00, 0x00, 0x00, 0x00
        ADD            modR/M           SIB Byte                            Disp32
= 00000011     00 101 100      00 000 101       00000000 00000000 00000000


ADD ebp,[0x11 + eax*1] = 0x03, 0x2C, 0x05,     0x11, 0x00, 0x00, 0x00 Total Bytes 3+4=7

                                                                               Disp32(0x11h)  se desplaza a la izquierda
= 00000011 00 101 100 00 000 101        00010001 00000000 00000000


ADD ebp,[0x11 + 0x11*4] = 0x03, 0x2C, 0x25, 0x55, 0x00, 0x00, 0x00


IMPORTANTICIMO NUNCA PERDER DE VISTA EL MODO DEL SISTEMA OPERATIVO 32 O 64
El ejemplo anterior corre en un sistema de 32 bits. ¿qué ocurre si corre en un sistema de 64 Bits?

     Recordatorio             0x67h  Address-Size Overrides   IN 64  -----EFECTIVE 32  
      
ADD ebp,[0x11 + eax*1] = 0x67, 0x03, 0x2C, 0x05,  0x11, 0x00, 0x00, 0x00 Total Bytes 1+3+4=8

             L-Prefix                ADD           modR/M           SIB Byte                            Disp32

=        01100111        00000011    00 101 100       00 000 101        00010001 00000000 00000000
                                        
Hemos utilizado el EAX 32 bits, si hubieramos utilizado RAX de 64 bis no haria falta el prefijo.



Algunos Valúes  Aritméticos - Lógicos


ADD x,y       xValue= (x+y)

ADC x,y       xValue= (x+y+CF)

SUB x,y       xValue= (x-y)

SBB x,y       xValue= (x-y-CF)

INC x         xValue= (x+1)

DEC x         xValue= (x-1)

NOT x=(0001)  xValue= (1110)  invierte los bits

NEG x=(1110)  xValue= [(0001)+1]= (0010) invierte los bits y le suma 1

OR x,y  x=(1110) y=(0011)   xValue=(1101)  if (bitx=bity) = 0  else = 1

AND x,y x=(1110) y=(0011)   xValue=(0010) if (bitx=1 y bity=1)=1 else =0

CMP x,y   if x=y Then (ZF (zero flag) gets a value=1) else =0

JMP x         Goto x


// VEX y XOP PREFIX

2 Bytes opecode
0xC5h   VEX

11000100     W vvvv L pp    W=0 fijo
map_select  00001         fijo
Implícito X=1 B=1


3 Bytes opecode
0xC4h VEX

11000101     RXB mmmmm       W vvvv L PP

0X8Fh    XOP
10001111     RXB mmmmm      W vvvv L PP


R
R = 1  obligatorio en 32 bits =  rex.r=0
R = 0  64 bits  = rex.r=1
R es una extensión del REG del (Byte M0Dr/m)(*)

X
X = 1   obligatorio en 32 bits
X=0     64 bits    
X es una extensión del Índice del (SIB Byte) ¿si existe? Sino es ignorado (*)

B
B = 1    ignorado en 32 bits                
B=0        64 bits  
B es una extensión de la BASE del (SIB Byte) ¿si existe? En caso
Contrario es una extensión del r/m del (Byte M0Dr/m)(*)


código de operación específico (uso como REX.W, o usado para código de operación
extensión, o ignorado, dependiendo del byte del código de operación)

W         =   REX.W INVERSO
Si W = 1  implica que no se cambia el tamaño del operando.
Si W= 0   implica que se cambia el tamaño del operando a 64 bits.



mmmmm       Mapa Selecionado
VEX
00000  reservado
00001  byte de código de operación inicial 0F implícito          opcode   Mapa 1   2 Byte
00010                                                                   0F 38       opcode  Mapa 2   3 Byte
00011                                                                   0F 3A       opcode  Mapa 3   3 Byte
00100  reservado
11111  reservado

XOP
00000 – 00111  Reservdo
01000 XOP opcode map 8
01001 XOP opcode map 9
01010 XOP opcode map 10
(Ah)01011 – 11111Reserved

vvvv
Es un especificador de registro (en forma de complemento de 1)
o 1111 si no se usa?¿
vvvv
Binary    Register           Binary              Register
0000    XMM15/YMM15      1000          XMM07/YMM07
0001    XMM14/YMM14      1001          XMM06/YMM06
0010    XMM13/YMM13      1010           XMM05/YMM05
0011    XMM12/YMM12      1011           XMM04/YMM04
0100    XMM11/YMM11      1100            XMM03/YMM03
0101     XMM10/YMM10     1101            XMM02/YMM02
0110     XMM09/YMM09     1110            XMM01/YMM01
0111     XMM08/YMM08     1111            XMM00/YMM00



L =0       scalar o 128 bits vector  
L= 1      256 Bits Vector

En Instruciones de Mascara

L=0  2 operandos in mascara
L=1  3 operandos in mascara


PP
Extensión de código de operación que proporciona la funcionalidad equivalente de un prefijo SIMD

00 None
01  66
10  F3
11  F2


VEX Byte 1, el bit [7] contiene un bit análogo a un REX.R invertido. En los modos protegido y de compatibilidad, el bit debe establecerse en "1"; de lo contrario,
la instrucción es LES o LDS.
El bit [6] del byte VEX de 3 bytes codifica un bit análogo a un bit REX.X invertido. Es una extensión del campo Índice SIB en modos de 64 bits. En los modos de 32 bits, este bit debe establecerse en "1"; de lo contrario, la instrucción es LES o LDS. Este bit solo está disponible en el prefijo VEX de 3 bytes. Este bit se
almacena en formato invertido.
El bit [5] del byte VEX de 3 bytes codifica un bit análogo a un REX.B invertido. En los modos de 64 bits, es una extensión del campo ModR / M r / m, o el campo base SIB.
En los modos de 32 bits, este bit se ignora. Este bit solo está disponible en el prefijo VEX de 3 bytes. Este bit se almacena en formato de bit invertido
El bit [7] del byte 2 VEX de 3 bytes está representado por la notación VEX.W. Puede proporcionar las siguientes funciones, dependiendo del código de operación específico.

• Para las instrucciones AVX que tienen instrucciones SSE heredadas equivalentes (por lo general, estas instrucciones SSE tienen un operando de registro de propósito general con su atributo de tamaño de operando promocionable por REX.W), si REX.W promueve el atributo de tamaño de operando del operando de registro de propósito general en la instrucción SSE heredada, VEX.W tiene el mismo significado en la forma equivalente AVX correspondiente. En los modos de 32 bits, VEX.W se ignora en silencio.

• Para las instrucciones AVX que tienen instrucciones SSE heredadas equivalentes (por lo general, estas instrucciones SSE tienen oper-ands con su atributo de tamaño de operando fijo y no promocionable por REX.W), si REX. A W no le importa la instrucción SSE heredada, VEX.W se ignora en la forma equivalente de AVX correspondiente independientemente del modo.

• Para las nuevas instrucciones AVX donde VEX.W no tiene una función definida (por lo general, esto significa la combinación del byte de código de operación y VEX.mmmmm no tenía ninguna función SSE equivalente), VEX.W está reservado como cero y si se configura en un valor distinto de cero, la instrucción será #UD

2 bytes VEX Byte 1, bits [6: 3] y 3 bytes VEX Byte 2, bits [6: 3] - 'vvvv' el Especificador de registro de origen o destino En modo de 32 bits, el primer byte VEX C4 y C5 alias las instrucciones LES y LDS.

Para mantener la compatibilidad con los programas existentes, el segundo byte VEX, los bits [7: 6] deben ser 11b. Para lograr esto, los bits de carga útil VEX se seleccionan para colocar solo campos válidos invertidos de 64 bits (selectores de registro extendido) en estos bits superiores.

El VEX de 2 bytes Byte 1, bits [6: 3] y el VEX de 3 bytes, Byte 2, bits [6: 3] codifican un campo (abreviatura VEX.vvvv) que para instrucciones con 2 o más registros fuente y un XMM o YMM o destino de memoria codifica el primer especificador de registro fuente almacenado en forma invertida (complemento de 1). VEX.vvvv no es utilizado por las instrucciones con una fuente (excepto ciertos turnos, ver más abajo) o en instrucciones sin XMM o YMM o destino de memoria.

Si una instrucción no usa VEX.vvvv, entonces debe establecerse en 1111b; de lo contrario, la instrucción será # UD.
En el modo de 64 bits, se pueden usar los 4 bits. el bit 6 debe ser 1 (si el bit 6 no es 1, la versión VEX de 2 bytes generará instrucción LDS y la versión VEX de 3 bytes ignorará este bit

El campo VEX.vvvv está codificado en formato de bit invertido para acceder a un operando de registro
*/

Continuare pronto.........................

3DNow!™
      Formato y        Opcodes
0x0F0Fh

0Fh 0Fh [ModRM] [SIB] [displacement] imm8_opcode

[/b][/size]

EVEX PREFIX
  
0X62h
R X B r  00 mm
W vvvv 1 pp
z l L b V aaa

PREFIX      62        1º   2º    3º  

mm             selección mapa

PP
Extensión de código de operación que proporciona la funcionalidad equivalente de un prefijo SIMD

00 None
01  66
10  F3
11  F2

RXB         Extensión del M/m, M/r , SIB/b y SIB/índice

r     Extensión del  EVEX.R and ModR/M.reg

X  Extensión del  EVEX.B and ModR/M.rm, SIB/VSIB si esta presente

vvvv
Es un especificador de registro (en forma de complemento de 1)
o 1111 si no se usa?¿

V  Extensión del  EVEX.vvvv , VSIB si esta presente Especificador de registro NDS / VIDX High-16


aaa Especificación de registro de máscara de operaciones integrada
Las instrucciones que requieren aaa <> 000 no permiten que EVEX.z se establezca en 1.

W   extensión de tamaño

Z     enmascaramiento (fusión y puesta a cero)

b            Broadcast/RC/SAE Context
b=1
Instrucciones de FP con redondeo semántico.
Instrucciones de carga + operación con fuente de memoria
b= 0
Para :Otras instrucciones (carga / almacenamiento / difusión / recopilación / dispersión explícitas)


l                Vector length/RC
l L        
00b: 128-bit  01b: 256-bit  10b: 512-bit    11b: Reservado (#UD)





Instrucciones que requieren el vector:       XCR0 Bit Vector [7:0]

Legacy SIMD prefix Instrucciones codificadas (e.g SSE)XMM
xxxxxx11b

VEX- Instrucciones codificadas operando en YMM YMM
xxxxx111b

EVEX-codificadas 128-bit Instrucciones ZMM
111xx111b

EVEX- codificadas 256-bit Instrucciones ZMM
111xx111b

EVEX-encoded 512-bit Instrucciones ZMM
111xx111b

VEX- codificadas  Instrucciones operando en  opmaskk-reg
xx1xxx11b


vmulps zmm1, zmm2, [rax] {1to16}

0x62, 0xF1, 0x6C, 0x58, 0x59, 0x08


    0º         1º         2º         3º    
{ 0x62,    0xF1,    0x6C,   0x58,    0x59,        0x18 }

  pref                                         op/s mapa    r/m


 Broadcast  (escalar) r/m


                        
                     zlLbVaaa

58 (1 to 16)    01011000  operando en zmm con reg de 64 bits

18  (1 to 4)    00011000  operando en xmm con reg de 32 bits


AVX-512 Opmask registers


Ejemplo de codificacion completo
 

Opcode Operando destino, operando, operando field

KANDW k1, k2, k3     modificamos el Operando destino k1

Prefixo VEX  +  W vvvv L pp + Opcode   + M/r
  
c5 ec 41 cb    k1   k2   k3           W vvvv L pp              M/r   11 001 011    k1 = base = 1

KANDW k4, k2, k3
c5 ec 41 e3    k4   k2   k3                                   M/r    11 100  011   k4 = base = 4

KANDW k7, k2, k3
c5 ec 41 fb    k7   k2   k3           1 1101 1 00                     11 111 011   k7 = base = 7



KANDW k1, k2, k3


c5 ec 41 cb    k1   k2   k3           W vvvv L pp              M/r   11 001 011     k3= m/r =3  

KANDW k1, k2, k4

c5 ec 41 cc                                                          11 001 100      k4= m/r =4

KANDW k1, k2, k7                                                      

c5 ec 41 cf                                                          11 001 111      k7= m/r =7    



KANDW k1, k2, k3                      

c5 ec 41 cb                            1 1101 1 00            101 bits invertidos 010 = 2 =k2

KANDW k1, k4, k3

c5 dc 41 cb                            1 1011 1 00            011 bits invertidos 100 = 4 =k4


KANDW k1, k7, k3

c5 c4 41 cb                             1 1000 1 00           000 bits invertidos 111 = 7 =k7

 
Aqui se codifica el Operando que en este caso no tiene sentido, pero se trata igual.

El Opcode lleva implicito que es una operacion con mascara "Opmask"


                                        




Static Rounding Mode  (EVEX.b = 1)   SAE CONTROL     aqui el Ll indica el round          

vaddps zmm7 {k6}, zmm2, zmm4, {rd-sae}

0x62, 0xF1, 0x6C, 0x3E, 0x58, 0xFC



                      zlLbVaaa
3E   rd-sae     00111110

5e   ru-sae     01011110

1E   rn-sae     00011110

7E   rz-sae     01111110

Analice del código hexadecimal

Instrucción “CMP”     Concretamente “81 /7 Imm?”

Compara Imm?(valor inmediato de 16,32,* en 64 Bit Modo si no alteramos el operando se extiende a 64 bits, claro el direccionamiento es de 64 bits sí o sí) Con r?/m( con Registro o Memoria)
“rip” – Dirección relativa
“PTR”- Puntero a la memoria en este caso (donde leeremos 32 Bits a partir del puntero)
El Operando en 64 bits es 32bits por lo general

Opcode
    81                  /7             disp32           Imm32  
    81                  3D        B90000B9     00 00 02 00
Opcode        Mod/r
                          3D(00  111  101)(modo  /7  disp32)

Ensamblador : DWORD PTR [rip+0XFFFF FFFF B900 00B9],0x20000
Se compara el valor Imm32 con el valor que esta a partir de la dirección “PTR”

 Modificador                                               disp32           imm16
       66                    81             3D             B9B90000         02  00
    PREFIX                                3D(00  111  101)(modo  /7  disp32)      

 Ensamblador :    WORD PTR [rip+0xB9B9],0x2
Se compara el valor Imm16 con el valor que está a partir de la dirección “PTR”

opcode               Mod/r                                                  Imm32
81                          3E                                                   00000200
                               3E (00 111 110) (Mod    /7     rsi)

Ensamblador :    DWORD PTR [rsi],0x20000

                             Imm32(lectura iz-derecha)                         Imm32(valor)
81  3E                  20 00 02 02                     DWORD PTR [rsi],   0x2 02 00 20
81  3E                  10 00 02 03                      DWORD PTR [rsi],   0x3 02 00 10
81  3E                  12 34 56 78                      DWORD PTR [rsi],   0x78 56 34 12

Con REX
48   81   3D   7F000001     23000004
QWORD PTR [rip+0x1 00 00 7F],0x4 00 00 23  

48 81  3D   7F 00 00 01    23 00 00 40
QWORD PTR [rip+0x100007F],0x40 00 00 23  

Conclusión   0x2 en ensamblador(Representa el valor de 02== 2) = 02(lectura Hexadecimal)

« Última modificación: 26 Septiembre 2020, 21:01 pm por FFernandez » En línea

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #1 en: 16 Julio 2020, 21:02 pm »

CREANDO DESENSAMBLADOR


PRIMERO LA BASE DE DATOS GENERICA


« Última modificación: 11 Noviembre 2020, 23:39 pm por FFernandez » En línea

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #2 en: 22 Julio 2020, 22:32 pm »

Segundo:   Base de datos de Instrucciones Documentadas



« Última modificación: 11 Noviembre 2020, 23:51 pm por FFernandez » En línea

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #3 en: 22 Julio 2020, 22:35 pm »

AMD  Continua   Cancelado



« Última modificación: 2 Diciembre 2020, 22:18 pm por FFernandez » En línea

MCKSys Argentina
Moderador Global
***
Desconectado Desconectado

Mensajes: 4.906


Diviértete crackeando, que para eso estamos!


Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #4 en: 24 Julio 2020, 02:26 am »

Está construyendo un testamento...

No sería mejor colocar todo en un repo como GitHub y poner el link?

Más que nada por claridad...

Saludos!
En línea

MCKSys Argentina

"Si piensas que algo está bien sólo porque todo el mundo lo cree, no estás pensando."

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #5 en: 1 Agosto 2020, 19:40 pm »

Está construyendo un testamento...

No sería mejor colocar todo en un repo como GitHub y poner el link?

Más que nada por claridad...

Saludos!


Tengo casi listo el Testamento de Intel, lo cruzare con el de AMD y publicare solo una base de datos de instruciones conocidas.   si se puede la publico aqui.     Mas adelante publicare funciones que utilizaremos y mas Testamento...........jeje     soy todo oido, gracias
En línea

apuromafo CLS


Desconectado Desconectado

Mensajes: 1.416



Ver Perfil WWW
Re: Estructuras Binarias x86-64
« Respuesta #6 en: 7 Agosto 2020, 21:10 pm »

yo sugeriría que abordaras un documento en github o gitlab, o bitbucket o cosas asi, con el tiempo evitas tener que...juntar tantos libros, además las arquitecturas mueven en cantidad de bits, tienes asm de 8, 16, 32, 64...
En línea

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #7 en: 8 Noviembre 2020, 00:48 am »

Estructuras PE  Windows


Código
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. public class PE_Formato
  5. {
  6.  
  7.    public static string[] IMAGE_DOS_HEADER_64(string[] DosHeader)
  8.  
  9.    { // 64 bytes
  10.  
  11.        string[] Retorno = new string[19];
  12.  
  13.        Retorno[0] = "e_magic, Firma MZ" + ";" + TotalConversor.HextoStringASCII(DosHeader[0] + DosHeader[1]);
  14.  
  15.        Retorno[1] = "e_cblp, Bytes Codigo Ultima Pagina" + ";" + TotalConversor.ConVertBaseDecimal( DosHeader[3] + DosHeader[2],16); ;
  16.  
  17.        Retorno[2] = "e_cp, paginas en archivo" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[5] + DosHeader[4], 16); ;
  18.  
  19.        Retorno[3] = "e_crlc, reubicación" + ";" + DosHeader[7] + DosHeader[6];
  20.  
  21.        Retorno[4] = "e_cparhdr, Tamaño del encabezado en  párrafos" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[9] + DosHeader[8], 16);  // paragraphs (16 byte chunks)
  22.  
  23.        Retorno[5] = "e_minalloc, Mínimos párrafos adicionales necesarios" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[11] + DosHeader[10], 16);
  24.  
  25.        Retorno[6] = "e_maxalloc, Máximo de párrafos adicionales necesarios" + ";" + TotalConversor.ConVertBaseDecimal(DosHeader[13] + DosHeader[12], 16);
  26.  
  27.        Retorno[7] = "e_ss, Valor inicial (relativo) SS" + ";" + DosHeader[15] + DosHeader[14];
  28.  
  29.        Retorno[8] = "e_sp, Valor inicial del SP" + ";" + DosHeader[17] + DosHeader[16];
  30.  
  31.        Retorno[9] = "e_csum, Checksum" + ";" + DosHeader[18] + DosHeader[19];  //++
  32.  
  33.        Retorno[10] = "e_ip, Valor IP inicial" + ";" + DosHeader[21] + DosHeader[20];
  34.  
  35.        Retorno[11] = "e_cs, Valor inicial (relativo) CS" + ";" + DosHeader[23] + DosHeader[22];
  36.  
  37.        Retorno[12] = "e_lfarlc, Dirección de archivo de la tabla de reubicación INICIO STUB??" + ";" + DosHeader[25] + DosHeader[24];
  38.  
  39.        Retorno[13] = "e_ovno, Número de superposición" + ";" + DosHeader[27] + DosHeader[26];
  40.  
  41.        Retorno[14] = "e_res[4]" + ";" + DosHeader[29] + DosHeader[28]; //  34-35
  42.  
  43.        Retorno[15] = "e_oemid, OEM identificador (para e_oeminfo)" + ";" + DosHeader[37] + DosHeader[36];
  44.  
  45.        Retorno[16] = "e_oeminfo,  OEM información específico e_oemid " + ";" + DosHeader[39] + DosHeader[38];
  46.  
  47.        Retorno[17] = "e_res2[10]" + ";" + DosHeader[41] + DosHeader[40];  // 58-59
  48.  
  49.        Retorno[18] = "Puntero Encabezado PE RVA" + ";" + DosHeader[63] + DosHeader[62] + DosHeader[61] + DosHeader[60];
  50.  
  51.  
  52.        return Retorno;
  53.    }
  54.  
  55.    public static string[] IMAGE_FILE_HEADER_24(string[] FileHeader)
  56.    { //
  57.  
  58.        string[] Retorno = new string[8];
  59.  
  60.        Retorno[0] = "Signature, firma del archivo en este caso PE00 PE 90 0" + ";" + TotalConversor.HextoStringASCII(FileHeader[0] + FileHeader[1] + FileHeader[2] + FileHeader[3]);
  61.  
  62.        Retorno[1] = "Machine, Procesador Arquitectura 014C–X86-32 8664-X86-64  0000–todos 0200-IA64" + ";" + FileHeader[5] + FileHeader[4]; //++
  63.  
  64.        Retorno[2] = "NumberOfSections, Número de secciones" + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[7] + FileHeader[6], 16);
  65.  
  66.        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]); //++
  67.  
  68.        Retorno[4] = "PointerToSymbolTable, Pointer A la tabla de símbolos  OBSOLETO IMG 00000000 RVA" + ";" + FileHeader[15] + FileHeader[14] + FileHeader[13] + FileHeader[12];
  69.  
  70.        Retorno[5] = "NumberOfSymbols, Número de símbolos OBSOLETO IMG 00000000" + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[19] + FileHeader[18]+ FileHeader[17] + FileHeader[16], 16);
  71.  
  72.        Retorno[6] = "SizeOfOptionalHeader, Tamaño del encabezado opcional  Para archivo de imagen " + ";" + TotalConversor.ConVertBaseDecimal(FileHeader[21] + FileHeader[20], 16);
  73.  
  74.        Retorno[7] = "Characteristics, Características  ****" + ";" + FileHeader[23] + FileHeader[22]; //++
  75.  
  76.  
  77.       return Retorno;
  78.    }  /* TOTAL 24 BYTES */
  79.  
  80.    public static string[] IMAGE_OPTIONAL_HEADER64_112(string[] OpHeader)
  81.    {
  82.        string[] Retorno = new string[29];
  83.  
  84.        Retorno[0] = "Magic, 010B -32  020B -64   0107 -ROM  0000 -dual" + ";" + OpHeader[1] + OpHeader[0];
  85.  
  86.        Retorno[1] = "MajorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[2],16);
  87.  
  88.        Retorno[2] = "MinorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[3],16);
  89.  
  90.        Retorno[3] = "SizeOfCode, tamaño del codigo maquina en todas las secciones" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[7] + OpHeader[6] + OpHeader[5] + OpHeader[4],16);
  91.  
  92.        Retorno[4] = "SizeOfInitializedData, tamaño de la sección de datos iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[11] + OpHeader[10] + OpHeader[9] + OpHeader[8],16);
  93.  
  94.        Retorno[5] = "SizeOfUninitializedData, tamaño de la sección de datos no iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[15] + OpHeader[14] + OpHeader[13] + OpHeader[12],16);
  95.  
  96.        Retorno[6] = "AddressOfEntryPoint, dirección de la primera instrucion que se ejecuta en memoria RVA" + ";" + OpHeader[19] + OpHeader[18] + OpHeader[17] + OpHeader[16];
  97.  
  98.        Retorno[7] = "BaseOfCode,dirección relativa de la base del código RVA" + ";" + OpHeader[23] + OpHeader[22] + OpHeader[21] + OpHeader[20];
  99.  
  100.        Retorno[8] = "ImageBase,dirección base preferida RVAbp" + ";" + OpHeader[31] + OpHeader[30] + OpHeader[29] + OpHeader[28] + OpHeader[27] + OpHeader[26] + OpHeader[25] + OpHeader[24];
  101.  
  102.        Retorno[9] = "SectionAlignment, alineación de las secciones >= a FileAlignment Pagina32-4096bytes" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[35] + OpHeader[34] + OpHeader[33] + OpHeader[32],16);
  103.  
  104.        Retorno[10] = "FileAlignment,factor de alineación 512Bytes-64K potencias de 2" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[39] + OpHeader[38] + OpHeader[37] + OpHeader[36],16);
  105.  
  106.        Retorno[11] = "MajorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[41] + OpHeader[40],16);
  107.  
  108.        Retorno[12] = "MinorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[43] + OpHeader[42],16);
  109.  
  110.        Retorno[13] = "MajorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[45] + OpHeader[44],16);
  111.  
  112.        Retorno[14] = "MinorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[47] + OpHeader[46],16);
  113.  
  114.        Retorno[15] = "MajorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[49] + OpHeader[48],16);
  115.  
  116.        Retorno[16] = "MinorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[51] + OpHeader[50],16);
  117.  
  118.        Retorno[17] = "Win32VersionValue," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[52] + OpHeader[53] + OpHeader[54] + OpHeader[55],16);
  119.  
  120.        Retorno[18] = "SizeOfImage,un múltiplo de SectionAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[59] + OpHeader[58] + OpHeader[57] + OpHeader[56],16);
  121.  
  122.        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);
  123.  
  124.        Retorno[20] = "CheckSum,algoritmo utilizado se toma de la librería IMAGEHELP.DLL" + ";" + OpHeader[67] + OpHeader[66] + OpHeader[65] + OpHeader[64]; //++
  125.  
  126.        Retorno[21] = "Subsystem, tipo de subsistema necesario" + ";" + OpHeader[69] + OpHeader[68];
  127.  
  128.        Retorno[22] = "DllCharacteristics, punto de entrada para las DLL" + ";" + OpHeader[71] + OpHeader[70];
  129.  
  130.        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);
  131.  
  132.        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);
  133.  
  134.        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);
  135.  
  136.        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);
  137.  
  138.        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);
  139.  
  140.        Retorno[28] = "NumberOfRvaAndSizes, Cantidad de DataDirectory" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[111] + OpHeader[110] + OpHeader[109] + OpHeader[108],16);
  141.  
  142.        return Retorno;
  143.    }    /* TOTAL 112 BYTES */
  144.  
  145.    public static string[] IMAGE_OPTIONAL_HEADER32_96(string[] OpHeader)
  146.    {
  147.        string[] Retorno = new string[30];
  148.  
  149.        Retorno[0] = "Magic, 010B -32  020B -64   0107 -ROM  0000 -dual" + ";" + OpHeader[1] + OpHeader[0];
  150.  
  151.        Retorno[1] = "MajorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[2],16);
  152.  
  153.        Retorno[2] = "MinorLinkerVersion, enlazador" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[3],16);
  154.  
  155.        Retorno[3] = "SizeOfCode, tamaño del codigo maquina en todas las secciones" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[7] + OpHeader[6] + OpHeader[5] + OpHeader[4], 16);
  156.  
  157.        Retorno[4] = "SizeOfInitializedData, tamaño de la sección de datos iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[11] + OpHeader[10] + OpHeader[9] + OpHeader[8], 16);
  158.  
  159.        Retorno[5] = "SizeOfUninitializedData, tamaño de la sección de datos no iniciados" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[15] + OpHeader[14] + OpHeader[13] + OpHeader[12], 16);
  160.  
  161.        Retorno[6] = "AddressOfEntryPoint, dirección de la primera instrucion que se ejecuta en memoria RVA" + ";" + OpHeader[19] + OpHeader[18] + OpHeader[17] + OpHeader[16];
  162.  
  163.        Retorno[7] = "BaseOfCode,dirección relativa de la base del código RVA" + ";" + OpHeader[23] + OpHeader[22] + OpHeader[21] + OpHeader[20];
  164.  
  165.        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];
  166.  
  167.        Retorno[9] = "ImageBase,dirección base preferida RVAbp" + ";"  + OpHeader[31] + OpHeader[30] + OpHeader[29] + OpHeader[28];
  168.  
  169.        Retorno[10] = "SectionAlignment, alineación de las secciones >= a FileAlignment Pagina32-4096bytes" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[35] + OpHeader[34] + OpHeader[33] + OpHeader[32], 16);
  170.  
  171.        Retorno[11] = "FileAlignment,factor de alineación 512Bytes-64K potencias de 2" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[39] + OpHeader[38] + OpHeader[37] + OpHeader[36], 16);
  172.  
  173.        Retorno[12] = "MajorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[41] + OpHeader[40],16);
  174.  
  175.        Retorno[13] = "MinorOperatingSystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[43] + OpHeader[42],16);
  176.  
  177.        Retorno[14] = "MajorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[45] + OpHeader[44],16);
  178.  
  179.        Retorno[15] = "MinorImageVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[47] + OpHeader[46],16);
  180.  
  181.        Retorno[16] = "MajorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[49] + OpHeader[48],16);
  182.  
  183.        Retorno[17] = "MinorSubsystemVersion," + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[51] + OpHeader[50],16);
  184.  
  185.        Retorno[18] = "Win32VersionValue," + ";" + OpHeader[52] + OpHeader[53] + OpHeader[54] + OpHeader[55];
  186.  
  187.        Retorno[19] = "SizeOfImage,un múltiplo de SectionAlignment" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[59] + OpHeader[58] + OpHeader[57] + OpHeader[56], 16);
  188.  
  189.        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);
  190.  
  191.        Retorno[21] = "CheckSum,algoritmo utilizado se toma de la librería IMAGEHELP.DLL" + ";" + OpHeader[64] + OpHeader[65] + OpHeader[66] + OpHeader[67];
  192.  
  193.        Retorno[22] = "Subsystem, tipo de subsistema necesario" + ";" + OpHeader[68] + OpHeader[69];
  194.  
  195.        Retorno[23] = "DllCharacteristics, punto de entrada para las DLL" + ";" + OpHeader[71] + OpHeader[70];
  196.  
  197.        Retorno[24] = "SizeOfStackReserve, tamaño que se debe reservar en la pila" + ";" + TotalConversor.ConVertBaseDecimal( OpHeader[75] + OpHeader[74] + OpHeader[73] + OpHeader[72], 16);
  198.  
  199.        Retorno[25] = "SizeOfStackCommit, Tamaño utilizado por la pila en men" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[79] + OpHeader[78] + OpHeader[77] + OpHeader[76], 16);
  200.  
  201.        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);
  202.  
  203.        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);
  204.  
  205.        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);
  206.  
  207.        Retorno[29] = "NumberOfRvaAndSizes, Cantidad de DataDirectory" + ";" + TotalConversor.ConVertBaseDecimal(OpHeader[95] + OpHeader[94] + OpHeader[93] + OpHeader[92], 16);
  208.  
  209.        return Retorno;
  210.    }    /* TOTAL 96 BYTES */
  211.  
  212.    public static string[] IMAGE_SECTION_HEADER_40(string[] SeHeader)
  213.    {
  214.        string[] Retorno = new string[10];
  215.  
  216.        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]);
  217.  
  218.        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);
  219.  
  220.        Retorno[2] = "VirtualAddress, dirección del primer byte de la sección RVA" + ";" + SeHeader[15] + SeHeader[14] + SeHeader[13] + SeHeader[12];
  221.  
  222.        Retorno[3] = "SizeOfRawData, tamaño de los datos inicializados" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[19] + SeHeader[18] + SeHeader[17] + SeHeader[16],16);
  223.  
  224.        Retorno[4] = "PointerToRawData, puntero a la primera pagina RVA" + ";" + SeHeader[23] + SeHeader[22] + SeHeader[21] + SeHeader[20];
  225.  
  226.        Retorno[5] = "PointerToRelocations, puntero a la primera if reubicación RVA" + ";" + SeHeader[27] + SeHeader[26] + SeHeader[25] + SeHeader[24];
  227.  
  228.        Retorno[6] = "PointerToLinenumbers, puntero a la primer if numerado RVA" + ";" + SeHeader[31] + SeHeader[30] + SeHeader[29] + SeHeader[28];
  229.  
  230.        Retorno[7] = "NumberOfRelocations" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[33] + SeHeader[32],16);
  231.  
  232.        Retorno[8] = "NumberOfLinenumbers" + ";" + TotalConversor.ConVertBaseDecimal(SeHeader[35] + SeHeader[34],16);
  233.  
  234.        Retorno[9] = "Characteristics" + ";" + SeHeader[39] + SeHeader[38] + SeHeader[37] + SeHeader[36]; //++
  235.  
  236.        return Retorno;
  237.    } // 40 bytes
  238.  
  239.  
  240.    public static string[] IMAGE_DATA_DIRECTORY_8(string[] DiHeader)
  241.    {
  242.        string[] Retorno = new string[2];
  243.  
  244.        Retorno[0] = "VirtualAddress RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];
  245.  
  246.        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)
  247.  
  248.        return Retorno;
  249.  
  250.    } // 8 bytes ojo hay 16 definidos total 128 bytes
  251.  
  252.    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
  253.    { //  DataDirectory
  254.  
  255.        string[] Retorno = new string[11];
  256.  
  257.  
  258.        Retorno[0] = "Characteristics, Export Flags Reserved, must be 0" + ";" + DiHeader[0] + DiHeader[1] + DiHeader[2] + DiHeader[3];
  259.  
  260.        Retorno[1] = "TimeDateStamp," + ";" + TotalConversor.ConvertExaFechaEsamblado(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
  261.  
  262.        Retorno[2] = "Major Version," + ";" + DiHeader[9] + DiHeader[8];
  263.  
  264.        Retorno[3] = "Minor Version," + ";" + DiHeader[11] + DiHeader[10];
  265.  
  266.        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];
  267.  
  268.        Retorno[5] = "Base, El número ordinal inicial DE LAS FUNCIONES" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16],16);
  269.  
  270.        Retorno[6] = "NumberOfFunctions, El número de funciones exportadas por nombre u ordinal" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20],16);
  271.  
  272.        Retorno[7] = "NumberOfName, número de nombres exportados" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24],16);
  273.  
  274.        Retorno[8] = "AddressOfFunctions, RVA apunta a una matriz de valores de 32 bits RVA" + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];
  275.  
  276.        Retorno[9] = "AddressOfName, RVA apunta a una matriz de valores de 32 bits RVA" + ";" + DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32];
  277.  
  278.        Retorno[10] = "AddressOfNameOrdinal, RVA apunta a una matriz de valores de 16 bits RVA" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];
  279.  
  280.        return Retorno;
  281.  
  282.    } // 40 Bytes The .edata Section (Image Only)
  283.  
  284.  
  285.    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
  286.    { //  DataDirectory
  287.  
  288.        string[] Retorno = new string[5];
  289.  
  290.  
  291.        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
  292.  
  293.        Retorno[1] = "TimeDateStamp, valor=  0 o F si es importacion " + ";" + TotalConversor.ConvertExaFechaEsamblado(DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
  294.  
  295.        Retorno[2] = " ForwarderChain, El índice de la primera redirección de la cadena obsoleto" + ";" + DiHeader[11] + DiHeader[10]+ DiHeader[9] + DiHeader[8] ;
  296.  
  297.        Retorno[3] = " Name,  RVA-base ASCII string, nombre de la DLL importada, null-terminated  RVA" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
  298.  
  299.        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
  300.        // una vez cargado apuntan a la misma estructura(original y actual)
  301.        return Retorno;
  302.  
  303.    } // 20 Bytes The .idata Section (Image Only)
  304.  
  305.    public static string Import_String_ASCII(string[] DiHeader) // The .idata Section
  306.    { //  DataDirectory
  307.  
  308.        string Retorno;
  309.  
  310.        Retorno = TotalConversor.HextoStringASCII(string.Concat (DiHeader));
  311.  
  312.        return Retorno;
  313.  
  314.    } // Nº ? Bytes import name
  315.  
  316.  
  317.  
  318.    public static string[] IMAGE_IMPORT_Lookup_8_4(string[] DiHeader) // The .idata Section
  319.    { //  DataDirectory_Import  ordinal o nombre de la funcion importada de la DLL, Bits 63 to 32 are zero. se importa por nombre
  320.  
  321.        string[] Retorno = new string[3];
  322.  
  323.  
  324.  
  325.        if (DiHeader.Length > 4) { Retorno[0] = " OrdinalNameFlag,  Ordinal/Name Flag bit field " + ";" + DiHeader[7]; } else { Retorno[0] = " OrdinalNameFlag,  " + ";" + DiHeader[3]; }
  326.  
  327.  
  328.        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.
  329.        // investigando la DLL obtenemos la función utilizada
  330.        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
  331.  
  332.  
  333.        return Retorno;
  334.  
  335.    } // 8_4 Bytes The .idata. storted in r.data Section (Image Only)
  336.  
  337.  
  338.    public static string[] IMAGE_RESOURCE_DIRECTORY_NODE_HEADER_16(string[] DiHeader) // The .rsrc Section  
  339.    {
  340.  
  341.        string[] Retorno = new string[6];
  342.  
  343.        Retorno[0] = "DWORD Characteristics" + ";" + DiHeader[0] + DiHeader[1] + DiHeader[2] + DiHeader[3]; // Flags Unknown
  344.        Retorno[1] = "DWORD TimeDateStamp" + ";" + TotalConversor.ConvertExaFechaEsamblado( DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]);
  345.        Retorno[2] = "WORD MajorVersion" + ";" + TotalConversor.ConVertBaseDecimal( DiHeader[9] + DiHeader[8],16);
  346.        Retorno[3] = "WORD MinorVersion" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[11] + DiHeader[10],16);
  347.        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
  348.        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.
  349.  
  350.        return Retorno;
  351.  
  352.    } // 16 bytes
  353.  
  354.    public static string[] Resource_Directory_Node_Entry_8(string[] DiHeader) // Resource data descriptor  The .rsrc Section
  355.    {
  356.  
  357.        string[] Retorno = new string[3];
  358.  
  359.        Retorno[0] = "DWORD Name Offset or Integer ID" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // determinado anteriormente  mirar???????
  360.  
  361.        string Binario = TotalConversor.ConVertByteExaBinary(DiHeader[7]);
  362.  
  363.      if (Binario.Substring(0, 1) == "1") { Retorno[2] = "NewDirectory"; DiHeader[7] = TotalConversor.HexQuitarBitAlto(DiHeader[7]) ; } else { Retorno[2] = "DataEntry"; }
  364.  
  365.        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).
  366.  
  367.        return Retorno;
  368.  
  369.    } // 8 bytes
  370.  
  371.    public static string[] Resource_Data_Entry_16(string[] DiHeader)  // The .rsrc Section
  372.    {
  373.  
  374.        string[] Retorno = new string[4];
  375.  
  376.        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
  377.        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.
  378.        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.
  379.        Retorno[3] = "Reserved, must be 0" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
  380.  
  381.        return Retorno;
  382.  
  383.    } // 16 bytes
  384.  
  385.                                                 // String resource data
  386.   // 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.
  387.    public static string[] Resource_Directory_Node_Name_o_Data_String_2_64(string[] DiHeader) // Resource node name string The .rsrc Section
  388.    {
  389.  
  390.        string[] Retorno = new string[3];
  391.  
  392.        int Longitud = 2 * (Convert.ToInt32(TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16)));  // este es un recuento de "WORD = 2" bytes X longitud
  393.        Retorno[0] = "WORD Lenght" + ";" + Longitud.ToString(); // El tamaño de la cadena en bytes, sin incluir el campo de longitud en sí.
  394.        if (Longitud > 62) { Retorno[2] = "Nombre mas grande que 62"; Longitud = 62; } else { Retorno[2] ="Ok"; }
  395.        ArraySegment<String> myArrSegMid = new ArraySegment<String>(DiHeader, 2, Longitud); ////  48
  396.       //  Retorno[1] = "Unicode String" + ";" + TotalConversor.ConVertByteExaCadena(myArrSegMid.ToArray()); ;  // The variable-length Unicode string data, word-aligned.
  397.  
  398.        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.
  399.  
  400.  
  401.        return Retorno;
  402.  
  403.    } // 64 bytes
  404.  
  405.  
  406.  
  407.  
  408.  
  409.  
  410.  
  411.  
  412.  
  413.  
  414.  
  415.  
  416.    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.
  417.    { //  DataDirectory
  418.  
  419.        string[] Retorno = new string[3];    
  420.  
  421.        Retorno[0] = "Long-" + ";" + TotalConversor.ConVertBaseDecimal(DiHeader[1] + DiHeader[0],16);  //  WORD La longitud, en bytes, de la estructura VS_VERSIONINFO
  422.        string LongHija = TotalConversor.ConVertBaseDecimal(DiHeader[3] + DiHeader[2], 16); //
  423.        if (LongHija == "0") { LongHija = "LongHija 0" + ";" + LongHija; } else { LongHija = "LongHija-" + ";" + LongHija; }  //
  424.        Retorno[1] = LongHija; // La longitud, en bytes, del VS_FIXEDFILEINFO y hijas  // WORD
  425.        Retorno[2] =  TotalConversor.ConVertBaseDecimal( DiHeader[5] + DiHeader[4],16); // Es 1 si datos de texto y 0 si datos binarios
  426.  
  427.        return Retorno;
  428.  
  429.    } //
  430.  
  431.  
  432.  
  433.  
  434.    // Obtenemos el string y...  con 64 bytes creo que cubrimos casi todos
  435.    // 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.
  436.    public static string[] RESOURSE_VS_VERSIONINFO_Unicode_string_L_64(string[] DiHeader, int Inicio) //
  437.    { //  DataDirectory
  438.        string[] Retorno = new string[3];
  439.        string[] paso= TotalConversor.StringPading(DiHeader, Inicio);
  440.  
  441.        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.
  442.        Retorno[1] = "Puntero-;" + TotalConversor.ConvertStrimDecExa( paso[1]); // puntero a la siguiente estructura
  443.        Retorno[2] = paso[2];  // si es igual a "ok"  todo salio perfecto....jeje
  444.        return Retorno;
  445.  
  446.    } //
  447.  
  448.  
  449.  
  450.    public static string[] RESOURSE_VS_VERSIONINFO_VS_FIXEDFILEINFO_52(string[] DiHeader) //
  451.    { //  DataDirectory
  452.  
  453.        string[] Retorno = new string[13];
  454.  
  455.        Retorno[0] = "DWORD dwSignature (FEEF04BD)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //
  456.        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" &#8658; 1.0
  457.        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" &#8658; 6.0
  458.        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" &#8658; 6000.16386
  459.        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.
  460.        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.
  461.        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
  462.        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.
  463.        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.
  464.        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.
  465.        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.
  466.        if (Retorno[9].Contains("VFT_DRV")){Retorno[10] = "DWORD dwFileSubtype" + ";" + RESOURSE_VS_FIXEDFILEINFO_VFT_DRV_dwFileSubtype_(DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]); }
  467.        if (Retorno[9].Contains("VFT_FONT")) { Retorno[10] = "DWORD dwFileSubtype" + ";" + RESOURSE_VS_FIXEDFILEINFO_VFT_FONT_dwFileSubtype_(DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40]); }
  468.        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.
  469.        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.
  470.  
  471.        return Retorno;
  472.  
  473.    } //
  474.  
  475.    public static string[] RESOURSE_VS_VERSIONINFO_VS_MUI_(string[] DiHeader) // UNICODE Literal TXT
  476.    { //  DataDirectory
  477.  
  478.        string[] Retorno = new string[13];
  479.  
  480.        Retorno[0] = "DWORD Signature (FECDFECD)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //
  481.        Retorno[1] = "DWORD Size" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   //
  482.        Retorno[2] = "DWORD RC Config Version 10000 " + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //
  483.        Retorno[3] = "DWORD Unknown" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //
  484.        Retorno[4] = "DWORD File type 0x00000011 = normal 0x00000012 = MUI file" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //
  485.        Retorno[5] = "DWORD System attributes" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  //
  486.        Retorno[6] = "DWORD Ultimate fallback location 0x01 = internal 0x02 = external" + ";" + DiHeader[27] + DiHeader[26] + DiHeader[25] + DiHeader[24];  //
  487.        Retorno[7] = "OWORD Service Checksum" + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];  // 16 BYTES 8 WORD
  488.        Retorno[8] = "OWORD Checksum" + ";" + DiHeader[35] + DiHeader[34] + DiHeader[33] + DiHeader[32];  // 16 BYTES 8 WORD
  489.        Retorno[9] = "DOWORD Unknown" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 24 BYTES 12 WORD
  490.        // Value descriptors
  491.        Retorno[10] = "DWORD Main name type data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //AVI FTR ORDERSTREAM TYPELIB UIFILE XML MUI      
  492.        Retorno[11] = "DWORD Main name type data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
  493.        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];  //
  494.        Retorno[14] = "DWORD MUI name type data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //   MOFTYPE MUI WEVT_TEMPLATE
  495.        Retorno[15] = "DWORD MUI name type data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
  496.        Retorno[16] = "DWORD MUI ID types data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
  497.        Retorno[17] = "DWORD MUI ID types data size" + ";" + DiHeader[39] + DiHeader[38] + DiHeader[37] + DiHeader[36];  // 24 BYTES 12 WORD
  498.        Retorno[18] = "DWORD Language data offset" + ";" + DiHeader[43] + DiHeader[42] + DiHeader[41] + DiHeader[40];  //    
  499.        Retorno[19] = "DWORD Language data size" + ";" + DiHeader[47] + DiHeader[46] + DiHeader[45] + DiHeader[44];  //
  500.        Retorno[20] = "DWORD Ultimate fallback language data offset" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
  501.        Retorno[21] = "DWORD Ultimate fallback language data size" + ";" + DiHeader[51] + DiHeader[50] + DiHeader[49] + DiHeader[48];  //
  502.        // VALUE DATA 64-bit aligned
  503.  
  504.        return Retorno;
  505.  
  506.    } //
  507.  
  508.  
  509.    public static string[] RESOURSE_VS_VERSIONINFO_VS_WEVT_TEMPLATE_(string[] DiHeader) // UNICODE Literal TXT
  510.    { //  DataDirectory
  511.        string[] Retorno = new string[6];
  512.  
  513.        Retorno[0] = "DWORD Signature (CRIM)" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  //
  514.        Retorno[1] = "DWORD Size" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   // Including the compiled resource instrumentation manifest header
  515.        Retorno[2] = "WORD Major version 3" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];  //
  516.        Retorno[3] = "WORD Minor version 1" + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];  //
  517.        Retorno[4] = "DWORD Number of event providers" + ";" + DiHeader[19] + DiHeader[18] + DiHeader[17] + DiHeader[16];  //
  518.        Retorno[5] = "DEWORD*Number Array of event provider descriptors" + ";" + DiHeader[23] + DiHeader[22] + DiHeader[21] + DiHeader[20];  // 20 BYTES  10 WORD
  519.  
  520.  
  521.        return Retorno;
  522.  
  523.    } //
  524.  
  525.    public static string[] RESOURSE_VS_VERSIONINFO_TABLA_WEVT_TEMPLATE_(string[] DiHeader) // UNICODE Literal TXT
  526.    { //  DataDirectory
  527.        string[] Retorno = new string[2];
  528.        Retorno[0] = "ODWORD  Contains a GUID" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  // 16 BYTES 8 WORD
  529.        Retorno[1] = "DWORD  data offset " + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];   // start of the instrumentation manifest
  530.  
  531.  
  532.        return Retorno;
  533.  
  534.    } //
  535.  
  536.    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
  537.    {
  538.  
  539.        string[] Retorno = new string[1];
  540.  
  541.        Retorno[0] = "NumberNodeTabla" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // Number of message-table entry descriptors
  542.  
  543.        return Retorno;
  544.  
  545.    } // 4 bytes
  546.  
  547.    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
  548.    {
  549.  
  550.        string[] Retorno = new string[12];
  551.  
  552.        Retorno[0] = "DWORD IdPrimer" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; // Identificador del primer mensaje
  553.        Retorno[1] = "DWORD IdUltimo" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]; // Identificador del último mensaje
  554.        Retorno[2] = "DWORD OffsetPrimer" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8]; // Offset of the first message
  555.  
  556.        return Retorno;
  557.  
  558.    } // 12 bytes
  559.  
  560.    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:
  561.    {
  562.  
  563.        string[] Retorno = new string[3];
  564.  
  565.        Retorno[0] = "WORD Size" + ";" + DiHeader[1] + DiHeader[0]; //
  566.        Retorno[1] = "WORD Flags" + ";" + DiHeader[3] + DiHeader[2]; // 0x00 = extended ASCII string with codepage /  0x01 = UTF-16 string
  567.        Retorno[2] = "? String_L_Padin32" + ";" + "?"; //
  568.        return Retorno;
  569.  
  570.    } // 4 + ?
  571.  
  572.  
  573.  
  574.  
  575.  
  576.  
  577.  
  578.  
  579.    public static string[] IMAGE_DELAY_IMPORT_DESCRIPTOR_32(string[] DiHeader) // The .idata Section (Image Only)
  580.    { //  DataDirectory
  581.  
  582.        string[] Retorno = new string[8];
  583.  
  584.        Retorno[0] = "Attributes,Must be zero." + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0];  // 1  31 reservado
  585.        Retorno[1] = "Name RVA,of the name of the DLL" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4];
  586.        Retorno[2] = "Module Handle RVA, of the module handle ." + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8];
  587.        Retorno[3] = "Delay Import Table RVA, of the delay-load import address table IAT." + ";" + DiHeader[15] + DiHeader[14] + DiHeader[13] + DiHeader[12];
  588.        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];
  589.        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];
  590.        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];
  591.        Retorno[7] = "Time Stamp,The timestamp of the DLL." + ";" + DiHeader[31] + DiHeader[30] + DiHeader[29] + DiHeader[28];
  592.  
  593.        return Retorno;
  594.  
  595.    } // 32 Bytes
  596. }
  597.  
« Última modificación: 22 Diciembre 2020, 23:18 pm por FFernandez » En línea

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #8 en: 10 Diciembre 2020, 21:35 pm »

Constantes



Código
  1. public static string MachineTypes_HEADER_2(string Maquina)
  2.    {
  3.        var Machine = new Dictionary<string, string>
  4.        {
  5.            ["0000"] = " The content of this field is assumed to be applicable to any machine type",                  
  6.            ["01D3"] = "Matsushita AM33",                
  7.            ["8664"] = "x64",
  8.            ["01C0"] = "ARM little endian",
  9.            ["AA64"] = "ARM64 little endian",
  10.            ["01C4"] = "ARM Thumb-2 little endian",
  11.            ["0EBC"] = "EFI byte code",
  12.            ["014C"] = "Intel 386 or later processors and compatible processors",
  13.            ["0200"] = "Intel Itanium processor family",
  14.            ["9041"] = "Mitsubishi M32R little endian",
  15.            ["0266"] = "MIPS16",
  16.            ["0366"] = "MIPS with FPU",
  17.            ["0466"] = "MIPS16 with FPU",
  18.            ["01F0"] = "Power PC little endian",
  19.            ["01F1"] = "Power PC with floating point support",
  20.            ["0166"] = "MIPS little endian",
  21.            ["5032"] = "RISC-V 32-bit address space",
  22.            ["5064"] = "RISC-V 64-bit address space",
  23.            ["5128"] = "RISC-V 128-bit address space",
  24.            ["01A2"] = "Hitachi SH3",
  25.            ["01A3"] = "Hitachi SH3 DSP",
  26.            ["01A6"] = "Hitachi SH4",
  27.            ["01A8"] = "Hitachi SH5",
  28.            ["01C2"] = "Thumb",
  29.            ["0169"] = "MIPS little-endian WCE v2",
  30.            ["None"] = Maquina + " None"  // return new
  31.  
  32.        };
  33.  
  34.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  35.  
  36.        return Machine[Maquina];
  37.    }
  38.  
  39.  
  40.    public static string CharacteristicsFile_HEADER_2(string Maquina)
  41.    {
  42.        var Machine = new Dictionary<string, string>
  43.        {
  44.            ["0001"] = "IMAGE_FILE_RELOCS_STRIPPED",    // Image only, Windows CE, and Microsoft Windows NT and later. This indicates that the file does not contain base relocations and must therefore be loaded at its preferred base address. If the base address is not available, the loader reports an error. The default behavior of the linker is to strip base relocations from executable (EXE) files.
  45.            ["0002"] = "IMAGE_FILE_EXECUTABLE_IMAGE",    // Image only. This indicates that the image file is valid and can be run. If this flag is not set, it indicates a linker error.
  46.            ["0004"] = "IMAGE_FILE_LINE_NUMS_STRIPPED",    // COFF line numbers have been removed. This flag is deprecated and should be zero.
  47.            ["0008"] = "IMAGE_FILE_LOCAL_SYMS_STRIPPED",    // COFF symbol table entries for local symbols have been removed. This flag is deprecated and should be zero.
  48.            ["0010"] = "IMAGE_FILE_AGGRESSIVE_WS_TRIM",    // Obsolete. Aggressively trim working set. This flag is deprecated for Windows 2000 and later and must be zero.
  49.            ["0020"] = "IMAGE_FILE_LARGE_ADDRESS_ AWARE",    // Application can handle > 2-GB addresses.
  50.            ["0040"] = "IMAGE_FILE_FUTURE_USE", // This flag is reserved for future use.
  51.            ["0080"] = "IMAGE_FILE_BYTES_REVERSED_LO",    // Little endian: the least significant bit (LSB) precedes the most significant bit (MSB) in memory. This flag is deprecated and should be zero.
  52.            ["0100"] = "IMAGE_FILE_32BIT_MACHINE",    // Machine is based on a 32-bit-word architecture.
  53.            ["0200"] = "IMAGE_FILE_DEBUG_STRIPPED",    // Debugging information is removed from the image file.
  54.            ["0400"] = "IMAGE_FILE_REMOVABLE_RUN_ FROM_SWAP",    // If the image is on removable media, fully load it and copy it to the swap file.
  55.            ["0800"] = "IMAGE_FILE_NET_RUN_FROM_SWAP",    // If the image is on network media, fully load it and copy it to the swap file.
  56.            ["1000"] = "IMAGE_FILE_SYSTEM",    // The image file is a system file, not a user program.
  57.            ["2000"] = "IMAGE_FILE_DLL",    // The image file is a dynamic-link library (DLL). Such files are considered executable files for almost all purposes, although they cannot be directly run.
  58.            ["4000"] = "IMAGE_FILE_UP_SYSTEM_ONLY",    // The file should be run only on a uniprocessor machine.
  59.            ["8000"] = "IMAGE_FILE_BYTES_REVERSED_HI",    // Big endian: the MSB precedes the LSB in memory. This flag is deprecated and should be zero.
  60.            ["None"] = Maquina + " None"  // return new
  61.  
  62.        };
  63.  
  64.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  65.  
  66.        return Machine[Maquina];
  67.  
  68.    } //
  69.  
  70.  
  71.  
  72.    public static string Subsystem_2(string Maquina)
  73.    {
  74.        var Machine = new Dictionary<string, string>
  75.        {
  76.            ["0"] = "IMAGE_SUBSYSTEM_UNKNOWN",   //An unknown subsystem
  77.            ["1"] = "IMAGE_SUBSYSTEM_NATIVE",   //Device drivers and native Windows processes
  78.            ["2"] = "IMAGE_SUBSYSTEM_WINDOWS_GUI",   //The Windows graphical user interface (GUI) subsystem
  79.            ["3"] = "IMAGE_SUBSYSTEM_WINDOWS_CUI",   //The Windows character subsystem
  80.            ["5"] = "IMAGE_SUBSYSTEM_OS2_CUI",   //The OS/2 character subsystem
  81.            ["7"] = "IMAGE_SUBSYSTEM_POSIX_CUI",   //The Posix character subsystem
  82.            ["8"] = "IMAGE_SUBSYSTEM_NATIVE_WINDOWS",   //Native Win9x driver
  83.            ["9"] = "IMAGE_SUBSYSTEM_WINDOWS_CE_GUI",   //Windows CE
  84.            ["10"] = "IMAGE_SUBSYSTEM_EFI_APPLICATION",   //An Extensible Firmware Interface (EFI) application
  85.            ["11"] = "IMAGE_SUBSYSTEM_EFI_BOOT_ SERVICE_DRIVER",   //An EFI driver with boot services
  86.            ["12"] = "IMAGE_SUBSYSTEM_EFI_RUNTIME_ DRIVER",   //An EFI driver with run-time services
  87.            ["13"] = "IMAGE_SUBSYSTEM_EFI_ROM",   //An EFI ROM image
  88.            ["14"] = "IMAGE_SUBSYSTEM_XBOX",   //XBOX
  89.            ["16"] = "IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION",   //Windows boot application.
  90.            ["None"] = Maquina + " None"  // return new
  91.  
  92.        };
  93.  
  94.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  95.  
  96.        return Machine[Maquina];
  97.  
  98.    } //
  99.  
  100.    public static string DllCharacteristics_OPTIONAL_2(string Maquina)
  101.    {
  102.        var Machine = new Dictionary<string, string>
  103.        {
  104.            ["0001"] = "IMAGE_LIBRARY_PROCESS_INIT",  // Reserved, must be zero.
  105.            ["0002"] = "IMAGE_LIBRARY_PROCESS_TERM",  // Reserved, must be zero.
  106.            ["0004"] = "IMAGE_LIBRARY_THREAD_INIT",  // Reserved, must be zero.
  107.            ["0008"] = "IMAGE_LIBRARY_THREAD_TERM",  // Reserved, must be zero.
  108.            ["0020"] = "IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA",  //Image can handle a high entropy 64-bit virtual address space.
  109.            ["0040"] = "IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE",  // DLL can be relocated at load time.
  110.            ["0080"] = "IMAGE_DLLCHARACTERISTICS_ FORCE_INTEGRITY",  // Code "Integrity checks are enforced.
  111.            ["0100"] = "IMAGE_DLLCHARACTERISTICS_ NX_COMPAT",  // Image "Is NX compatible.
  112.            ["0200"] = "IMAGE_DLLCHARACTERISTICS_ NO_ISOLATION",  //  Isolation aware, but do not "Isolate the "Image.
  113.            ["0400"] = "IMAGE_DLLCHARACTERISTICS_ NO_SEH",  // Does not use structured exception (SE) handling. No SE handler may be called "In this "Image.
  114.            ["0800"] = "IMAGE_DLLCHARACTERISTICS_ NO_BIND",  // Do not bind the "Image.
  115.            ["1000"] = "IMAGE_DLLCHARACTERISTICS_APPCONTAINER",  //  Image must execute "In an AppContainer.
  116.            ["2000"] = "IMAGE_DLLCHARACTERISTICS_ WDM_DRIVER",  // A WDM driver.
  117.            ["4000"] = "IMAGE_DLLCHARACTERISTICS_GUARD_CF",  //  Image supports Control Flow Guard.
  118.            ["8000"] = "IMAGE_DLLCHARACTERISTICS_ TERMINAL_SERVER_AWARE", // Terminal Server aware.
  119.            ["None"] = Maquina + " None"  // return new
  120.  
  121.        };
  122.  
  123.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  124.  
  125.        return Machine[Maquina];
  126.  
  127.    } //
  128.  
  129.  
  130.    public static string Characteristics_SECTION_HEADER_4(string Maquina)
  131.    {
  132.        var Machine = new Dictionary<string, string>
  133.        {
  134.            ["00000000"] = "IMAGE_SCN_TYPE_REG",  // Reserved for future use.
  135.            ["00000001"] = "IMAGE_SCN_TYPE_DSECT or IMAGE_SCN_SCALE_INDEX",  // Reserved for future use. Tls index is scaled
  136.            ["00000002"] = "IMAGE_SCN_TYPE_NOLOAD",  // Reserved for future use.
  137.            ["00000004"] = "IMAGE_SCN_TYPE_GROUP",  // Reserved for future use.
  138.            ["00000008"] = "IMAGE_SCN_TYPE_NO_PAD ",  // The section should not be padded to the next boundary. This flag is obsolete and is replaced by IMAGE_SCN_ALIGN_1BYTES. This is valid only for object files.
  139.            ["00000010"] = "IMAGE_SCN_TYPE_COPY",  // Reserved for future use.
  140.            ["00000020"] = "IMAGE_SCN_CNT_CODE ",  // The section contains executable code.
  141.            ["00000040"] = "IMAGE_SCN_CNT_INITIALIZED_DATA ",  // The section contains initialized data.
  142.            ["00000080"] = "IMAGE_SCN_CNT_UNINITIALIZED_ DATA ",  // The section contains uninitialized data.
  143.            ["00000100"] = "IMAGE_SCN_LNK_OTHER ",  // Reserved for future use.
  144.            ["00000200"] = "IMAGE_SCN_LNK_INFO ",  // The section contains comments or other information. The .drectve section has this type. This is valid for object files only.
  145.            ["00000400"] = "IMAGE_SCN_MEM_PROTECTED - Obsolete",  // Reserved for future use.
  146.            ["00000800"] = "IMAGE_SCN_LNK_REMOVE ",  // The section will not become part of the image. This is valid only for object files.
  147.            ["00001000"] = "IMAGE_SCN_LNK_COMDAT ",  // The section contains COMDAT data. For more information, see COMDAT Sections (Object Only). This is valid only for object files.
  148.            ["00002000"] = "reservado",  // reservado
  149.            ["00004000"] = "IMAGE_SCN_NO_DEFER_SPEC_EXC",  // Reset speculative exceptions
  150.            ["00008000"] = "IMAGE_SCN_GPREL ",  // The section contains data referenced through the global pointer (GP).
  151.            ["00010000"] = "IMAGE_SCN_MEM_SYSHEAP - Obsolete",  // Obsolete
  152.            ["00020000"] = "IMAGE_SCN_MEM_PURGEABLE Or IMAGE_SCN_MEM_16BIT",  // Reserved for future use.
  153.            ["00040000"] = "IMAGE_SCN_MEM_LOCKED ",  // Reserved for future use.
  154.            ["00080000"] = "IMAGE_SCN_MEM_PRELOAD ",  // Reserved for future use.
  155.            ["00100000"] = "IMAGE_SCN_ALIGN_1BYTES ",  // Align data on a 1-byte boundary. Valid only for object files.
  156.            ["00200000"] = "IMAGE_SCN_ALIGN_2BYTES ",  // Align data on a 2-byte boundary. Valid only for object files.
  157.            ["00300000"] = "IMAGE_SCN_ALIGN_4BYTES ",  // Align data on a 4-byte boundary. Valid only for object files.
  158.            ["00400000"] = "IMAGE_SCN_ALIGN_8BYTES ",  // Align data on an 8-byte boundary. Valid only for object files.
  159.            ["00500000"] = "IMAGE_SCN_ALIGN_16BYTES ",  // Align data on a 16-byte boundary. Valid only for object files.
  160.            ["00600000"] = "IMAGE_SCN_ALIGN_32BYTES ",  // Align data on a 32-byte boundary. Valid only for object files.
  161.            ["00700000"] = "IMAGE_SCN_ALIGN_64BYTES ",  // Align data on a 64-byte boundary. Valid only for object files.
  162.            ["00800000"] = "IMAGE_SCN_ALIGN_128BYTES ",  // Align data on a 128-byte boundary. Valid only for object files.
  163.            ["00900000"] = "IMAGE_SCN_ALIGN_256BYTES ",  // Align data on a 256-byte boundary. Valid only for object files.
  164.            ["00A00000"] = "IMAGE_SCN_ALIGN_512BYTES ",  // Align data on a 512-byte boundary. Valid only for object files.
  165.            ["00B00000"] = "IMAGE_SCN_ALIGN_1024BYTES ",  // Align data on a 1024-byte boundary. Valid only for object files.
  166.            ["00C00000"] = "IMAGE_SCN_ALIGN_2048BYTES ",  // Align data on a 2048-byte boundary. Valid only for object files.
  167.            ["00D00000"] = "IMAGE_SCN_ALIGN_4096BYTES ",  // Align data on a 4096-byte boundary. Valid only for object files.
  168.            ["00E00000"] = "IMAGE_SCN_ALIGN_8192BYTES ",  // Align data on an 8192-byte boundary. Valid only for object files.
  169.            ["00F00000"] = "IMAGE_SCN_ALIGN_MASK",  // unused
  170.            ["01000000"] = "IMAGE_SCN_LNK_NRELOC_OVFL ",  // The section contains extended relocations. > 16 Bits NumberOfRelocations >= 0xffff => is stored in the 32-bit VirtualAddress field of the first relocation
  171.            ["02000000"] = "IMAGE_SCN_MEM_DISCARDABLE ",  // The section can be discarded as needed.
  172.            ["04000000"] = "IMAGE_SCN_MEM_NOT_CACHED ",  // The section cannot be cached.
  173.            ["08000000"] = "IMAGE_SCN_MEM_NOT_PAGED ",  // The section is not pageable.
  174.            ["10000000"] = "IMAGE_SCN_MEM_SHARED ",  // The section can be shared in memory.
  175.            ["20000000"] = "IMAGE_SCN_MEM_EXECUTE ",  // The section can be executed as code.
  176.            ["40000000"] = "IMAGE_SCN_MEM_READ ",  // The section can be read.
  177.            ["80000000"] = "IMAGE_SCN_MEM_WRITE ",  // The section can be written to.
  178.            ["None"] = Maquina + " None"  // return new
  179.  
  180.        };
  181.  
  182.        if(Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  183.  
  184.        return Machine[Maquina];
  185.  
  186.    } //
  187.  
  188.    public static string CodePage_4(string Maquina)
  189.    {
  190.        var Machine = new Dictionary<string, string>
  191.        {
  192.            ["0"] = "default to ANSI code page",
  193.            ["37"] = "IBM037 IBM EBCDIC US-Canada",
  194.            ["437"] = "IBM437 OEM United States",
  195.            ["500"] = "IBM500 IBM EBCDIC International",
  196.            ["708"] = "ASMO-708 Arabic (ASMO 708)",
  197.            ["709"] = " Arabic (ASMO-449+, BCON V4)",
  198.            ["710"] = " Arabic - Transparent Arabic",
  199.            ["720"] = "DOS-720 Arabic (Transparent ASMO); Arabic (DOS)",
  200.            ["737"] = "ibm737 OEM Greek (formerly 437G); Greek (DOS)",
  201.            ["775"] = "ibm775 OEM Baltic; Baltic (DOS)",
  202.            ["850"] = "ibm850 OEM Multilingual Latin 1; Western European (DOS)",
  203.            ["852"] = "ibm852 OEM Latin 2; Central European (DOS)",
  204.            ["855"] = "IBM855 OEM Cyrillic (primarily Russian)",
  205.            ["857"] = "ibm857 OEM Turkish; Turkish (DOS)",
  206.            ["858"] = "IBM00858 OEM Multilingual Latin 1 + Euro symbol",
  207.            ["860"] = "IBM860 OEM Portuguese; Portuguese (DOS)",
  208.            ["861"] = "ibm861 OEM Icelandic; Icelandic (DOS)",
  209.            ["862"] = "DOS-862 OEM Hebrew; Hebrew (DOS)",
  210.            ["863"] = "IBM863 OEM French Canadian; French Canadian (DOS)",
  211.            ["864"] = "IBM864 OEM Arabic; Arabic (864)",
  212.            ["865"] = "IBM865 OEM Nordic; Nordic (DOS)",
  213.            ["866"] = "cp866 OEM Russian; Cyrillic (DOS)",
  214.            ["869"] = "ibm869 OEM Modern Greek; Greek, Modern (DOS)",
  215.            ["870"] = "IBM870 IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2",
  216.            ["874"] = "windows-874 Thai (Windows)",
  217.            ["875"] = "cp875 IBM EBCDIC Greek Modern",
  218.            ["932"] = "shift_jis ANSI/OEM Japanese; Japanese (Shift-JIS)",
  219.            ["936"] = "gb2312 ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)",
  220.            ["949"] = "ks_c_5601-1987 ANSI/OEM Korean (Unified Hangul Code)",
  221.            ["950"] = "big5 ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5)",
  222.            ["1026"] = "IBM1026 IBM EBCDIC Turkish (Latin 5)",
  223.            ["1047"] = "IBM01047 IBM EBCDIC Latin 1/Open System",
  224.            ["1140"] = "IBM01140 IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro)",
  225.            ["1141"] = "IBM01141 IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro)",
  226.            ["1142"] = "IBM01142 IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro)",
  227.            ["1143"] = "IBM01143 IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro)",
  228.            ["1144"] = "IBM01144 IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro)",
  229.            ["1145"] = "IBM01145 IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro)",
  230.            ["1146"] = "IBM01146 IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro)",
  231.            ["1147"] = "IBM01147 IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro)",
  232.            ["1148"] = "IBM01148 IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro)",
  233.            ["1149"] = "IBM01149 IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro)",
  234.            ["1200"] = "utf-16 Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications",
  235.            ["1201"] = "unicodeFFFE Unicode UTF-16, big endian byte order; available only to managed applications",
  236.            ["1250"] = "windows-1250 ANSI Central European; Central European (Windows)",
  237.            ["1251"] = "windows-1251 ANSI Cyrillic; Cyrillic (Windows)",
  238.            ["1252"] = "windows-1252 ANSI Latin 1; Western European (Windows)",
  239.            ["1253"] = "windows-1253 ANSI Greek; Greek (Windows)",
  240.            ["1254"] = "windows-1254 ANSI Turkish; Turkish (Windows)",
  241.            ["1255"] = "windows-1255 ANSI Hebrew; Hebrew (Windows)",
  242.            ["1256"] = "windows-1256 ANSI Arabic; Arabic (Windows)",
  243.            ["1257"] = "windows-1257 ANSI Baltic; Baltic (Windows)",
  244.            ["1258"] = "windows-1258 ANSI/OEM Vietnamese; Vietnamese (Windows)",
  245.            ["1361"] = "Johab Korean (Johab)",
  246.            ["10000"] = "macintosh MAC Roman; Western European (Mac)",
  247.            ["10001"] = "x-mac-japanese Japanese (Mac)",
  248.            ["10002"] = "x-mac-chinesetrad MAC Traditional Chinese (Big5); Chinese Traditional (Mac)",
  249.            ["10003"] = "x-mac-korean Korean (Mac)",
  250.            ["10004"] = "x-mac-arabic Arabic (Mac)",
  251.            ["10005"] = "x-mac-hebrew Hebrew (Mac)",
  252.            ["10006"] = "x-mac-greek Greek (Mac)",
  253.            ["10007"] = "x-mac-cyrillic Cyrillic (Mac)",
  254.            ["10008"] = "x-mac-chinesesimp MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac)",
  255.            ["10010"] = "x-mac-romanian Romanian (Mac)",
  256.            ["10017"] = "x-mac-ukrainian Ukrainian (Mac)",
  257.            ["10021"] = "x-mac-thai Thai (Mac)",
  258.            ["10029"] = "x-mac-ce MAC Latin 2; Central European (Mac)",
  259.            ["10079"] = "x-mac-icelandic Icelandic (Mac)",
  260.            ["10081"] = "x-mac-turkish Turkish (Mac)",
  261.            ["10082"] = "x-mac-croatian Croatian (Mac)",
  262.            ["12000"] = "utf-32 Unicode UTF-32, little endian byte order; available only to managed applications",
  263.            ["12001"] = "utf-32BE Unicode UTF-32, big endian byte order; available only to managed applications",
  264.            ["20000"] = "x-Chinese_CNS CNS Taiwan; Chinese Traditional (CNS)",
  265.            ["20001"] = "x-cp20001 TCA Taiwan",
  266.            ["20002"] = "x_Chinese-Eten Eten Taiwan; Chinese Traditional (Eten)",
  267.            ["20003"] = "x-cp20003 IBM5550 Taiwan",
  268.            ["20004"] = "x-cp20004 TeleText Taiwan",
  269.            ["20005"] = "x-cp20005 Wang Taiwan",
  270.            ["20105"] = "x-IA5 IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5)",
  271.            ["20106"] = "x-IA5-German IA5 German (7-bit)",
  272.            ["20107"] = "x-IA5-Swedish IA5 Swedish (7-bit)",
  273.            ["20108"] = "x-IA5-Norwegian IA5 Norwegian (7-bit)",
  274.            ["20127"] = "us-ascii US-ASCII (7-bit)",
  275.            ["20261"] = "x-cp20261 T.61",
  276.            ["20269"] = "x-cp20269 ISO 6937 Non-Spacing Accent",
  277.            ["20273"] = "IBM273 IBM EBCDIC Germany",
  278.            ["20277"] = "IBM277 IBM EBCDIC Denmark-Norway",
  279.            ["20278"] = "IBM278 IBM EBCDIC Finland-Sweden",
  280.            ["20280"] = "IBM280 IBM EBCDIC Italy",
  281.            ["20284"] = "IBM284 IBM EBCDIC Latin America-Spain",
  282.            ["20285"] = "IBM285 IBM EBCDIC United Kingdom",
  283.            ["20290"] = "IBM290 IBM EBCDIC Japanese Katakana Extended",
  284.            ["20297"] = "IBM297 IBM EBCDIC France",
  285.            ["20420"] = "IBM420 IBM EBCDIC Arabic",
  286.            ["20423"] = "IBM423 IBM EBCDIC Greek",
  287.            ["20424"] = "IBM424 IBM EBCDIC Hebrew",
  288.            ["20833"] = "x-EBCDIC-KoreanExtended IBM EBCDIC Korean Extended",
  289.            ["20838"] = "IBM-Thai IBM EBCDIC Thai",
  290.            ["20866"] = "koi8-r Russian (KOI8-R); Cyrillic (KOI8-R)",
  291.            ["20871"] = "IBM871 IBM EBCDIC Icelandic",
  292.            ["20880"] = "IBM880 IBM EBCDIC Cyrillic Russian",
  293.            ["20905"] = "IBM905 IBM EBCDIC Turkish",
  294.            ["20924"] = "IBM00924 IBM EBCDIC Latin 1/Open System (1047 + Euro symbol)",
  295.            ["20932"] = "EUC-JP Japanese (JIS 0208-1990 and 0212-1990)",
  296.            ["20936"] = "x-cp20936 Simplified Chinese (GB2312); Chinese Simplified (GB2312-80)",
  297.            ["20949"] = "x-cp20949 Korean Wansung",
  298.            ["21025"] = "cp1025 IBM EBCDIC Cyrillic Serbian-Bulgarian",
  299.            ["21027"] = " (deprecated)",
  300.            ["21866"] = "koi8-u Ukrainian (KOI8-U); Cyrillic (KOI8-U)",
  301.            ["28591"] = "iso-8859-1 ISO 8859-1 Latin 1; Western European (ISO)",
  302.            ["28592"] = "iso-8859-2 ISO 8859-2 Central European; Central European (ISO)",
  303.            ["28593"] = "iso-8859-3 ISO 8859-3 Latin 3",
  304.            ["28594"] = "iso-8859-4 ISO 8859-4 Baltic",
  305.            ["28595"] = "iso-8859-5 ISO 8859-5 Cyrillic",
  306.            ["28596"] = "iso-8859-6 ISO 8859-6 Arabic",
  307.            ["28597"] = "iso-8859-7 ISO 8859-7 Greek",
  308.            ["28598"] = "iso-8859-8 ISO 8859-8 Hebrew; Hebrew (ISO-Visual)",
  309.            ["28599"] = "iso-8859-9 ISO 8859-9 Turkish",
  310.            ["28603"] = "iso-8859-13 ISO 8859-13 Estonian",
  311.            ["28605"] = "iso-8859-15 ISO 8859-15 Latin 9",
  312.            ["29001"] = "x-Europa Europa 3",
  313.            ["38598"] = "iso-8859-8-i ISO 8859-8 Hebrew; Hebrew (ISO-Logical)",
  314.            ["50220"] = "iso-2022-jp ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)",
  315.            ["50221"] = "csISO2022JP ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana)",
  316.            ["50222"] = "iso-2022-jp ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI)",
  317.            ["50225"] = "iso-2022-kr ISO 2022 Korean",
  318.            ["50227"] = "x-cp50227 ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022)",
  319.            ["50229"] = " ISO 2022 Traditional Chinese",
  320.            ["50930"] = " EBCDIC Japanese (Katakana) Extended",
  321.            ["50931"] = " EBCDIC US-Canada and Japanese",
  322.            ["50933"] = " EBCDIC Korean Extended and Korean",
  323.            ["50935"] = " EBCDIC Simplified Chinese Extended and Simplified Chinese",
  324.            ["50936"] = " EBCDIC Simplified Chinese",
  325.            ["50937"] = " EBCDIC US-Canada and Traditional Chinese",
  326.            ["50939"] = " EBCDIC Japanese (Latin) Extended and Japanese",
  327.            ["51932"] = "euc-jp EUC Japanese",
  328.            ["51936"] = "EUC-CN EUC Simplified Chinese; Chinese Simplified (EUC)",
  329.            ["51949"] = "euc-kr EUC Korean",
  330.            ["51950"] = " EUC Traditional Chinese",
  331.            ["52936"] = "hz-gb-2312 HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ)",
  332.            ["54936"] = "GB18030 Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030)",
  333.            ["57002"] = "x-iscii-de ISCII Devanagari",
  334.            ["57003"] = "x-iscii-be ISCII Bangla",
  335.            ["57004"] = "x-iscii-ta ISCII Tamil",
  336.            ["57005"] = "x-iscii-te ISCII Telugu",
  337.            ["57006"] = "x-iscii-as ISCII Assamese",
  338.            ["57007"] = "x-iscii-or ISCII Odia",
  339.            ["57008"] = "x-iscii-ka ISCII Kannada",
  340.            ["57009"] = "x-iscii-ma ISCII Malayalam",
  341.            ["57010"] = "x-iscii-gu ISCII Gujarati",
  342.            ["57011"] = "x-iscii-pa ISCII Punjabi",
  343.            ["65000"] = "utf-7 Unicode (UTF-7)",
  344.            ["65001"] = "utf-8 Unicode (UTF-8)",
  345.            ["None"] = Maquina + " None" // return new
  346.  
  347.        };
  348.  
  349.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  350.  
  351.        return Machine[Maquina];
  352.    }
  353.  
  354. public static string Resourse_Types_MAKEINTRESOURCE(string Maquina)
  355.    {
  356.        var Machine = new Dictionary<string, string>
  357.        {
  358.            ["9"] = "RT_ACCELERATOR", // Accelerator table.
  359.            ["21"] = "RT_ANICURSOR", // Animated cursor.
  360.            ["22"] = "RT_ANIICON", // Animated icon.
  361.            ["2"] = "RT_BITMAP", // Bitmap resource.
  362.            ["1"] = "RT_CURSOR", // Hardware-dependent cursor resource.
  363.            ["5"] = "RT_DIALOG", // Dialog box.
  364.            ["17"] = "RT_DLGINCLUDE", //  Por ejemplo, 1 DLGINCLUDE "MyFile.h"
  365.            ["8"] = "RT_FONT", // Font resource.
  366.            ["7"] = "RT_FONTDIR", // Font directory resource.
  367.            ["12"] = "RT_GROUP_CURSOR", // RT_CURSOR + 11 Hardware-independent cursor resource.
  368.            ["14"] = "RT_GROUP_ICON", // RT_ICON  + 11 Hardware-independent icon resource.
  369.            ["23"] = "RT_HTML", // HTML resource.
  370.            ["3"] = "RT_ICON", // Hardware-dependent icon resource.
  371.            ["24"] = "RT_MANIFEST", // Side-by-Side Assembly Manifest.
  372.            ["4"] = "RT_MENU", // Menu resource.
  373.            ["11"] = "RT_MESSAGETABLE", // Message-table entry.
  374.            ["19"] = "RT_PLUGPLAY", // Plug and Play resource.
  375.            ["10"] = "RT_RCDATA", // Application-defined resource (raw data).
  376.            ["6"] = "RT_STRING", // String-table entry.
  377.            ["16"] = "RT_VERSION", // Version resource.
  378.            ["20"] = "RT_VXD", // VXD.
  379.            ["None"] = Maquina + " None"  // return new
  380.  
  381.        };
  382.  
  383.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  384.  
  385.        return Machine[Maquina];
  386.  
  387.    } //
  388.  
  389.  
« Última modificación: 14 Diciembre 2020, 19:28 pm por FFernandez » En línea

FFernandez

Desconectado Desconectado

Mensajes: 80



Ver Perfil
Re: Estructuras Binarias x86-64
« Respuesta #9 en: 14 Diciembre 2020, 19:30 pm »

Constantes


Código
  1.  public static string Language_Int(string Maquina)
  2.    {
  3.        var Machine = new Dictionary<string, string>
  4.        {
  5.  
  6.            ["1025"] = "Arabic - Saudi Arabia",  // ar-SA
  7.            ["1026"] = "Bulgarian",  // bg-BG
  8.            ["1027"] = "Catalan",  // ca-ES
  9.            ["1028"] = "Chinese - Taiwan",  // zh-TW
  10.            ["1029"] = "Czech",  // cs-CZ
  11.            ["1030"] = "Danish",  // da-DK
  12.            ["1031"] = "German - Germany",  // de-DE
  13.            ["1032"] = "Greek",  // el-GR
  14.            ["1033"] = "English - United States",  // en-US
  15.            ["1034"] = "Spanish - Spain (Traditional Sort)",  // es-ES
  16.            ["1035"] = "Finnish",  // fi-FI
  17.            ["1036"] = "French - France",  // fr-FR
  18.            ["1037"] = "Hebrew",  // he-IL
  19.            ["1038"] = "Hungarian",  // hu-HU
  20.            ["1039"] = "Icelandic",  // is-IS
  21.            ["1040"] = "Italian - Italy",  // it-IT
  22.            ["1041"] = "Japanese",  // ja-JP
  23.            ["1042"] = "Korean",  // ko-KR
  24.            ["1043"] = "Dutch - Netherlands",  // nl-NL
  25.            ["1044"] = "Norwegian (Bokmål)",  // nb-NO
  26.            ["1045"] = "Polish",  // pl-PL
  27.            ["1046"] = "Portuguese - Brazil",  // pt-BR
  28.            ["1047"] = "Rhaeto-Romanic",  // rm-CH
  29.            ["1048"] = "Romanian",  // ro-RO
  30.            ["1049"] = "Russian",  // ru-RU
  31.            ["1050"] = "Croatian",  // hr-HR
  32.            ["1051"] = "Slovak",  // sk-SK
  33.            ["1052"] = "Albanian - Albania",  // sq-AL
  34.            ["1053"] = "Swedish",  // sv-SE
  35.            ["1054"] = "Thai",  // th-TH
  36.            ["1055"] = "Turkish",  // tr-TR
  37.            ["1056"] = "Urdu - Pakistan",  // ur-PK
  38.            ["1057"] = "Indonesian",  // id-ID
  39.            ["1058"] = "Ukrainian",  // uk-UA
  40.            ["1059"] = "Belarusian",  // be-BY
  41.            ["1060"] = "Slovenian",  // sl-SI
  42.            ["1061"] = "Estonian",  // et-EE
  43.            ["1062"] = "Latvian",  // lv-LV
  44.            ["1063"] = "Lithuanian",  // lt-LT
  45.            ["1064"] = "Tajik",  // tg-Cyrl-TJ
  46.            ["1065"] = "Persian",  // fa-IR
  47.            ["1066"] = "Vietnamese",  // vi-VN
  48.            ["1067"] = "Armenian - Armenia",  // hy-AM
  49.            ["1068"] = "Azeri (Latin)",  // az-Latn-AZ
  50.            ["1069"] = "Basque",  // eu-ES
  51.            ["1070"] = "Sorbian",  // wen-DE
  52.            ["1071"] = "F.Y.R.O. Macedonian",  // mk-MK
  53.            ["1072"] = "Sutu",  // st-ZA
  54.            ["1073"] = "Tsonga",  // ts-ZA
  55.            ["1074"] = "Tswana",  // tn-ZA
  56.            ["1075"] = "Venda",  // ven-ZA
  57.            ["1076"] = "Xhosa",  // xh-ZA
  58.            ["1077"] = "Zulu",  // zu-ZA
  59.            ["1078"] = "Afrikaans - South Africa",  // af-ZA
  60.            ["1079"] = "Georgian",  // ka-GE
  61.            ["1080"] = "Faroese",  // fo-FO
  62.            ["1081"] = "Hindi",  // hi-IN
  63.            ["1082"] = "Maltese",  // mt-MT
  64.            ["1083"] = "Sami",  // se-NO
  65.            ["1084"] = "Gaelic (Scotland)",  // gd-GB
  66.            ["1085"] = "Yiddish",  // yi
  67.            ["1086"] = "Malay - Malaysia",  // ms-MY
  68.            ["1087"] = "Kazakh",  // kk-KZ
  69.            ["1088"] = "Kyrgyz (Cyrillic)",  // ky-KG
  70.            ["1089"] = "Swahili",  // sw-que
  71.            ["1090"] = "Turkmen",  // tk-TM
  72.            ["1091"] = "Uzbek (Latin)",  // uz-Latn-UZ
  73.            ["1092"] = "Tatar",  // tt-RU
  74.            ["1093"] = "Bengali (India)",  // bn-IN
  75.            ["1094"] = "Punjabi",  // pa-IN
  76.            ["1095"] = "Gujarati",  // gu-IN
  77.            ["1096"] = "Oriya",  // or-IN
  78.            ["1097"] = "Tamil",  // ta-IN
  79.            ["1098"] = "Telugu",  // te-IN
  80.            ["1099"] = "Kannada",  // kn-IN
  81.            ["1100"] = "Malayalam",  // ml-IN
  82.            ["1101"] = "Assamese",  // as-IN
  83.            ["1102"] = "Marathi",  // mr-IN
  84.            ["1103"] = "Sanskrit",  // sa-IN
  85.            ["1104"] = "Mongolian (Cyrillic)",  // mn-MN
  86.            ["1105"] = "Tibetan - People's Republic of China",  // bo-CN
  87.            ["1106"] = "Welsh",  // cy-GB
  88.            ["1107"] = "Khmer",  // km-KH
  89.            ["1108"] = "Lao",  // lo-LA
  90.            ["1109"] = "Burmese",  // my-MM
  91.            ["1110"] = "Galician",  // gl-ES
  92.            ["1111"] = "Konkani",  // kok-IN
  93.            ["1112"] = "Manipuri",  // mni
  94.            ["1113"] = "Sindhi - India",  // sd-IN
  95.            ["1114"] = "Syriac",  // syr-SY
  96.            ["1115"] = "Sinhalese - Sri Lanka",  // si-LK
  97.            ["1116"] = "Cherokee - United States",  // chr-US
  98.            ["1117"] = "Inuktitut",  // iu-Cans-CA
  99.            ["1118"] = "Amharic - Ethiopia",  // am-ET
  100.            ["1119"] = "Tamazight (Arabic)",  // tmz
  101.            ["1120"] = "Kashmiri (Arabic)",  // ks-Arab-IN
  102.            ["1121"] = "Nepali",  // ne-NP
  103.            ["1122"] = "Frisian - Netherlands",  // fy-NL
  104.            ["1123"] = "Pashto",  // ps-AF
  105.            ["1124"] = "Filipino",  // fil-PH
  106.            ["1125"] = "Divehi",  // dv-MV
  107.            ["1126"] = "Edo",  // bin-NG
  108.            ["1127"] = "Fulfulde - Nigeria",  // fuv-NG
  109.            ["1128"] = "Hausa - Nigeria",  // ha-Latn-NG
  110.            ["1129"] = "Ibibio - Nigeria",  // ibb-NG
  111.            ["1130"] = "Yoruba",  // yo-NG
  112.            ["1131"] = "Quecha - Bolivia",  // quz-BO
  113.            ["1132"] = "Sepedi",  // nso-ZA
  114.            ["1136"] = "Igbo - Nigeria",  // ig-NG
  115.            ["1137"] = "Kanuri - Nigeria",  // kr-NG
  116.            ["1138"] = "Oromo",  // gaz-ET
  117.            ["1139"] = "Tigrigna - Ethiopia",  // ti-ER
  118.            ["1140"] = "Guarani - Paraguay",  // gn-PY
  119.            ["1141"] = "Hawaiian - United States",  // haw-US
  120.            ["1142"] = "Latin",  // la
  121.            ["1143"] = "Somali",  // so-SO
  122.            ["1144"] = "Yi",  // ii-CN
  123.            ["1145"] = "Papiamentu",  // pap-AN
  124.            ["1152"] = "Uighur - China",  // ug-Arab-CN
  125.            ["1153"] = "Maori - New Zealand",  // mi-NZ
  126.            ["2049"] = "Arabic - Iraq",  // ar-IQ
  127.            ["2052"] = "Chinese - People's Republic of China",  // zh-CN
  128.            ["2055"] = "German - Switzerland",  // de-CH
  129.            ["2057"] = "English - United Kingdom",  // en-GB
  130.            ["2058"] = "Spanish - Mexico",  // es-MX
  131.            ["2060"] = "French - Belgium",  // fr-BE
  132.            ["2064"] = "Italian - Switzerland",  // it-CH
  133.            ["2067"] = "Dutch - Belgium",  // nl-BE
  134.            ["2068"] = "Norwegian (Nynorsk)",  // nn-NO
  135.            ["2070"] = "Portuguese - Portugal",  // pt-PT
  136.            ["2072"] = "Romanian - Moldava",  // ro-MD
  137.            ["2073"] = "Russian - Moldava",  // ru-MD
  138.            ["2074"] = "Serbian (Latin)",  // sr-Latn-CS
  139.            ["2077"] = "Swedish - Finland",  // sv-FI
  140.            ["2080"] = "Urdu - India",  // ur-IN
  141.            ["2092"] = "Azeri (Cyrillic)",  // az-Cyrl-AZ
  142.            ["2108"] = "Gaelic (Ireland)",  // ga-IE
  143.            ["2110"] = "Malay - Brunei Darussalam",  // ms-BN
  144.            ["2115"] = "Uzbek (Cyrillic)",  // uz-Cyrl-UZ
  145.            ["2117"] = "Bengali (Bangladesh)",  // bn-BD
  146.            ["2118"] = "Punjabi (Pakistan)",  // pa-PK
  147.            ["2128"] = "Mongolian (Mongolian)",  // mn-Mong-CN
  148.            ["2129"] = "Tibetan - Bhutan",  // bo-BT
  149.            ["2137"] = "Sindhi - Pakistan",  // sd-PK
  150.            ["2143"] = "Tamazight (Latin)",  // tzm-Latn-DZ
  151.            ["2144"] = "Kashmiri (Devanagari)",  // ks-Deva-IN
  152.            ["2145"] = "Nepali - India",  // ne-IN
  153.            ["2155"] = "Quecha - Ecuador",  // quz-EC
  154.            ["2163"] = "Tigrigna - Eritrea",  // ti-ET
  155.            ["3073"] = "Arabic - Egypt",  // ar-EG
  156.            ["3076"] = "Chinese - Hong Kong SAR",  // zh-HK
  157.            ["3079"] = "German - Austria",  // de-AT
  158.            ["3081"] = "English - Australia",  // en-AU
  159.            ["3082"] = "Spanish - Spain (Modern Sort)",  // es-ES
  160.            ["3084"] = "French - Canada",  // fr-CA
  161.            ["3098"] = "Serbian (Cyrillic)",  // sr-Cyrl-CS
  162.            ["3179"] = "Quecha - Peru",  // quz-PE
  163.            ["4097"] = "Arabic - Libya",  // ar-LY
  164.            ["4100"] = "Chinese - Singapore",  // zh-SG
  165.            ["4103"] = "German - Luxembourg",  // de-LU
  166.            ["4105"] = "English - Canada",  // en-CA
  167.            ["4106"] = "Spanish - Guatemala",  // es-GT
  168.            ["4108"] = "French - Switzerland",  // fr-CH
  169.            ["4122"] = "Croatian (Bosnia/Herzegovina)",  // hr-BA
  170.            ["5121"] = "Arabic - Algeria",  // ar-DZ
  171.            ["5124"] = "Chinese - Macao SAR",  // zh-MO
  172.            ["5127"] = "German - Liechtenstein",  // de-LI
  173.            ["5129"] = "English - New Zealand",  // en-NZ
  174.            ["5130"] = "Spanish - Costa Rica",  // es-CR
  175.            ["5132"] = "French - Luxembourg",  // fr-LU
  176.            ["5146"] = "Bosnian (Bosnia/Herzegovina)",  // bs-Latn-BA
  177.            ["6145"] = "Arabic - Morocco",  // ar-MO
  178.            ["6153"] = "English - Ireland",  // en-IE
  179.            ["6154"] = "Spanish - Panama",  // es-PA
  180.            ["6156"] = "French - Monaco",  // fr-MC
  181.            ["7169"] = "Arabic - Tunisia",  // ar-TN
  182.            ["7177"] = "English - South Africa",  // en-ZA
  183.            ["7178"] = "Spanish - Dominican Republic",  // es-DO
  184.            ["7180"] = "French - West Indies",  // fr-029
  185.            ["8193"] = "Arabic - Oman",  // ar-OM
  186.            ["8201"] = "English - Jamaica",  // en-JM
  187.            ["8202"] = "Spanish - Venezuela",  // es-VE
  188.            ["8204"] = "French - Reunion",  // fr-RE
  189.            ["9217"] = "Arabic - Yemen",  // ar-YE
  190.            ["9225"] = "English - Caribbean",  // en-029
  191.            ["9226"] = "Spanish - Colombia",  // es-CO
  192.            ["9228"] = "French - Democratic Rep. of Congo",  // fr-CG
  193.            ["10241"] = "Arabic - Syria",  // ar-SY
  194.            ["10249"] = "English - Belize",  // en-BZ
  195.            ["10250"] = "Spanish - Peru",  // es-PE
  196.            ["10252"] = "French - Senegal",  // fr-SN
  197.            ["11265"] = "Arabic - Jordan",  // ar-JO
  198.            ["11273"] = "English - Trinidad",  // en-TT
  199.            ["11274"] = "Spanish - Argentina",  // es-AR
  200.            ["11276"] = "French - Cameroon",  // fr-CM
  201.            ["12289"] = "Arabic - Lebanon",  // ar-LB
  202.            ["12297"] = "English - Zimbabwe",  // en-ZW
  203.            ["12298"] = "Spanish - Ecuador",  // es-EC
  204.            ["12300"] = "French - Cote d'Ivoire",  // fr-CI
  205.            ["13313"] = "Arabic - Kuwait",  // ar-KW
  206.            ["13321"] = "English - Philippines",  // en-PH
  207.            ["13322"] = "Spanish - Chile",  // es-CL
  208.            ["13324"] = "French - Mali",  // fr-ML
  209.            ["14337"] = "Arabic - U.A.E.",  // ar-AE
  210.            ["14345"] = "English - Indonesia",  // en-ID
  211.            ["14346"] = "Spanish - Uruguay",  // es-UY
  212.            ["14348"] = "French - Morocco",  // fr-MA
  213.            ["15361"] = "Arabic - Bahrain",  // ar-BH
  214.            ["15369"] = "English - Hong Kong SAR",  // en-HK
  215.            ["15370"] = "Spanish - Paraguay",  // es-PY
  216.            ["15372"] = "French - Haiti",  // fr-HT
  217.            ["16385"] = "Arabic - Qatar",  // ar-QA
  218.            ["16393"] = "English - India",  // en-IN
  219.            ["16394"] = "Spanish - Bolivia",  // es-BO
  220.            ["17417"] = "English - Malaysia",  // en-MY
  221.            ["17418"] = "Spanish - El Salvador",  // es-SV
  222.            ["18441"] = "English - Singapore",  // en-SG
  223.            ["18442"] = "Spanish - Honduras",  // es-HN
  224.            ["19466"] = "Spanish - Nicaragua",  // es-NI
  225.            ["20490"] = "Spanish - Puerto Rico",  // es-PR
  226.            ["21514"] = "Spanish - United States",  // es-US
  227.            ["58378"] = "Spanish - Latin America",  // es-419
  228.            ["58380"] = "French - North Africa",  // fr-015
  229.            ["None"] = Maquina + " None" // return new
  230.  
  231.        };
  232.  
  233.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  234.  
  235.        return Machine[Maquina];
  236.    }
  237. public static string RESOURSE_VS_FIXEDFILEINFO_dwFileFlags(string Maquina)
  238.    {
  239.        var Machine = new Dictionary<string, string>
  240.        {
  241.  
  242.            ["00000001"] = "VS_FF_DEBUG",  //  El archivo contiene información de depuración o se compila con las funciones de depuración habilitadas.
  243.  
  244.            ["00000010"] = "VS_FF_INFOINFERRED",  // La estructura de la versión del archivo se creó de forma dinámica; por lo tanto, algunos de los miembros de esta estructura pueden estar vacíos o incorrectos. Esta bandera nunca debe establecerse en los datos VS_VERSIONINFO de un archivo.
  245.  
  246.            ["00000004"] = "VS_FF_PATCHED",  // El archivo ha sido modificado y no es idéntico al archivo de envío original del mismo número de versión.
  247.  
  248.            ["00000002"] = "VS_FF_PRERELEASE",  // El archivo es una versión de desarrollo, no un producto comercializado.
  249.  
  250.            ["00000008"] = "VS_FF_PRIVATEBUILD",  // El archivo no se creó utilizando los procedimientos de publicación estándar.Si se establece este indicador, la estructura StringFileInfo debe contener una entrada PrivateBuild entry.
  251.  
  252.  
  253.            ["00000020"] = "VS_FF_SPECIALBUILD",  // El archivo fue creado por la empresa original utilizando procedimientos de publicación estándar, pero es una variación del archivo normal del mismo número de versión. Si se establece este indicador, la estructura StringFileInfo debe contener una entrada SpecialBuild entry.
  254.  
  255.            ["None"] = Maquina + " None"  // return new
  256.  
  257.        };
  258.  
  259.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  260.  
  261.        return Machine[Maquina];
  262.    }
  263.  
  264.    public static string RESOURSE_VS_FIXEDFILEINFO_dwFileOS(string Maquina)
  265.    {
  266.        var Machine = new Dictionary<string, string>
  267.        {
  268.  
  269.            ["00010000"] = "VOS_DOS",  //The file was designed for MS-DOS.
  270.            ["00040000"] = "VOS_NT",  //The file was designed for Windows NT.
  271.            ["00000001"] = "VOS__WINDOWS16",  //The file was designed for 16-bit Windows.
  272.            ["00000004L"] = "VOS__WINDOWS32",  //The file was designed for 32-bit Windows.
  273.            ["00020000L"] = "VOS_OS216",  //The file was designed for 16-bit OS/2.
  274.            ["00030000L"] = "VOS_OS232",  //The file was designed for 32-bit OS/2.
  275.            ["00000002L"] = "VOS__PM16",  //The file was designed for 16-bit Presentation Manager.
  276.            ["00000003L"] = "VOS__PM32",  //The file was designed for 32-bit Presentation Manager.
  277.            ["00000000L"] = "VOS_UNKNOWN",  //The operating system for which the file was designed is unknown to the system.
  278.            ["00010001"] = "VOS_DOS_WINDOWS16",  //The file was designed for 16-bit Windows running on MS-DOS.
  279.            ["00010004"] = "VOS_DOS_WINDOWS32",  //The file was designed for 32-bit Windows running on MS-DOS.
  280.            ["00040004"] = "VOS_NT_WINDOWS32",  //The file was designed for Windows NT.
  281.            ["00020002"] = "VOS_OS216_PM16",  //The file was designed for 16-bit Presentation Manager running on 16-bit OS/2.
  282.            ["00030003"] = "VOS_OS232_PM32",  //The file was designed for 32-bit Presentation Manager running on 32-bit OS/2.
  283.            ["None"] = Maquina + " None"  // return new
  284.  
  285.        };
  286.  
  287.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  288.  
  289.        return Machine[Maquina];
  290.    }
  291.  
  292.    public static string RESOURSE_VS_FIXEDFILEINFO_dwFileType(string Maquina)
  293.    {
  294.        var Machine = new Dictionary<string, string>
  295.        {
  296.  
  297.            ["00000001"] = "VFT_APP",  //The file contains an application.
  298.            ["00000002"] = "VFT_DLL",  //The file contains a DLL.
  299.            ["00000003"] = "VFT_DRV",  //The file contains a device driver. If dwFileType is VFT_DRV, dwFileSubtype contains a more specific description of the driver.
  300.            ["00000004"] = "VFT_FONT",  //The file contains a font. If dwFileType is VFT_FONT, dwFileSubtype contains a more specific description of the font file.
  301.            ["00000007"] = "VFT_STATIC_LIB",  //The file contains a static-link library.
  302.            ["00000000"] = "VFT_UNKNOWN",  //The file type is unknown to the system.
  303.            ["00000005"] = "VFT_VXD",  //The file contains a virtual device.
  304.            ["None"] = Maquina + " None"  // return new
  305.  
  306.        };
  307.  
  308.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  309.  
  310.        return Machine[Maquina];
  311.    }
  312.  
  313.    // Todos los valores de dwFileSubtype que no se enumeran aquí están reservados.
  314.    public static string RESOURSE_VS_FIXEDFILEINFO_VFT_DRV_dwFileSubtype_(string Maquina)
  315.    {
  316.        var Machine = new Dictionary<string, string>
  317.        {
  318.  
  319.            ["0000000A"] = "VFT2_DRV_COMM",  //The file contains a communications driver.
  320.            ["00000004"] = "VFT2_DRV_DISPLAY",  //The file contains a display driver.
  321.            ["00000008"] = "VFT2_DRV_INSTALLABLE",  //The file contains an installable driver.
  322.            ["00000002"] = "VFT2_DRV_KEYBOARD",  //The file contains a keyboard driver.
  323.            ["00000003"] = "VFT2_DRV_LANGUAGE",  //The file contains a language driver.
  324.            ["00000005"] = "VFT2_DRV_MOUSE",  //The file contains a mouse driver.
  325.            ["00000006"] = "VFT2_DRV_NETWORK",  //The file contains a network driver.
  326.            ["00000001"] = "VFT2_DRV_PRINTER",  //The file contains a printer driver.
  327.            ["00000009"] = "VFT2_DRV_SOUND",  //The file contains a sound driver.
  328.            ["00000007"] = "VFT2_DRV_SYSTEM",  //The file contains a system driver.
  329.            ["0000000C"] = "VFT2_DRV_VERSIONED_PRINTER",  //The file contains a versioned printer driver.
  330.            ["00000000"] = "VFT2_UNKNOWN",  //The driver type is unknown by the system.
  331.  
  332.            ["None"] = Maquina + " None"  // return new
  333.  
  334.        };
  335.  
  336.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  337.  
  338.        return Machine[Maquina];
  339.    }
  340.    public static string RESOURSE_VS_FIXEDFILEINFO_VFT_FONT_dwFileSubtype_(string Maquina)
  341.    {
  342.        var Machine = new Dictionary<string, string>
  343.        {
  344.  
  345.            ["00000001"] = "VFT2_FONT_RASTER",  //The file contains a raster font.
  346.            ["00000003"] = "VFT2_FONT_TRUETYPE",  //The file contains a TrueType font.
  347.            ["00000002"] = "VFT2_FONT_VECTOR",  //The file contains a vector font.
  348.            ["00000000"] = "VFT2_UNKNOWN",  //The font type is unknown by the system.
  349.            ["None"] = Maquina + " None"  // return new
  350.  
  351.        };
  352.  
  353.        if (Machine.ContainsKey(Maquina) == false) { Maquina = "None"; }
  354.  
  355.        return Machine[Maquina];
  356.    }
  357.  
  358.  
« Última modificación: 15 Diciembre 2020, 23:39 pm por FFernandez » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines