Temas

[Secuencia valor 1,3,6,10, ......etc.......]

Numerar (ordenar.etc.) una secuencia es relativamente fácil, el reverso es donde está el problema.............    Podemos numerar (X por Y) y obtener su Z.

Lo difícil es el Reverso-Tenebroso, nos dan Z y cómo podemos obtener el índice numerado de (X por Y).

Me leo y no me entiendo:

Secuencia valor   1,3,6,10, ......etc.......  ¿Cuál es elemento 99?, sabiendo que el valor =1 es el elemento 1.
.. n=Elemento
Existe su relación Valor= n(n+1) /2

Bien la cuestión se complica si te doy el número 6441 y te pido n. En este caso es fácil.


La cuestión está en saber llegar a V=n(n+1) /2

¿Como lo haría ustedes?   ....................

https://www.mozilla.org/es-ES/products/vpn/

[En el caso de arriba no existe nada de esto joder, si me equivoco que me ilumine alguien, gracias]

Notepad 64 bits




No sé cómo encajar esta línea...........................
Código Exa    01 06 02 00 06 32 02 30
Dirección hexadecimal  RVA- 2E178      la siguiente me sale 2E180
Como encajo esos códigos Hexadecimales en la estructura UNWIND_INFO

Estructuras del directorio de excepciones x64

Código (cpp) [Seleccionar] Expandir

public static string[] EXCEPTION_RUNTIME_FUNCTION_12(string[] DiHeader)  //  Tabla   redondeo dword 32 bits
   {
      string[] Retorno = new string[3];
       Retorno[0] = "DWORD FunctionStart RVA" + ";" + DiHeader[3] + DiHeader[2] + DiHeader[1] + DiHeader[0]; //
       Retorno[1] = "DWORD FunctionEnd RVA" + ";" + DiHeader[7] + DiHeader[6] + DiHeader[5] + DiHeader[4]; //
       Retorno[2] = "DWORD UnwindInfo RVA" + ";" + DiHeader[11] + DiHeader[10] + DiHeader[9] + DiHeader[8]; //
       return Retorno;
   } // PROBANDO
Las entradas a las funciones en él  .TXT son exactas con RVA-DWORD, pero la  DWORD UnwindInfo RVA me parecen extrañas............ no se porque




Excepciones,  joder que no exista información, y tenga que averiguarlo examinando el código tiene narices.

Estructura Unwid_Info{
Versión + flag               1 byte          si es                       01
SizeOfProlong               1 byte
CountOfCode                1 byte               Cada code tiene 2 Byte
FrameRegister + FrameOffset          1 byte            si es 00

Mas los codes}
Y termina aquí           toda la información, la excepción se resuelve en el RSP actual
Si se aplica la información que hay en internet(La que he encontrado)  se obtienen datos erróneos.......................................

Por eso hay poca información, ni siquiera en Microsoft te lo detalla, la información que suministra te lleva a error😡

Immediately after the UNWIND_INFO structure, either the EXCEPTION_HANDLER structure or the RUNTIME_FUNCTION structure is located. The structure of EXCEPTION_HANDLER is defined in Figure 4.                   En el caso de arriba no existe nada de esto   joder, si me equivoco que me ilumine alguien, gracias

[Localizado proceso, encuesta de Visual Studio ........................... la pospuse y seguía activa un pequeño tiempo.]

System.InvalidOperationException: 'No se puede procesar la solicitud porque el proceso (6200) ha terminado.'


No encuentro el proceso!!!! , solo comprobaba  los procesos del sistema operativo si era 64 o 32 bits en Windows 10

No cambio nada y ya funciona  


Respuesta:

Localizado proceso, encuesta de Visual Studio ........................... la pospuse y seguía activa un pequeño tiempo.

La primera función del directorio de excepciones empieza en 08 , coincide con la primera función del código ejecutable (.text).
Y termina en C7 se ve que la alineación en .text es QWORD(64 bits).
Me imagino que CC CC CC CC CC CC CC CC  indica que empieza la sección en este caso de código. Y las funciones empiezan y terminan con (CC CC CC CC CC CC CC CC). Coincidiendo con el directorio mencionado.

CC CC CC CC CC CC CC CC 40 55 48 8D 6C 24 E1 48
81 EC D0 00 00 00 48 8B 05 8B 14 03 00 48 33 C4
48 89 45 0F 48 8B 45 7F 45 33 C9 48 89 45 FF 45
33 C0 48 8B 45 77 48 89 45 EF 48 8B 45 6F 48 89
45 DF 48 8B 45 67 48 89 45 CF 48 8B 45 5F 48 89
45 BF 48 8B 45 57 48 89 45 AF 48 8B 45 4F 48 89
45 9F 48 8D 44 24 30 48 89 44 24 28 C7 44 24 20
09 00 00 00 48 C7 45 07 08 00 00 00 48 C7 45 F7
04 00 00 00 48 C7 45 E7 01 00 00 00 48 C7 45 D7
02 00 00 00 48 C7 45 C7 04 00 00 00 48 C7 45 B7
04 00 00 00 48 C7 45 A7 04 00 00 00 E8 EB 06 00
00 48 8B 4D 0F 48 33 CC E8 A3 49 02 00 48 81 C4
D0 00 00 00 5D C3 CC CC CC CC CC CC CC CC CC CC


La pregunta es: ¿son ciertas mis conclusiones?

struct UNWIND_CODE


Size              Value
UBYTE      Offset in prolog
UBYTE: 4     Unwind operation code
UBYTE: 4      Operation info


Los Byte(s) los estoy leyendo de derecha a izquierda, como leo entonces a estos bits, gracias.
1 byte == UBYTE: 4     Unwind operation code  UBYTE: 4      Operation info
Supongo que de izquierda a derecha..................................?¿?¿

[****************Esta definición es la correcta, coinciden todos los parametros]

struct UNWIND_CODE


Size              Value
UBYTE      Offset in prolog
UBYTE: 4     Unwind operation code
UBYTE: 4      Operation info


Tamaño en bits UBYTE:4 ¿   
Tengo dudas porque me he encontrado distintas interpretaciones, gracias

Esta es diferente a todas que he encontrado : Excepciones de prólogo y epílogo

****************Esta definición es la correcta, coinciden todos los parametros

Dentro de una función descrita por una _RUNTIME_FUNCTIONestructura, puede ocurrir una excepción en el prólogo o el epílogo de la función, así como en el cuerpo de la función, que puede estar o no en un bloque try. El prólogo es la parte de la función que guarda registros, almacena parámetros en la pila (si - ). El epílogo es la inversión de este proceso, es decir, el regreso de la función. El compilador almacena cada acción que tiene lugar en el prólogo en una UnwindCodesmatriz; cada acción está representada por una UNWIND_CODEestructura de 2 bytes que contiene un miembro para el desplazamiento en el prólogo (1 byte), el código de operación de desenrollado (4 bits) y la información de operación (4 bits).

Y la segunda pregunta es: Los Byte(s) los estoy leyendo de derecha a izquierda, como leo entonces a estos bits, gracias.
1 byte == UBYTE: 4     Unwind operation code  UBYTE: 4      Operation info
Supongo que de izquierda a derecha..................................?¿?¿

******************** Pues si que es correcto aquí se lee como se escribe, comprobado y coinciden los parámetros extraidos.

Entonces la struct UNWIND_CODE tiene un tamaño de 2 byte en x64

Aclaro sistema x64

Sabe alguien algo, gracias

rectificó ahora mismo ha subido a 101.

  ,  gracias

[typedef struct _RUNTIME_FUNCTION]

Estoy devuelta, y con las pilas recargadas, para seguir con el proyecto, no encuentro información concisa sobre el formato de las excepciones, alguien podría facilitarme un enlace, gracias

https://foro.elhacker.net/ingenieria_inversa/estructuras_binarias_x8664-t505205.0.html


Aquí tengo algo, pero me faltan detalles .............

https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=msvc-160



typedef enum _UNWIND_OP_CODES {
   UWOP_PUSH_NONVOL = 0, /* info == register number */
   UWOP_ALLOC_LARGE,     /* no info, alloc size in next 2 slots */
   UWOP_ALLOC_SMALL,     /* info == size of allocation / 8 - 1 */
   UWOP_SET_FPREG,       /* no info, FP = RSP + UNWIND_INFO.FPRegOffset*16 */
   UWOP_SAVE_NONVOL,     /* info == register number, offset in next slot */
   UWOP_SAVE_NONVOL_FAR, /* info == register number, offset in next 2 slots */
   UWOP_SAVE_XMM128 = 8, /* info == XMM reg number, offset in next slot */
   UWOP_SAVE_XMM128_FAR, /* info == XMM reg number, offset in next 2 slots */
   UWOP_PUSH_MACHFRAME   /* info == 0: no error-code, 1: error-code */
} UNWIND_CODE_OPS;

typedef union _UNWIND_CODE {
   struct {
       UBYTE CodeOffset;
       UBYTE UnwindOp : 4;
       UBYTE OpInfo   : 4;
   };
   USHORT FrameOffset;
} UNWIND_CODE, *PUNWIND_CODE;

#define UNW_FLAG_EHANDLER  0x01
#define UNW_FLAG_UHANDLER  0x02
#define UNW_FLAG_CHAININFO 0x04

typedef struct _UNWIND_INFO {
   UBYTE Version       : 3;
   UBYTE Flags         : 5;
   UBYTE SizeOfProlog;
   UBYTE CountOfCodes;
   UBYTE FrameRegister : 4;
   UBYTE FrameOffset   : 4;
   UNWIND_CODE UnwindCode[1];
/*  UNWIND_CODE MoreUnwindCode[((CountOfCodes + 1) & ~1) - 1];
*   union {
*       OPTIONAL ULONG ExceptionHandler;
*       OPTIONAL ULONG FunctionEntry;
*   };
*   OPTIONAL ULONG ExceptionData[]; */
} UNWIND_INFO, *PUNWIND_INFO;

typedef struct _RUNTIME_FUNCTION {
   ULONG BeginAddress;
   ULONG EndAddress;
   ULONG UnwindData;
} RUNTIME_FUNCTION, *PRUNTIME_FUNCTION;

#define GetUnwindCodeEntry(info, index) \
   ((info)->UnwindCode[index])

#define GetLanguageSpecificDataPtr(info) \
   ((PVOID)&GetUnwindCodeEntry((info),((info)->CountOfCodes + 1) & ~1))

#define GetExceptionHandler(base, info) \
   ((PEXCEPTION_HANDLER)((base) + *(PULONG)GetLanguageSpecificDataPtr(info)))

#define GetChainedFunctionEntry(base, info) \
   ((PRUNTIME_FUNCTION)((base) + *(PULONG)GetLanguageSpecificDataPtr(info)))

#define GetExceptionDataPtr(info) \
   ((PVOID)((PULONG)GetLanguageSpecificData(info) + 1)


Estas entradas de tabla como se que han terminado "typedef struct _RUNTIME_FUNCTION " ????????????



Resuelto  https://www.leviathansecurity.com/blog/use-of-windows-exception-handling-metadata

Estoy devuelta, y con las pilas recargadas, para seguir con el proyecto, no encuentro información concisa sobre el formato de las excepciones, alguien podría facilitarme un enlace, gracias

https://foro.elhacker.net/ingenieria_inversa/estructuras_binarias_x8664-t505205.0.html


Aquí tengo algo, pero me faltan detalles .............

https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=msvc-160

[Primero:]

Primero:
1º averiguar longitud de la clave ¿si existe?
2º si no existe, averiguar el algoritmo
Todo sin entrar en las funciones que lo ha creado.
Segundo: ¿???



Quien se apunta?

[Resuelto y publicado]

He encontrado esto, en el primer enlace me cuadra con la realidad viendo el código en hexadecimal.  Pero no encuentro la explicación de cada ítem correctamente, tengo localizado
Signatura, size, etc y el final  UltimateFallbackLanguage. El resto no lo puedo determinar???

El segundo enlace es para obtenerlo por código, y no me sirve para desensamblar


https://docs.microsoft.com/en-us/windows/win32/intl/resource-utilities

https://docs.microsoft.com/en-us/windows/win32/api/winnls/ns-winnls-filemuiinfo





Resuelto y publicado    

Gracias  Apuromafo CLS   

[Selecionando texto]

Gracias


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

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

Un saludo a todos:

¿Examinando  el código binario de un " .EXE", sabe alguien como distinguir entre DATOS E INSTRUCCIONES?

¿ Como encontrar la primera instrucción que se ejecuta ?

          Gracias....

Intel® 64 and IA-32 Architectures Software Developer's Manual Combined Volumes:1, 2A, 2B, 2C, 2D, 3A, 3B, 3C, 3D and 4   
Vol. 2D A-29    OPCODE MAP

Esta página está en blanco, aquí vendría los Mapas de Instrucciones  VEX, EVEX y sus Grupos.

Alguien tan amable que tenga estos mapas de INTEL, podría pasármelos................   
Es para comprobar las literaturas..........  Y entender las distintas literaturas que veo por internet.
Intel al utilizar una literatura distinta en los Mapas de código me ayuda a entender mejor
Lo que me traigo entre manos.   Gracias de antemano..........................jeje

Cambiando de tercio, me he encontrado con dos definiciones de la instrucción en assembler  " LSL  " Opcode  "0F-03"   una en el manual de Intel y otra en el manual de AMD.   Alguien me da la LUZ   💡

Compilador JIT en .NET,   Cuando una aplicación .NET se carga en memoria sigue estando en lenguaje intermedio????

[0FA4050000000003H]

Solo veo que se añaden 00 00 00 00   Ceros..............    en este ejemplo:

Example A-2.  Look-up Example for 2-Byte OpcodesLook-up opcode 0FA4050000000003H for a SHLD instruction using Table A-3.•The opcode is located in row A, column 4. The location indicates a SHLD instruction with operands Ev, Gv, and Ib. Interpret the operands as follows:—   Ev: The ModR/M byte follows the opcode to specify a word or doubleword operand.—   Gv: The reg field of the ModR/M byte selects a general-purpose register.—   Ib: Immediate data is encoded in the subsequent byte of the instruction.•The third byte is the ModR/M byte (05H). The mod and opcode/reg fields of ModR/M indicate that a 32-bit displacement is used to locate the first operand in memory and eAX as the second operand.•The next part of the opcode is the 32-bit displacement for the destination memory operand (00000000H). The last byte stores immediate byte that provides the count of the shift (03H).•By this breakdown, it has been shown that this opcode represents the instruction: SHLD DS:00000000H, EAX, 3.



En este ejemplo ocurre lo contrario


3DNOW  ?????

WEB Utlizada https://defuse.ca/online-x86-assembler.htm#disassembly


PFMUL  mm1, [ebx+eax*4+10]

67 0f 0f 4c 83 0a b4

Coincide con el ejemplo del manual  https://www.amd.com/system/files/TechDocs/21928.pdf



En teoria el 4C es el MOD/rm

En binario 01 001 100      01 disp 8           100 requiere SIB       001 ECX

el SIB   83

en Binario  10 000 011      10  *4              000 EAX                011 EBX

0A es el desplazamiento  = 10 en decimal

En este ejemplo el Desplazamiento es utilizado?????          

[Gracias]

OF 0D    prefetchw(/1)Ev    INTEL     No hay más detalles en los manuales.......???


Group  P     0F 0D  PREFETCH    AMD     /0 /1 /2  /3 /4 /5 /6 /7      




           Si se refieren al mismo juego de instrucciones, entiendo que las dos informaciones se complementan???


https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-2b-manual.pdf

0F 0D /1    PREFETCHW m8    A    V/V      PRFCHWMove data from m8 closer to the processor in anticipation of a write.
4-406 Vol. 2B


https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf

0F 0D /2      PREFETCHWT1 m8    M      PREFETCHWT1  data from m8 closer to the processor using T1 hint with intent to write
4-404 Vol. 2B


Gracias, como cabía esperar, la información de AMD es complementaria en los juegos de instrucciones compatibles por ambas arquitecturas.
De hecho, en INTEL en distintos manuales como se puede comprobar en estos dos la instrucción referenciada se complementa a si misma

[analizando el binario]

KANDW k1, k2, k3    "Bitwise AND word masks k2 and k3 and place result in k1"
Notacion Disamble  VEX.L1.0F.W0 41 /r
en EXA..    0xC5, 0xEC, 0x41, 0xCB    "Bitwise AND word masks k2 and k3 and place result in k1"



11000100                 W vvvv L pp

0xC5,
0xEC, 1             1101                  1           00

1 no se cambia el tamaño del operando "W"

1101 segun tabla ????       XMM02/YMM02  "vvvv"

(1    256 Bits Vector   "L")     L=1  3 operandos en mascara


00   Sin extensión del codigo de operacion  "pp"

0x41, 01000001      Opcode/Mapa  KANDW

0xCB  11001011      MordR/m


Como puedo saber que son los registros k1,k2,k3   ?¿?¿?¿?¿?¿? analizando el binario

.........................  No me he expresado bien, no encuentro la tabla que relacione esos tres registros k1,k2,k3  con el codigo de zeros y unos.

Resuelto lo tenia delante de las narices, jejejejej

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.


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"

[0x66 h]

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
 
0º 0X62h
1º R X B r  00 mm
2º W vvvv 1 pp
3º 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


                        3º
                    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)

            Con el confinamiento me he puesto a estudiar las estructuras binarias del juego de instruciones x86-64, me ha entusiasmado el tema, y ya me he  gastado pasta en dos clases, que han sido un desastre.

            Si alguien sabe de algún "profe", o donde buscar............, que no sean los mismos en los que he buscado sin mencionar.

           

   Comprendo lo que me dices, igual no me expreso bien, en el Post que he abierto "Estructuras Binarias x86-64"             aquí mismo en Ingeniería Inversa  estoy desarrollando un Esquema Tutu.
con lo que sé y aprendo, pero aún me queda comprender algunas cosas, que aunque falte una, no tendría sentido lo aprendido.
     Se que es un tema difícil, y mis preguntas aún más...............jeje.

De todas formas GRACIAS.