Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-01-10 12:18:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md

381 lines
15 KiB
Markdown
Raw Normal View History

Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
# macOS MIG - Generador de Interfaz Mach
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<details>
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
<summary><strong>Aprende a hackear AWS desde cero hasta convertirte en un experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Equipos Rojos de AWS de HackTricks)</strong></a><strong>!</strong></summary>
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2024-01-04 10:16:08 +00:00
Otras formas de apoyar a HackTricks:
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
</details>
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
MIG fue creado para **simplificar el proceso de creación de código de IPC de Mach**. Básicamente **genera el código necesario** para que el servidor y el cliente se comuniquen con una definición dada. Incluso si el código generado es feo, un desarrollador solo necesitará importarlo y su código será mucho más simple que antes.
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
### Ejemplo
Crea un archivo de definición, en este caso con una función muy simple:
{% code title="myipc.defs" %}
```cpp
subsystem myipc 500; // Arbitrary name and id
userprefix USERPREF; // Prefix for created functions in the client
serverprefix SERVERPREF; // Prefix for created functions in the server
#include <mach/mach_types.defs>
#include <mach/std_types.defs>
simpleroutine Subtract(
server_port : mach_port_t;
n1 : uint32_t;
n2 : uint32_t);
```
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
{% endcode %}
Ahora utiliza mig para generar el código del servidor y del cliente que serán capaces de comunicarse entre sí para llamar a la función Subtract:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
```bash
mig -header myipcUser.h -sheader myipcServer.h myipc.defs
```
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2024-01-04 10:16:08 +00:00
Se crearán varios archivos nuevos en el directorio actual.
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
En los archivos **`myipcServer.c`** y **`myipcServer.h`** se puede encontrar la declaración y definición de la estructura **`SERVERPREFmyipc_subsystem`**, la cual básicamente define la función a llamar basada en el ID del mensaje recibido (indicamos un número inicial de 500):
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
{% tabs %}
{% tab title="myipcServer.c" %}
```c
/* Description of this subsystem, for use in direct RPC */
const struct SERVERPREFmyipc_subsystem SERVERPREFmyipc_subsystem = {
myipc_server_routine,
500, // start ID
501, // end ID
(mach_msg_size_t)sizeof(union __ReplyUnion__SERVERPREFmyipc_subsystem),
(vm_address_t)0,
{
{ (mig_impl_routine_t) 0,
// Function to call
(mig_stub_routine_t) _XSubtract, 3, 0, (routine_arg_descriptor_t)0, (mach_msg_size_t)sizeof(__Reply__Subtract_t)},
}
};
```
{% endtab %}
Translated ['forensics/basic-forensic-methodology/specific-software-file
2023-12-26 02:09:27 +00:00
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
{% tab title="myipcServer.h" %}
### macOS MIG (Mach Interface Generator)
El Generador de Interfaz Mach (MIG) es una herramienta utilizada en macOS para generar código fuente en C a partir de definiciones de interfaz. Permite la comunicación entre procesos a través de llamadas a procedimientos remotos.
#### Creación de una definición de interfaz
Para crear una definición de interfaz en MIG, se debe definir un archivo `.defs` que contenga las declaraciones de los procedimientos que se pueden llamar de forma remota. Por ejemplo:
```c
routine my_remote_procedure_1(
in int input,
out int output
);
```
#### Generación de código fuente
Una vez que se tiene la definición de la interfaz en el archivo `.defs`, se puede utilizar MIG para generar el código fuente en C correspondiente. Esto se logra ejecutando el siguiente comando en la terminal:
```bash
mig myipc.defs -header myipcServer.h -user myipcUser.c
```
Esto generará los archivos `myipcServer.h` y `myipcUser.c` que se pueden utilizar en la implementación de la comunicación entre procesos en macOS.
La comunicación entre procesos a través de MIG es una técnica poderosa, pero también puede ser utilizada de forma maliciosa para la escalada de privilegios en sistemas macOS. Es importante asegurarse de que las comunicaciones a través de MIG estén debidamente protegidas para evitar posibles vulnerabilidades de seguridad.
{% endtab %}
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
```c
/* Description of this subsystem, for use in direct RPC */
extern const struct SERVERPREFmyipc_subsystem {
mig_server_routine_t server; /* Server routine */
mach_msg_id_t start; /* Min routine number */
mach_msg_id_t end; /* Max routine number + 1 */
unsigned int maxsize; /* Max msg size */
vm_address_t reserved; /* Reserved */
struct routine_descriptor /* Array of routine descriptors */
routine[1];
} SERVERPREFmyipc_subsystem;
```
{% endtab %}
{% endtabs %}
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
Basado en la estructura anterior, la función **`myipc_server_routine`** obtendrá el **ID del mensaje** y devolverá la función adecuada para llamar:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
```c
mig_external mig_routine_t myipc_server_routine
(mach_msg_header_t *InHeadP)
{
int msgh_id;
msgh_id = InHeadP->msgh_id - 500;
if ((msgh_id > 0) || (msgh_id < 0))
return 0;
return SERVERPREFmyipc_subsystem.routine[msgh_id].stub_routine;
}
```
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
En este ejemplo solo hemos definido 1 función en las definiciones, pero si hubiéramos definido más funciones, estarían dentro del array de **`SERVERPREFmyipc_subsystem`** y la primera se habría asignado al ID **500**, la segunda al ID **501**...
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
Translated ['forensics/basic-forensic-methodology/specific-software-file
2023-12-26 02:09:27 +00:00
De hecho, es posible identificar esta relación en la estructura **`subsystem_to_name_map_myipc`** de **`myipcServer.h`**:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
```c
#ifndef subsystem_to_name_map_myipc
#define subsystem_to_name_map_myipc \
{ "Subtract", 500 }
#endif
```
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
Finalmente, otra función importante para hacer que el servidor funcione será **`myipc_server`**, que es la que realmente **llamará a la función** relacionada con el ID recibido:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<pre class="language-c"><code class="lang-c">mig_external boolean_t myipc_server
(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)
{
/*
* typedef struct {
* mach_msg_header_t Head;
* NDR_record_t NDR;
* kern_return_t RetCode;
* } mig_reply_error_t;
*/
mig_routine_t routine;
OutHeadP->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InHeadP->msgh_bits), 0);
OutHeadP->msgh_remote_port = InHeadP->msgh_reply_port;
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
/* Tamaño mínimo: ¡routine() lo actualizará si es diferente! */
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
OutHeadP->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
OutHeadP->msgh_local_port = MACH_PORT_NULL;
OutHeadP->msgh_id = InHeadP->msgh_id + 100;
OutHeadP->msgh_reserved = 0;
if ((InHeadP->msgh_id > 500) || (InHeadP->msgh_id &#x3C; 500) ||
<strong> ((routine = SERVERPREFmyipc_subsystem.routine[InHeadP->msgh_id - 500].stub_routine) == 0)) {
</strong> ((mig_reply_error_t *)OutHeadP)->NDR = NDR_record;
((mig_reply_error_t *)OutHeadP)->RetCode = MIG_BAD_ID;
return FALSE;
}
<strong> (*routine) (InHeadP, OutHeadP);
</strong> return TRUE;
}
</code></pre>
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
Verifique las líneas previamente resaltadas accediendo a la función a llamar por ID.
Translated ['README.md', 'backdoors/salseo.md', 'forensics/basic-forensi
2023-12-16 14:31:06 +00:00
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
En lo siguiente se muestra el código para crear un **servidor** y un **cliente** simples donde el cliente puede llamar a las funciones Restar desde el servidor:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
{% tabs %}
{% tab title="myipc_server.c" %}
```c
// gcc myipc_server.c myipcServer.c -o myipc_server
#include <stdio.h>
#include <mach/mach.h>
#include <servers/bootstrap.h>
#include "myipcServer.h"
kern_return_t SERVERPREFSubtract(mach_port_t server_port, uint32_t n1, uint32_t n2)
{
printf("Received: %d - %d = %d\n", n1, n2, n1 - n2);
return KERN_SUCCESS;
}
int main() {
mach_port_t port;
kern_return_t kr;
// Register the mach service
kr = bootstrap_check_in(bootstrap_port, "xyz.hacktricks.mig", &port);
if (kr != KERN_SUCCESS) {
printf("bootstrap_check_in() failed with code 0x%x\n", kr);
return 1;
}
// myipc_server is the function that handles incoming messages (check previous exlpanation)
mach_msg_server(myipc_server, sizeof(union __RequestUnion__SERVERPREFmyipc_subsystem), port, MACH_MSG_TIMEOUT_NONE);
}
```
Translated ['README.md', 'backdoors/salseo.md', 'forensics/basic-forensi
2023-12-16 14:31:06 +00:00
{% endtab %}
Translated ['forensics/basic-forensic-methodology/specific-software-file
2023-12-26 02:09:27 +00:00
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
{% tab title="myipc_client.c" %}
### macOS MIG (Mach Interface Generator)
El Generador de Interfaz Mach (MIG) es una herramienta utilizada en macOS para generar código que facilita la comunicación entre procesos a través de llamadas a procedimientos remotos. Permite a los procesos enviar mensajes y datos entre sí de manera eficiente y segura.
En el contexto de la seguridad, el uso de MIG puede introducir vulnerabilidades si no se implementa correctamente. Los atacantes pueden abusar de las interfaces generadas por MIG para realizar escaladas de privilegios u otros ataques.
Es fundamental comprender cómo se implementan y utilizan las interfaces MIG en macOS para garantizar que no se produzcan vulnerabilidades de seguridad en las aplicaciones y sistemas.
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
```c
// gcc myipc_client.c myipcUser.c -o myipc_client
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <mach/mach.h>
#include <servers/bootstrap.h>
#include "myipcUser.h"
int main() {
// Lookup the receiver port using the bootstrap server.
mach_port_t port;
kern_return_t kr = bootstrap_look_up(bootstrap_port, "xyz.hacktricks.mig", &port);
if (kr != KERN_SUCCESS) {
printf("bootstrap_look_up() failed with code 0x%x\n", kr);
return 1;
}
printf("Port right name %d\n", port);
USERPREFSubtract(port, 40, 2);
}
```
Translated ['forensics/basic-forensic-methodology/specific-software-file
2023-12-26 02:09:27 +00:00
### Análisis Binario
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
Dado que muchos binarios ahora utilizan MIG para exponer puertos mach, es interesante saber cómo **identificar que se utilizó MIG** y las **funciones que MIG ejecuta** con cada ID de mensaje.
[**jtool2**](../../macos-apps-inspecting-debugging-and-fuzzing/#jtool2) puede analizar la información de MIG de un binario Mach-O indicando el ID del mensaje e identificando la función a ejecutar:
```bash
jtool2 -d __DATA.__const myipc_server | grep MIG
```
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
Se mencionó anteriormente que la función que se encargará de **llamar a la función correcta dependiendo del ID del mensaje recibido** era `myipc_server`. Sin embargo, generalmente no se tendrán los símbolos del binario (nombres de funciones), por lo que es interesante **ver cómo se ve decompilado** ya que siempre será muy similar (el código de esta función es independiente de las funciones expuestas):
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
{% tabs %}
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
{% tab title="myipc_server decompiled 1" %}
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<pre class="language-c"><code class="lang-c">int _myipc_server(int arg0, int arg1) {
var_10 = arg0;
var_18 = arg1;
// Instrucciones iniciales para encontrar los punteros de función adecuados
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f;
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
*(int32_t *)(var_18 + 0x8) = *(int32_t *)(var_10 + 0x8);
*(int32_t *)(var_18 + 0x4) = 0x24;
*(int32_t *)(var_18 + 0xc) = 0x0;
*(int32_t *)(var_18 + 0x14) = *(int32_t *)(var_10 + 0x14) + 0x64;
*(int32_t *)(var_18 + 0x10) = 0x0;
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
if (*(int32_t *)(var_10 + 0x14) <= 0x1f4 && *(int32_t *)(var_10 + 0x14) >= 0x1f4) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
rax = *(int32_t *)(var_10 + 0x14);
// Llamada a sign_extend_64 que puede ayudar a identificar esta función
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
// Esto almacena en rax el puntero a la llamada que debe realizarse
// Ver el uso de la dirección 0x100004040 (array de direcciones de funciones)
// 0x1f4 = 500 (el ID de inicio)
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<strong> rax = *(sign_extend_64(rax - 0x1f4) * 0x28 + 0x100004040);
</strong> var_20 = rax;
Translated ['forensics/basic-forensic-methodology/specific-software-file
2023-11-02 17:51:22 +00:00
// If - else, el if devuelve falso, mientras que el else llama a la función correcta y devuelve verdadero
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<strong> if (rax == 0x0) {
</strong> *(var_18 + 0x18) = **_NDR_record;
*(int32_t *)(var_18 + 0x20) = 0xfffffffffffffed1;
var_4 = 0x0;
}
else {
// Dirección calculada que llama a la función adecuada con 2 argumentos
<strong> (var_20)(var_10, var_18);
</strong> var_4 = 0x1;
}
}
else {
*(var_18 + 0x18) = **_NDR_record;
*(int32_t *)(var_18 + 0x20) = 0xfffffffffffffed1;
var_4 = 0x0;
}
rax = var_4;
return rax;
}
</code></pre>
{% endtab %}
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
{% tab title="myipc_server decompiled 2" %}
Esta es la misma función decompilada en una versión gratuita diferente de Hopper:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<pre class="language-c"><code class="lang-c">int _myipc_server(int arg0, int arg1) {
r31 = r31 - 0x40;
saved_fp = r29;
stack[-8] = r30;
var_10 = arg0;
var_18 = arg1;
// Instrucciones iniciales para encontrar los punteros de función adecuados
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
*(int32_t *)var_18 = *(int32_t *)var_10 & 0x1f | 0x0;
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
*(int32_t *)(var_18 + 0x8) = *(int32_t *)(var_10 + 0x8);
*(int32_t *)(var_18 + 0x4) = 0x24;
*(int32_t *)(var_18 + 0xc) = 0x0;
*(int32_t *)(var_18 + 0x14) = *(int32_t *)(var_10 + 0x14) + 0x64;
*(int32_t *)(var_18 + 0x10) = 0x0;
r8 = *(int32_t *)(var_10 + 0x14);
r8 = r8 - 0x1f4;
if (r8 > 0x0) {
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
if (CPU_FLAGS & G) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
r8 = 0x1;
}
}
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
if ((r8 & 0x1) == 0x0) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
r8 = *(int32_t *)(var_10 + 0x14);
r8 = r8 - 0x1f4;
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
if (r8 < 0x0) {
if (CPU_FLAGS & L) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
r8 = 0x1;
}
}
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
if ((r8 & 0x1) == 0x0) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
r8 = *(int32_t *)(var_10 + 0x14);
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
// 0x1f4 = 500 (el ID de inicio)
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
<strong> r8 = r8 - 0x1f4;
</strong> asm { smaddl x8, w8, w9, x10 };
r8 = *(r8 + 0x8);
var_20 = r8;
r8 = r8 - 0x0;
if (r8 != 0x0) {
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
if (CPU_FLAGS & NE) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
r8 = 0x1;
}
}
// Mismo if else que en la versión anterior
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
// Ver el uso de la dirección 0x100004040 (array de direcciones de funciones)
<strong> if ((r8 & 0x1) == 0x0) {
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
</strong><strong> *(var_18 + 0x18) = **0x100004000;
</strong> *(int32_t *)(var_18 + 0x20) = 0xfffffed1;
var_4 = 0x0;
}
else {
// Llamada a la dirección calculada donde debería estar la función
<strong> (var_20)(var_10, var_18);
</strong> var_4 = 0x1;
}
}
else {
*(var_18 + 0x18) = **0x100004000;
*(int32_t *)(var_18 + 0x20) = 0xfffffed1;
var_4 = 0x0;
}
}
else {
*(var_18 + 0x18) = **0x100004000;
*(int32_t *)(var_18 + 0x20) = 0xfffffed1;
var_4 = 0x0;
}
r0 = var_4;
return r0;
}
</code></pre>
{% endtab %}
{% endtabs %}
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
De hecho, si vas a la función **`0x100004000`** encontrarás el array de estructuras **`routine_descriptor`**. El primer elemento de la estructura es la **dirección** donde está implementada la **función**, y la **estructura ocupa 0x28 bytes**, por lo que cada 0x28 bytes (comenzando desde el byte 0) puedes obtener 8 bytes y esa será la **dirección de la función** que se llamará:
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2024-01-04 10:16:08 +00:00
Translated ['README.md', 'backdoors/salseo.md', 'cryptography/certificat
2024-01-10 06:28:19 +00:00
<figure><img src="../../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
<figure><img src="../../../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2024-01-04 10:16:08 +00:00
Translated ['generic-methodologies-and-resources/external-recon-methodol
2024-02-23 16:28:45 +00:00
Estos datos se pueden extraer [**usando este script de Hopper**](https://github.com/knightsc/hopper/blob/master/scripts/MIG%20Detect.py).
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
Translated ['macos-hardening/macos-security-and-privilege-escalation/mac
2023-10-05 22:38:31 +00:00
</details>
Reference in a new issue Copy permalink