Translated ['macos-hardening/macos-security-and-privilege-escalation/mac

macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -6,63 +6,63 @@
 
 Otras formas de apoyar a HackTricks:
 
-* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
+* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
 * Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
-* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
+* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
 * **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>
 
 ## **Niveles de Excepción - EL (ARM64v8)**
 
-En la arquitectura ARMv8, los niveles de ejecución, conocidos como Niveles de Excepción (ELs), definen el nivel de privilegio y las capacidades del entorno de ejecución. Hay cuatro niveles de excepción, que van desde EL0 hasta EL3, cada uno con un propósito diferente:
+En la arquitectura ARMv8, los niveles de ejecución, conocidos como Niveles de Excepción (ELs), definen el nivel de privilegio y las capacidades del entorno de ejecución. Hay cuatro niveles de excepción, que van desde EL0 a EL3, cada uno con un propósito diferente:
 
 1. **EL0 - Modo Usuario**:
 * Este es el nivel menos privilegiado y se utiliza para ejecutar código de aplicaciones regulares.
-* Las aplicaciones que se ejecutan en EL0 están aisladas entre sí y del software del sistema, mejorando la seguridad y la estabilidad.
+* Las aplicaciones que se ejecutan en EL0 están aisladas entre sí y del software del sistema, mejorando la seguridad y estabilidad.
 2. **EL1 - Modo Kernel del Sistema Operativo**:
 * La mayoría de los kernels de sistemas operativos se ejecutan en este nivel.
-* EL1 tiene más privilegios que EL0 y puede acceder a recursos del sistema, pero con algunas restricciones para garantizar la integridad del sistema.
+* EL1 tiene más privilegios que EL0 y puede acceder a recursos del sistema, pero con algunas restricciones para asegurar la integridad del sistema.
 3. **EL2 - Modo Hipervisor**:
-* Este nivel se utiliza para la virtualización. Un hipervisor que se ejecuta en EL2 puede gestionar múltiples sistemas operativos (cada uno en su propio EL1) que se ejecutan en el mismo hardware físico.
+* Este nivel se utiliza para virtualización. Un hipervisor que se ejecuta en EL2 puede gestionar múltiples sistemas operativos (cada uno en su propio EL1) que se ejecutan en el mismo hardware físico.
 * EL2 proporciona características para la aislación y control de los entornos virtualizados.
 4. **EL3 - Modo Monitor Seguro**:
 * Este es el nivel más privilegiado y a menudo se utiliza para arranque seguro y entornos de ejecución confiables.
 * EL3 puede gestionar y controlar accesos entre estados seguros y no seguros (como arranque seguro, sistema operativo confiable, etc.).
 
-El uso de estos niveles permite una forma estructurada y segura de gestionar diferentes aspectos del sistema, desde aplicaciones de usuario hasta el software del sistema más privilegiado. El enfoque de ARMv8 para los niveles de privilegio ayuda a aislar efectivamente los diferentes componentes del sistema, mejorando así la seguridad y robustez del sistema.
+El uso de estos niveles permite una forma estructurada y segura de gestionar diferentes aspectos del sistema, desde aplicaciones de usuario hasta el software del sistema más privilegiado. El enfoque de ARMv8 hacia los niveles de privilegio ayuda a aislar efectivamente los diferentes componentes del sistema, mejorando así la seguridad y robustez del sistema.
 
 ## **Registros (ARM64v8)**
 
-ARM64 tiene **31 registros de propósito general**, etiquetados de `x0` a `x30`. Cada uno puede almacenar un valor de **64 bits** (8 bytes). Para operaciones que solo requieren valores de 32 bits, los mismos registros se pueden acceder en un modo de 32 bits usando los nombres w0 a w30.
+ARM64 tiene **31 registros de propósito general**, etiquetados de `x0` a `x30`. Cada uno puede almacenar un valor de **64 bits** (8 bytes). Para operaciones que solo requieren valores de 32 bits, los mismos registros se pueden acceder en modo de 32 bits usando los nombres w0 a w30.
 
-1. **`x0`** a **`x7`** - Estos se utilizan típicamente como registros temporales y para pasar parámetros a subrutinas.
+1. **`x0`** a **`x7`** - Típicamente se utilizan como registros temporales y para pasar parámetros a subrutinas.
 * **`x0`** también lleva el dato de retorno de una función
 2. **`x8`** - En el kernel de Linux, `x8` se utiliza como el número de llamada al sistema para la instrucción `svc`. **¡En macOS se utiliza el x16!**
 3. **`x9`** a **`x15`** - Más registros temporales, a menudo utilizados para variables locales.
 4. **`x16`** y **`x17`** - **Registros de Llamada Intraprocedural**. Registros temporales para valores inmediatos. También se utilizan para llamadas a funciones indirectas y stubs de PLT (Tabla de Enlace de Procedimientos).
 * **`x16`** se utiliza como el **número de llamada al sistema** para la instrucción **`svc`** en **macOS**.
-5. **`x18`** - **Registro de plataforma**. Puede utilizarse como un registro de propósito general, pero en algunas plataformas, este registro está reservado para usos específicos de la plataforma: Puntero al bloque de entorno de hilo actual en Windows, o para apuntar a la estructura de tarea actualmente **ejecutando en el kernel de linux**.
+5. **`x18`** - **Registro de plataforma**. Puede utilizarse como un registro de propósito general, pero en algunas plataformas, este registro está reservado para usos específicos de la plataforma: Puntero al bloque de entorno de hilo actual en Windows, o para apuntar a la estructura de tarea en ejecución actual en el kernel de Linux.
-6. **`x19`** a **`x28`** - Estos son registros guardados por el llamado. Una función debe preservar los valores de estos registros para su llamador, por lo que se almacenan en la pila y se recuperan antes de volver al llamador.
+6. **`x19`** a **`x28`** - Estos son registros preservados por el llamado. Una función debe preservar los valores de estos registros para su llamador, por lo que se almacenan en la pila y se recuperan antes de volver al llamador.
-7. **`x29`** - **Puntero de marco** para llevar un registro del marco de pila. Cuando se crea un nuevo marco de pila porque se llama a una función, el registro **`x29`** se **almacena en la pila** y la **nueva** dirección del puntero de marco es (dirección **`sp`**) se **almacena en este registro**.
+7. **`x29`** - **Puntero de marco** para llevar un registro del marco de pila. Cuando se crea un nuevo marco de pila porque se llama a una función, el registro **`x29`** se **almacena en la pila** y la dirección del **nuevo** puntero de marco (dirección **`sp`**) se **almacena en este registro**.
-* Este registro también puede utilizarse como un **registro de propósito general** aunque generalmente se utiliza como referencia a **variables locales**.
+* Este registro también puede utilizarse como un **registro de propósito general** aunque generalmente se usa como referencia a **variables locales**.
 8. **`x30`** o **`lr`**- **Registro de enlace**. Contiene la **dirección de retorno** cuando se ejecuta una instrucción `BL` (Branch with Link) o `BLR` (Branch with Link to Register) almacenando el valor de **`pc`** en este registro.
 * También podría utilizarse como cualquier otro registro.
 9. **`sp`** - **Puntero de pila**, utilizado para llevar un registro de la parte superior de la pila.
 * el valor de **`sp`** siempre debe mantenerse al menos con una **alineación de cuádruple palabra** o podría ocurrir una excepción de alineación.
-10. **`pc`** - **Contador de programa**, que apunta a la instrucción actual. Este registro solo puede actualizarse a través de generaciones de excepciones, retornos de excepciones y ramificaciones. Las únicas instrucciones ordinarias que pueden leer este registro son las instrucciones de ramificación con enlace (BL, BLR) para almacenar la dirección de **`pc`** en **`lr`** (Registro de Enlace).
+10. **`pc`** - **Contador de programa**, que apunta a la siguiente instrucción. Este registro solo puede actualizarse a través de generaciones de excepciones, retornos de excepciones y ramificaciones. Las únicas instrucciones ordinarias que pueden leer este registro son las instrucciones de ramificación con enlace (BL, BLR) para almacenar la dirección de **`pc`** en **`lr`** (Registro de Enlace).
 11. **`xzr`** - **Registro cero**. También llamado **`wzr`** en su forma de registro de **32 bits**. Puede utilizarse para obtener fácilmente el valor cero (operación común) o para realizar comparaciones usando **`subs`** como **`subs XZR, Xn, #10`** almacenando los datos resultantes en ninguna parte (en **`xzr`**).
 
 Los registros **`Wn`** son la versión de **32 bits** del registro **`Xn`**.
 
 ### SIMD y Registros de Punto Flotante
 
-Además, hay otros **32 registros de 128 bits de longitud** que se pueden utilizar en operaciones optimizadas de datos múltiples de instrucción única (SIMD) y para realizar aritmética de punto flotante. Estos se llaman registros Vn aunque también pueden operar en **64 bits**, **32 bits**, **16 bits** y **8 bits** y entonces se llaman **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** y **`Bn`**.
+Además, hay otros **32 registros de 128 bits de longitud** que se pueden utilizar en operaciones SIMD (instrucción única, múltiples datos) optimizadas y para realizar aritmética de punto flotante. Estos se llaman registros Vn aunque también pueden operar en **64 bits**, **32 bits**, **16 bits** y **8 bits** y entonces se llaman **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** y **`Bn`**.
 
 ### Registros del Sistema
 
-**hay cientos de registros del sistema**, también llamados registros de propósito especial (SPRs), se utilizan para **monitorear** y **controlar** el **comportamiento de los procesadores**.\
+**hay cientos de registros del sistema**, también llamados registros de propósito especial (SPRs), que se utilizan para **monitorear** y **controlar** el comportamiento de **procesadores**.\
 Solo se pueden leer o configurar utilizando la instrucción especial dedicada **`mrs`** y **`msr`**.
 
 Los registros especiales **`TPIDR_EL0`** y **`TPIDDR_EL0`** son comunes cuando se hace ingeniería inversa. El sufijo `EL0` indica el **nivel mínimo de excepción** desde el cual se puede acceder al registro (en este caso, EL0 es el nivel regular de excepción (privilegio) con el que se ejecutan los programas regulares).\
@@ -73,7 +73,8 @@ A menudo se utilizan para almacenar la **dirección base del área de almacenami
 
 ### **PSTATE**
 
-**PSTATE** son varios componentes serializados en el registro especial **`SPSR_ELx`** visible por el sistema operativo. Estos son los campos accesibles:
+**PSTATE** contiene varios componentes del proceso serializados en el registro especial visible por el sistema operativo **`SPSR_ELx`**, siendo X el **nivel de permiso del** excepción desencadenada (esto permite recuperar el estado del proceso cuando la excepción termina).\
+Estos son los campos accesibles:
 
 * Las banderas de condición **`N`**, **`Z`**, **`C`** y **`V`**:
 * **`N`** significa que la operación produjo un resultado negativo
@@ -85,18 +86,19 @@ A menudo se utilizan para almacenar la **dirección base del área de almacenami
 * En la resta, cuando se resta un número negativo grande de un número positivo más pequeño (o viceversa), y el resultado no se puede representar dentro del rango del tamaño de bit dado.
 * La bandera de **ancho de registro actual (`nRW`)**: Si la bandera tiene el valor 0, el programa se ejecutará en el estado de ejecución AArch64 una vez reanudado.
 * El **Nivel de Excepción actual** (**`EL`**): Un programa regular que se ejecuta en EL0 tendrá el valor 0
-* La bandera de **paso único** (**`SS`**): Utilizada por los depuradores para realizar un paso único configurando la bandera SS en 1 dentro de **`SPSR_ELx`** a través de una excepción. El programa ejecutará un paso y emitirá una excepción de paso único.
+* La bandera de **paso único** (**`SS`**): Utilizada por depuradores para realizar un paso único configurando la bandera SS en 1 dentro de **`SPSR_ELx`** a través de una excepción. El programa ejecutará un paso y emitirá una excepción de paso único.
-* La bandera de estado de excepción ilegal (**`IL`**): Se utiliza para marcar cuando un software privilegiado realiza una transferencia de nivel de excepción inválida, esta bandera se establece en 1 y el procesador desencadena una excepción de estado ilegal.
+* La bandera de estado de excepción **ilegal** (**`IL`**): Se utiliza para marcar cuando un software privilegiado realiza una transferencia de nivel de excepción inválida, esta bandera se establece en 1 y el procesador desencadena una excepción de estado ilegal.
 * Las banderas **`DAIF`**: Estas banderas permiten a un programa privilegiado enmascarar selectivamente ciertas excepciones externas.
-* Las banderas de selección de puntero de pila (**`SPS`**): Los programas privilegiados que se ejecutan en EL1 y superior pueden cambiar entre usar su propio registro de puntero de pila y el del modelo de usuario (por ejemplo, entre `SP_EL1` y `EL0`). Este cambio se realiza escribiendo en el registro especial **`SPSel`**. Esto no se puede hacer desde EL0.
+* Si **`A`** es 1 significa que se desencadenarán **abortos asíncronos**. La **`I`** configura para responder a **Solicitudes de Interrupción** de hardware externo (IRQs). y la F está relacionada con **Solicitudes de Interrupción Rápida** (FIRs).
+* Las banderas de selección del **puntero de pila** (**`SPS`**): Los programas privilegiados que se ejecutan en EL1 y superior pueden cambiar entre usar su propio registro de puntero de pila y el del modelo de usuario (por ejemplo, entre `SP_EL1` y `EL0`). Este cambio se realiza escribiendo en el registro especial **`SPSel`**. Esto no se puede hacer desde EL0.
 
 <figure><img src="../../../.gitbook/assets/image (724).png" alt=""><figcaption></figcaption></figure>
 
 ## **Convención de Llamadas (ARM64v8)**
 
-La convención de llamadas ARM64 especifica que los **primeros ocho parámetros** de una función se pasan en los registros **`x0` a `x7`**. **Parámetros adicionales** se pasan en la **pila**. El valor de **retorno** se devuelve en el registro **`x0`**, o también en **`x1`** si es de 128 bits. Los registros **`x19`** a **`x30`** y **`sp`** deben ser **preservados** a través de las llamadas a funciones.
+La convención de llamadas ARM64 especifica que los **primeros ocho parámetros** de una función se pasan en los registros **`x0` a `x7`**. **Parámetros adicionales** se pasan en la **pila**. El valor de **retorno** se devuelve en el registro **`x0`**, o también en **`x1`** si es de **128 bits**. Los registros **`x19`** a **`x30`** y **`sp`** deben ser **preservados** a través de las llamadas a funciones.
 
-Al leer una función en ensamblador, busque el **prólogo y epílogo de la función**. El **prólogo** generalmente implica **guardar el puntero de marco (`x29`)**, **establecer** un **nuevo puntero de marco**, y **asignar espacio en la pila**. El **epílogo** generalmente implica **restaurar el puntero de marco guardado** y **retornar** de la función.
+Al leer una función en ensamblador, busca el **prólogo y epílogo de la función**. El **prólogo** generalmente implica **guardar el puntero de marco (`x29`)**, **establecer** un **nuevo puntero de marco**, y **asignar espacio en la pila**. El **epílogo** generalmente implica **restaurar el puntero de marco guardado** y **retornar** de la función.
 
 ### Convención de Llamadas en Swift
 
@@ -109,9 +111,9 @@ Las instrucciones ARM64 generalmente tienen el **formato `opcode dst, src1, src2
 * **`mov`**: **Mover** un valor de un **registro** a otro.
 * Ejemplo: `mov x0, x1` — Esto mueve el valor de `x1` a `x0`.
 * **`ldr`**: **Cargar** un valor de la **memoria** en un **registro**.
-* Ejemplo: `ldr x0, [x1]` — Esto carga un valor de la ubicación de memoria señalada por `x1` en `x0`.
+* Ejemplo: `ldr x0, [x1]` — Esto carga un valor de la ubicación de memoria apuntada por `x1` en `x0`.
 * **`str`**: **Almacenar** un valor de un **registro** en la **memoria**.
-* Ejemplo: `str x0, [x1]` — Esto almacena el valor en `x0` en la ubicación de memoria señalada por `x1`.
+* Ejemplo: `str x0, [x1]` — Esto almacena el valor en `x0` en la ubicación de memoria apuntada por `x1`.
 * **`ldp`**: **Cargar Par de Registros**. Esta instrucción **carga dos registros** de **ubicaciones de memoria consecutivas**. La dirección de memoria se forma típicamente sumando un desplazamiento al valor en otro registro.
 * Ejemplo: `ldp x0, x1, [x2]` — Esto carga `x0` y `x1` de las ubicaciones de memoria en `x2` y `x2 + 8`, respectivamente.
 * **`stp`**: **Almacenar Par de Registros**. Esta instrucción **almacena dos registros** en **ubicaciones de memoria consecutivas**. La dirección de memoria se forma típicamente sumando un desplazamiento al valor en otro registro.
@@ -125,9 +127,7 @@ Las instrucciones ARM64 generalmente tienen el **formato `opcode dst, src1, src2
 * **`div`**: **Dividir** el valor de un registro por otro y almacenar el resultado en un registro.
 * Ejemplo: `div x0, x1, x2` — Esto divide el valor en `x1` por `x2` y almacena el resultado en `x0`.
 * **`bl`**: **Rama** con enlace, utilizada para **llamar** a una **subrutina**. Almacena la **dirección de retorno en `x30`**.
-* Ejemplo: `bl myFunction` — Esto llama a la función `myFunction` y almacena la dirección de retorno en `x30`.
+* Ejemplo: `bl myFunction
-* **`blr`**: **Rama** con Enlace a Registro, utilizada para **llamar** a una **subrutina** donde el objetivo está **especificado** en un **registro**. Almacena la dirección de retorno en `x30`.
-* Ejemplo: `blr x1` — Esto llama a la función cuya dirección está contenida en `x1` y al
 ```armasm
 ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer
 ```
@@ -137,21 +137,80 @@ ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment th
 
 ## Estado de Ejecución AARCH32
 
-Armv8-A soporta la ejecución de programas de 32 bits. **AArch32** puede ejecutarse en uno de **dos conjuntos de instrucciones**: **`A32`** y **`T32`** y puede alternar entre ellos mediante **`interworking`**.\
+Armv8-A soporta la ejecución de programas de 32 bits. **AArch32** puede ejecutarse en uno de **dos conjuntos de instrucciones**: **`A32`** y **`T32`** y puede cambiar entre ellos mediante **`interworking`**.\
-Los programas de 64 bits **Privilegiados** pueden programar la **ejecución de programas de 32 bits** ejecutando una transferencia de nivel de excepción al 32 bits menos privilegiado.\
+Los programas **privilegiados** de 64 bits pueden programar la **ejecución de programas de 32 bits** ejecutando una transferencia de nivel de excepción al 32 bits menos privilegiado.\
-Note que la transición de 64 bits a 32 bits ocurre con una disminución del nivel de excepción (por ejemplo, un programa de 64 bits en EL1 activando un programa en EL0). Esto se hace estableciendo el **bit 4 de** **`SPSR_ELx`** registro especial **a 1** cuando el hilo del proceso `AArch32` está listo para ser ejecutado y el resto de `SPSR_ELx` almacena el CPSR del programa **`AArch32`**. Luego, el proceso privilegiado llama a la instrucción **`ERET`** para que el procesador transite a **`AArch32`** entrando en A32 o T32 dependiendo del CPSR**.**
+Note que la transición de 64 bits a 32 bits ocurre con una disminución del nivel de excepción (por ejemplo, un programa de 64 bits en EL1 activando un programa en EL0). Esto se hace estableciendo el **bit 4 de** **`SPSR_ELx`** registro especial **a 1** cuando el hilo del proceso `AArch32` está listo para ser ejecutado y el resto de `SPSR_ELx` almacena el CPSR del programa **`AArch32`**. Luego, el proceso privilegiado llama a la instrucción **`ERET`** para que el procesador haga la transición a **`AArch32`** entrando en A32 o T32 dependiendo del CPSR**.**
+
+El **`interworking`** ocurre utilizando los bits J y T del CPSR. `J=0` y `T=0` significa **`A32`** y `J=0` y `T=1` significa **T32**. Esto básicamente se traduce en establecer el **bit más bajo a 1** para indicar que el conjunto de instrucciones es T32.\
+Esto se establece durante las **instrucciones de ramificación de interworking,** pero también se puede establecer directamente con otras instrucciones cuando el PC se establece como el registro de destino. Ejemplo:
+
+Otro ejemplo:
+```armasm
+_start:
+.code 32                ; Begin using A32
+add r4, pc, #1      ; Here PC is already pointing to "mov r0, #0"
+bx r4               ; Swap to T32 mode: Jump to "mov r0, #0" + 1 (so T32)
+
+.code 16:
+mov r0, #0
+mov r0, #8
+```
+### Registros
+
+Hay 16 registros de 32 bits (r0-r15). **Desde r0 hasta r14** pueden ser utilizados para **cualquier operación**, sin embargo, algunos de ellos suelen estar reservados:
+
+* **`r15`**: Contador de programa (siempre). Contiene la dirección de la siguiente instrucción. En A32 actual + 8, en T32, actual + 4.
+* **`r11`**: Puntero de Marco
+* **`r12`**: Registro de llamada intra-procedural
+* **`r13`**: Puntero de Pila
+* **`r14`**: Registro de Enlace
+
+Además, los registros están respaldados en **`registros bancados`**. Estos son lugares que almacenan los valores de los registros permitiendo realizar **cambios de contexto rápidos** en el manejo de excepciones y operaciones privilegiadas para evitar la necesidad de guardar y restaurar manualmente los registros cada vez.\
+Esto se hace **guardando el estado del procesador del `CPSR` al `SPSR`** del modo de procesador al que se toma la excepción. Al retornar de la excepción, el **`CPSR`** se restaura desde el **`SPSR`**.
+
+### CPSR - Registro de Estado del Programa Actual
+
+En AArch32 el CPSR funciona de manera similar a **`PSTATE`** en AArch64 y también se almacena en **`SPSR_ELx`** cuando se toma una excepción para restaurar luego la ejecución:
+
+<figure><img src="../../../.gitbook/assets/image (725).png" alt=""><figcaption></figcaption></figure>
+
+Los campos están divididos en algunos grupos:
+
+* Registro de Estado del Programa de Aplicación (APSR): Banderas aritméticas y accesibles desde EL0
+* Registros de Estado de Ejecución: Comportamiento del proceso (gestionado por el SO).
+
+#### Registro de Estado del Programa de Aplicación (APSR)
+
+* Las banderas **`N`**, **`Z`**, **`C`**, **`V`** (igual que en AArch64)
+* La bandera **`Q`**: Se establece en 1 siempre que ocurre **saturación entera** durante la ejecución de una instrucción aritmética de saturación especializada. Una vez que se establece en **`1`**, mantendrá el valor hasta que se establezca manualmente en 0. Además, no hay ninguna instrucción que verifique su valor implícitamente, debe hacerse leyéndolo manualmente.
+*   **`GE`** (Mayor o igual) Banderas: Se utiliza en operaciones SIMD (Instrucción Única, Datos Múltiples), como "suma paralela" y "resta paralela". Estas operaciones permiten procesar múltiples puntos de datos en una sola instrucción.
+
+Por ejemplo, la instrucción **`UADD8`** **suma cuatro pares de bytes** (de dos operandos de 32 bits) en paralelo y almacena los resultados en un registro de 32 bits. Luego **establece las banderas `GE` en el `APSR`** basándose en estos resultados. Cada bandera GE corresponde a una de las adiciones de bytes, indicando si la adición para ese par de bytes **desbordó**.
+
+La instrucción **`SEL`** utiliza estas banderas GE para realizar acciones condicionales.
+
+#### Registros de Estado de Ejecución
+
+* Los bits **`J`** y **`T`**: **`J`** debe ser 0 y si **`T`** es 0 se utiliza el conjunto de instrucciones A32, y si es 1, se utiliza T32.
+* **Registro de Estado del Bloque IT** (`ITSTATE`): Estos son los bits del 10-15 y 25-26. Almacenan condiciones para instrucciones dentro de un grupo prefijado con **`IT`**.
+* **`E`** bit: Indica la **endiandad**.&#x20;
+* **Bits de Máscara de Modo y Excepción** (0-4): Determinan el estado de ejecución actual. El **quinto** indica si el programa se ejecuta como 32 bits (un 1) o 64 bits (un 0). Los otros 4 representan el **modo de excepción actualmente en uso** (cuando ocurre una excepción y se está manejando). El número establecido **indica la prioridad actual** en caso de que se active otra excepción mientras se está manejando esta.
+
+<figure><img src="../../../.gitbook/assets/image (728).png" alt=""><figcaption></figcaption></figure>
+
+* **`AIF`**: Ciertas excepciones pueden deshabilitarse utilizando los bits **`A`**, `I`, `F`. Si **`A`** es 1 significa que se activarán **abortos asincrónicos**. El **`I`** configura para responder a **Solicitudes de Interrupción de Hardware Externas** (IRQs). y el F está relacionado con **Solicitudes de Interrupción Rápida** (FIRs).
 
 ## macOS
 
 ### Syscalls de BSD
 
-Consulte [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Los syscalls de BSD tendrán **x16 > 0**.
+Consulta [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Los syscalls de BSD tendrán **x16 > 0**.
 
-### Mach Traps
+### Trampas de Mach
 
-Consulte [**syscall\_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall\_sw.c.auto.html). Los Mach traps tendrán **x16 < 0**, por lo que necesitará llamar a los números de la lista anterior con un **menos**: **`_kernelrpc_mach_vm_allocate_trap`** es **`-10`**.
+Consulta [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html). Las trampas de Mach tendrán **x16 < 0**, por lo que necesitas llamar a los números de la lista anterior con un **menos**: **`_kernelrpc_mach_vm_allocate_trap`** es **`-10`**.
 
-También puede revisar **`libsystem_kernel.dylib`** en un desensamblador para encontrar cómo llamar a estos (y a los de BSD) syscalls:
+También puedes consultar **`libsystem_kernel.dylib`** en un desensamblador para encontrar cómo llamar a estos (y a los de BSD) syscalls:
 ```bash
 # macOS
 dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e
@@ -283,7 +342,7 @@ svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter,
 ```
 #### Leer con cat
 
-El objetivo es ejecutar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, por lo que el segundo argumento (x1) es un array de parámetros (lo que en memoria significa una pila de direcciones).
+El objetivo es ejecutar `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, por lo que el segundo argumento (x1) es un arreglo de parámetros (lo que en memoria significa una pila de direcciones).
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -437,9 +496,9 @@ mov  x2, xzr
 mov  x16, #59
 svc  #0x1337
 ```
-#### Conexión inversa
+#### Concha inversa
 
-Desde [https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s), revshell a **127.0.0.1:4444**
+De [https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS\_ARM64\_Shellcode/blob/master/reverseshell.s), revshell a **127.0.0.1:4444**
 ```armasm
 .section __TEXT,__text
 .global _main
@@ -512,10 +571,10 @@ svc  #0x1337
 
 Otras formas de apoyar a HackTricks:
 
-* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
+* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
 * Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
 * Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
-* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
+* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
 * **Comparte tus trucos de hacking enviando PRs a los repositorios de github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
 
 </details>