iOS Pentesting

Use Trickest para construir e automatizar fluxos de trabalho facilmente, impulsionados pelas ferramentas da comunidade mais avançadas do mundo. Obtenha Acesso Hoje:

Support HackTricks

• Confira os planos de assinatura!

• Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-nos no Twitter 🐦 @hacktricks_live.

• Compartilhe truques de hacking enviando PRs para o HackTricks e HackTricks Cloud repositórios do github.

iOS Basics

Testing Environment

Nesta página você pode encontrar informações sobre o simulador iOS, emuladores e jailbreaking:

Initial Analysis

Basic iOS Testing Operations

Durante o teste várias operações serão sugeridas (conectar ao dispositivo, ler/escrever/enviar/baixar arquivos, usar algumas ferramentas...). Portanto, se você não souber como realizar alguma dessas ações, por favor, comece a ler a página:

Para os próximos passos o app deve estar instalado no dispositivo e já deve ter obtido o arquivo IPA da aplicação. Leia a página Basic iOS Testing Operations para aprender como fazer isso.

Basic Static Analysis

É recomendado usar a ferramenta MobSF para realizar uma Análise Estática automática no arquivo IPA.

Identificação de proteções presentes no binário:

• PIE (Position Independent Executable): Quando habilitado, o aplicativo é carregado em um endereço de memória aleatório toda vez que é iniciado, dificultando a previsão de seu endereço de memória inicial.

otool -hv <app-binary> | grep PIE   # Deve incluir a flag PIE

• Stack Canaries: Para validar a integridade da pilha, um valor ‘canário’ é colocado na pilha antes de chamar uma função e é validado novamente uma vez que a função termina.

otool -I -v <app-binary> | grep stack_chk   # Deve incluir os símbolos: stack_chk_guard e stack_chk_fail

• ARC (Automatic Reference Counting): Para prevenir falhas comuns de corrupção de memória

otool -I -v <app-binary> | grep objc_release   # Deve incluir o símbolo _objc_release

• Binary Encriptado: O binário deve estar encriptado

otool -arch all -Vl <app-binary> | grep -A5 LC_ENCRYPT   # O cryptid deve ser 1

Identificação de Funções Sensíveis/Inseguras

• Algoritmos de Hashing Fracos

# No dispositivo iOS
otool -Iv <app> | grep -w "_CC_MD5"
otool -Iv <app> | grep -w "_CC_SHA1"

# No linux
grep -iER "_CC_MD5"
grep -iER "_CC_SHA1"

• Funções Aleatórias Inseguras

# No dispositivo iOS
otool -Iv <app> | grep -w "_random"
otool -Iv <app> | grep -w "_srand"
otool -Iv <app> | grep -w "_rand"

# No linux
grep -iER "_random"
grep -iER "_srand"
grep -iER "_rand"

• Função ‘Malloc’ Insegura

# No dispositivo iOS
otool -Iv <app> | grep -w "_malloc"

# No linux
grep -iER "_malloc"

• Funções Inseguras e Vulneráveis

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

# No 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"

Basic Dynamic Analysis

Confira a análise dinâmica que MobSF realiza. Você precisará navegar pelas diferentes visualizações e interagir com elas, mas ele irá interceptar várias classes ao fazer outras coisas e preparará um relatório assim que você terminar.

Listing Installed Apps

Use o comando frida-ps -Uai para determinar o identificador do pacote dos aplicativos instalados:

$ frida-ps -Uai
PID  Name                 Identifier
----  -------------------  -----------------------------------------
6847  Calendar             com.apple.mobilecal
6815  Mail                 com.apple.mobilemail
-  App Store            com.apple.AppStore
-  Apple Store          com.apple.store.Jolly
-  Calculator           com.apple.calculator
-  Camera               com.apple.camera
-  iGoat-Swift          OWASP.iGoat-Swift

Enumeração Básica & Hooking

Aprenda como enumerar os componentes da aplicação e como hookear métodos e classes com objection:

Estrutura IPA

A estrutura de um arquivo IPA é essencialmente a de um pacote zipado. Ao renomear sua extensão para .zip, ele pode ser descompactado para revelar seu conteúdo. Dentro dessa estrutura, um Bundle representa uma aplicação totalmente empacotada e pronta para instalação. Dentro, você encontrará um diretório chamado <NAME>.app, que encapsula os recursos da aplicação.

• Info.plist: Este arquivo contém detalhes específicos de configuração da aplicação.

• _CodeSignature/: Este diretório inclui um arquivo plist que contém uma assinatura, garantindo a integridade de todos os arquivos no bundle.

• Assets.car: Um arquivo compactado que armazena arquivos de ativos, como ícones.

• Frameworks/: Esta pasta abriga as bibliotecas nativas da aplicação, que podem estar na forma de arquivos .dylib ou .framework.

• PlugIns/: Isso pode incluir extensões para a aplicação, conhecidas como arquivos .appex, embora nem sempre estejam presentes. * Core Data: É usado para salvar os dados permanentes da sua aplicação para uso offline, para armazenar dados temporários e para adicionar funcionalidade de desfazer à sua aplicação em um único dispositivo. Para sincronizar dados em vários dispositivos em uma única conta do iCloud, o Core Data espelha automaticamente seu esquema para um contêiner do CloudKit.

• PkgInfo: O arquivo PkgInfo é uma maneira alternativa de especificar os códigos de tipo e criador da sua aplicação ou bundle.

• en.lproj, fr.proj, Base.lproj: São os pacotes de idioma que contêm recursos para esses idiomas específicos e um recurso padrão caso um idioma não seja suportado.

• Segurança: O diretório _CodeSignature/ desempenha um papel crítico na segurança do aplicativo, verificando a integridade de todos os arquivos empacotados por meio de assinaturas digitais.

• Gerenciamento de Ativos: O arquivo Assets.car utiliza compressão para gerenciar eficientemente ativos gráficos, crucial para otimizar o desempenho da aplicação e reduzir seu tamanho total.

• Frameworks e PlugIns: Esses diretórios destacam a modularidade das aplicações iOS, permitindo que os desenvolvedores incluam bibliotecas de código reutilizáveis (Frameworks/) e estendam a funcionalidade do aplicativo (PlugIns/).

• Localização: A estrutura suporta vários idiomas, facilitando o alcance global da aplicação ao incluir recursos para pacotes de idiomas específicos.

Info.plist

O Info.plist serve como uma pedra angular para aplicações iOS, encapsulando dados de configuração chave na forma de pares chave-valor. Este arquivo é um requisito não apenas para aplicações, mas também para extensões de aplicativos e frameworks empacotados dentro. Está estruturado em formato XML ou binário e contém informações críticas que vão desde permissões de aplicativo até configurações de segurança. Para uma exploração detalhada das chaves disponíveis, pode-se consultar a Documentação do Desenvolvedor Apple.

Para aqueles que desejam trabalhar com este arquivo em um formato mais acessível, a conversão para XML pode ser realizada facilmente através do uso de plutil no macOS (disponível nativamente nas versões 10.2 e posteriores) ou plistutil no Linux. Os comandos para conversão são os seguintes:

• Para macOS:

$ plutil -convert xml1 Info.plist

• Para Linux:

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

Entre a miríade de informações que o arquivo Info.plist pode divulgar, entradas notáveis incluem strings de permissão do aplicativo (UsageDescription), esquemas de URL personalizados (CFBundleURLTypes) e configurações para a Segurança de Transporte de Aplicativos (NSAppTransportSecurity). Essas entradas, junto com outras como tipos de documentos personalizados exportados/importados (UTExportedTypeDeclarations / UTImportedTypeDeclarations), podem ser facilmente localizadas inspecionando o arquivo ou empregando um simples comando grep:

$ grep -i <keyword> Info.plist

Caminhos de Dados

No ambiente iOS, diretórios são designados especificamente para aplicações do sistema e aplicações instaladas pelo usuário. Aplicações do sistema residem no diretório /Applications, enquanto aplicativos instalados pelo usuário são colocados em /var/mobile/containers/Data/Application/. Essas aplicações recebem um identificador único conhecido como UUID de 128 bits, tornando a tarefa de localizar manualmente a pasta de um aplicativo desafiadora devido à aleatoriedade dos nomes dos diretórios.

Como as aplicações no iOS devem ser isoladas, cada aplicativo também terá uma pasta dentro de $HOME/Library/Containers com o CFBundleIdentifier do aplicativo como o nome da pasta.

No entanto, ambas as pastas (dados e pastas de contêiner) possuem o arquivo .com.apple.mobile_container_manager.metadata.plist que vincula ambos os arquivos na chave MCMetadataIdentifier).

Para facilitar a descoberta do diretório de instalação de um aplicativo instalado pelo usuário, a ferramenta objection fornece um comando útil, env. Este comando revela informações detalhadas do diretório para o aplicativo em questão. Abaixo está um exemplo de como usar este comando:

OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # env

Name               Path
-----------------  -------------------------------------------------------------------------------------------
BundlePath         /var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app
CachesDirectory    /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Library/Caches
DocumentDirectory  /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Documents
LibraryDirectory   /var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693/Library

Alternativamente, o nome do aplicativo pode ser pesquisado dentro de /private/var/containers usando o comando find:

find /private/var/containers -name "Progname*"

Comandos como ps e lsof também podem ser utilizados para identificar o processo do aplicativo e listar arquivos abertos, respectivamente, fornecendo informações sobre os caminhos de diretório ativos do aplicativo:

ps -ef | grep -i <app-name>
lsof -p <pid> | grep -i "/containers" | head -n 1

Diretório do pacote:

• AppName.app

• Este é o Pacote da Aplicação, como visto anteriormente no IPA, contém dados essenciais da aplicação, conteúdo estático, bem como o binário compilado da aplicação.

• Este diretório é visível para os usuários, mas os usuários não podem escrever nele.

• O conteúdo deste diretório não é salvo.

• O conteúdo desta pasta é usado para validar a assinatura do código.

Diretório de dados:

• Documents/

• Contém todos os dados gerados pelo usuário. O usuário final da aplicação inicia a criação desses dados.

• Visível para os usuários e os usuários podem escrever nele.

• O conteúdo deste diretório é salvo.

• O app pode desabilitar caminhos configurando NSURLIsExcludedFromBackupKey.

• Library/

• Contém todos os arquivos que não são específicos do usuário, como caches, preferências, cookies e arquivos de configuração de lista de propriedades (plist).

• Aplicativos iOS geralmente usam os subdiretórios Application Support e Caches, mas o app pode criar subdiretórios personalizados.

• Library/Caches/

• Contém arquivos de cache semi-persistentes.

• Invisível para os usuários e os usuários não podem escrever nele.

• O conteúdo deste diretório não é salvo.

• O sistema operacional pode excluir automaticamente os arquivos deste diretório quando o app não está em execução e o espaço de armazenamento está baixo.

• Library/Application Support/

• Contém arquivos persistentes necessários para a execução do app.

• Invisível para os usuários e os usuários não podem escrever nele.

• O conteúdo deste diretório é salvo.

• O app pode desabilitar caminhos configurando NSURLIsExcludedFromBackupKey.

• Library/Preferences/

• Usado para armazenar propriedades que podem persistir mesmo após a reinicialização de uma aplicação.

• As informações são salvas, sem criptografia, dentro do sandbox da aplicação em um arquivo plist chamado [BUNDLE_ID].plist.

• Todos os pares chave/valor armazenados usando NSUserDefaults podem ser encontrados neste arquivo.

• tmp/

• Use este diretório para escrever arquivos temporários que não precisam persistir entre as execuções do app.

• Contém arquivos de cache não persistentes.

• Invisível para os usuários.

• O conteúdo deste diretório não é salvo.

• O sistema operacional pode excluir automaticamente os arquivos deste diretório quando o app não está em execução e o espaço de armazenamento está baixo.

Vamos dar uma olhada mais de perto no Pacote da Aplicação do iGoat-Swift (.app) dentro do diretório do Pacote (/var/containers/Bundle/Application/3ADAF47D-A734-49FA-B274-FBCA66589E67/iGoat-Swift.app):

OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # ls
NSFileType      Perms  NSFileProtection    ...  Name
------------  -------  ------------------  ...  --------------------------------------
Regular           420  None                ...  rutger.html
Regular           420  None                ...  mansi.html
Regular           420  None                ...  splash.html
Regular           420  None                ...  about.html

Regular           420  None                ...  LICENSE.txt
Regular           420  None                ...  Sentinel.txt
Regular           420  None                ...  README.txt

Binary Reversing

Dentro da pasta <application-name>.app, você encontrará um arquivo binário chamado <application-name>. Este é o arquivo que será executado. Você pode realizar uma inspeção básica do binário com a ferramenta otool:

otool -Vh DVIA-v2 #Check some compilation attributes
magic  cputype cpusubtype  caps    filetype ncmds sizeofcmds      flags
MH_MAGIC_64    ARM64        ALL  0x00     EXECUTE    65       7112   NOUNDEFS DYLDLINK TWOLEVEL WEAK_DEFINES BINDS_TO_WEAK PIE

otool -L DVIA-v2 #Get third party libraries
DVIA-v2:
/usr/lib/libc++.1.dylib (compatibility version 1.0.0, current version 400.9.1)
/usr/lib/libsqlite3.dylib (compatibility version 9.0.0, current version 274.6.0)
/usr/lib/libz.1.dylib (compatibility version 1.0.0, current version 1.2.11)
@rpath/Bolts.framework/Bolts (compatibility version 1.0.0, current version 1.0.0)
[...]

Verifique se o aplicativo está criptografado

Veja se há alguma saída para:

otool -l <app-binary> | grep -A 4 LC_ENCRYPTION_INFO

Desmontando o binário

Desmonte a seção de texto:

otool -tV DVIA-v2
DVIA-v2:
(__TEXT,__text) section
+[DDLog initialize]:
0000000100004ab8    sub    sp, sp, #0x60
0000000100004abc    stp    x29, x30, [sp, #0x50]   ; Latency: 6
0000000100004ac0    add    x29, sp, #0x50
0000000100004ac4    sub    x8, x29, #0x10
0000000100004ac8    mov    x9, #0x0
0000000100004acc    adrp    x10, 1098 ; 0x10044e000
0000000100004ad0    add    x10, x10, #0x268

Para imprimir o segmento Objective-C do aplicativo de amostra, pode-se usar:

otool -oV DVIA-v2
DVIA-v2:
Contents of (__DATA,__objc_classlist) section
00000001003dd5b8 0x1004423d0 _OBJC_CLASS_$_DDLog
isa        0x1004423a8 _OBJC_METACLASS_$_DDLog
superclass 0x0 _OBJC_CLASS_$_NSObject
cache      0x0 __objc_empty_cache
vtable     0x0
data       0x1003de748
flags          0x80
instanceStart  8

Para obter um código Objective-C mais compacto, você pode usar class-dump:

class-dump some-app
//
//     Generated by class-dump 3.5 (64 bit).
//
//     class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//

#pragma mark Named Structures

struct CGPoint {
double _field1;
double _field2;
};

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

struct CGSize {
double _field1;
double _field2;
};

No entanto, as melhores opções para desassemblar o binário são: Hopper e IDA.

Use Trickest para construir e automatizar fluxos de trabalho facilmente, impulsionados pelas ferramentas da comunidade mais avançadas do mundo. Acesse hoje:

Armazenamento de Dados

Para aprender sobre como o iOS armazena dados no dispositivo, leia esta página:

Os seguintes locais para armazenar informações devem ser verificados logo após a instalação do aplicativo, após verificar todas as funcionalidades do aplicativo e até mesmo após sair de um usuário e entrar em um diferente. O objetivo é encontrar informações sensíveis não protegidas do aplicativo (senhas, tokens), do usuário atual e de usuários que se conectaram anteriormente.

Plist

Os arquivos plist são arquivos XML estruturados que contêm pares chave-valor. É uma forma de armazenar dados persistentes, então às vezes você pode encontrar informações sensíveis nesses arquivos. É recomendado verificar esses arquivos após a instalação do aplicativo e após usá-lo intensivamente para ver se novos dados são escritos.

A forma mais comum de persistir dados em arquivos plist é através do uso de NSUserDefaults. Este arquivo plist é salvo dentro do sandbox do aplicativo em Library/Preferences/<appBundleID>.plist

A classe NSUserDefaults fornece uma interface programática para interagir com o sistema padrão. O sistema padrão permite que um aplicativo personalize seu comportamento de acordo com as preferências do usuário. Os dados salvos pelo NSUserDefaults podem ser visualizados no pacote do aplicativo. Esta classe armazena dados em um arquivo plist, mas é destinada a ser usada com pequenas quantidades de dados.

Esses dados não podem ser acessados diretamente via um computador confiável, mas podem ser acessados realizando um backup.

Você pode extrair as informações salvas usando NSUserDefaults com o comando ios nsuserdefaults get do objection.

Para encontrar todos os plist usados pelo aplicativo, você pode acessar /private/var/mobile/Containers/Data/Application/{APPID} e executar:

find ./ -name "*.plist"

Para converter arquivos do formato XML ou binário (bplist) para XML, vários métodos dependendo do seu sistema operacional estão disponíveis:

Para usuários do macOS: Utilize o comando plutil. É uma ferramenta embutida no macOS (10.2+), projetada para esse propósito:

$ plutil -convert xml1 Info.plist

Para usuários do Linux: Instale libplist-utils primeiro, depois use plistutil para converter seu arquivo:

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

Dentro de uma Sessão Objection: Para analisar aplicativos móveis, um comando específico permite que você converta arquivos plist diretamente:

ios plist cat /private/var/mobile/Containers/Data/Application/<Application-UUID>/Library/Preferences/com.some.package.app.plist

Core Data

Core Data é um framework para gerenciar a camada de modelo de objetos em seu aplicativo. Core Data pode usar SQLite como seu armazenamento persistente, mas o framework em si não é um banco de dados. CoreData não criptografa seus dados por padrão. No entanto, uma camada de criptografia adicional pode ser adicionada ao CoreData. Veja o GitHub Repo para mais detalhes.

Você pode encontrar as informações do SQLite Core Data de um aplicativo no caminho /private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support

Se você conseguir abrir o SQLite e acessar informações sensíveis, então você encontrou uma má configuração.

Code from iGoat

-(void)storeDetails {
AppDelegate * appDelegate = (AppDelegate *)(UIApplication.sharedApplication.delegate);

NSManagedObjectContext *context =[appDelegate managedObjectContext];

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

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

YapDatabase

YapDatabase é um armazenamento chave/valor construído sobre o SQLite. Como os bancos de dados Yap são bancos de dados sqlite, você pode encontrá-los usando o comando proposto na seção anterior.

Outros Bancos de Dados SQLite

É comum que aplicativos criem seu próprio banco de dados sqlite. Eles podem estar armazenando dados sensíveis neles e deixá-los não criptografados. Portanto, é sempre interessante verificar cada banco de dados dentro do diretório dos aplicativos. Portanto, vá para o diretório do aplicativo onde os dados são salvos (/private/var/mobile/Containers/Data/Application/{APPID})

find ./ -name "*.sqlite" -or -name "*.db"

Firebase Real-Time Databases

Os desenvolvedores podem armazenar e sincronizar dados dentro de um banco de dados NoSQL hospedado na nuvem através do Firebase Real-Time Databases. Armazenados em formato JSON, os dados são sincronizados para todos os clientes conectados em tempo real.

Você pode encontrar como verificar bancos de dados Firebase mal configurados aqui:

Realm databases

Realm Objective-C e Realm Swift oferecem uma alternativa poderosa para armazenamento de dados, não fornecida pela Apple. Por padrão, eles armazenam dados não criptografados, com criptografia disponível através de configuração específica.

Os bancos de dados estão localizados em: /private/var/mobile/Containers/Data/Application/{APPID}. Para explorar esses arquivos, pode-se utilizar comandos como:

iPhone:/private/var/mobile/Containers/Data/Application/A079DF84-726C-4AEA-A194-805B97B3684A/Documents root# ls
default.realm  default.realm.lock  default.realm.management/  default.realm.note|

$ find ./ -name "*.realm*"

Para visualizar esses arquivos de banco de dados, a ferramenta Realm Studio é recomendada.

Para implementar criptografia dentro de um banco de dados Realm, o seguinte trecho de código pode ser usado:

// Open the encrypted Realm file where getKey() is a method to obtain a key from the Keychain or a server
let config = Realm.Configuration(encryptionKey: getKey())
do {
let realm = try Realm(configuration: config)
// Use the Realm as normal
} catch let error as NSError {
// If the encryption key is wrong, `error` will say that it's an invalid database
fatalError("Error opening realm: \(error)")
}

Couchbase Lite Databases

Couchbase Lite é descrito como um mecanismo de banco de dados leve e embutido que segue a abordagem orientada a documentos (NoSQL). Projetado para ser nativo do iOS e macOS, oferece a capacidade de sincronizar dados de forma contínua.

Para identificar potenciais bancos de dados Couchbase em um dispositivo, o seguinte diretório deve ser inspecionado:

ls /private/var/mobile/Containers/Data/Application/{APPID}/Library/Application Support/

Cookies

iOS armazena os cookies dos aplicativos em Library/Cookies/cookies.binarycookies dentro da pasta de cada aplicativo. No entanto, os desenvolvedores às vezes decidem salvá-los no keychain, pois o mencionado arquivo de cookie pode ser acessado em backups.

Para inspecionar o arquivo de cookies, você pode usar este script python ou usar o ios cookies get do objection. Você também pode usar o objection para converter esses arquivos para um formato JSON e inspecionar os dados.

...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"
}
]

Cache

Por padrão, o NSURLSession armazena dados, como requisições e respostas HTTP no banco de dados Cache.db. Este banco de dados pode conter dados sensíveis, se tokens, nomes de usuário ou qualquer outra informação sensível tiver sido armazenada em cache. Para encontrar as informações em cache, abra o diretório de dados do aplicativo (/var/mobile/Containers/Data/Application/<UUID>) e vá para /Library/Caches/<Bundle Identifier>. O cache do WebKit também está sendo armazenado no arquivo Cache.db. Objection pode abrir e interagir com o banco de dados com o comando sqlite connect Cache.db, pois é um banco de dados SQLite normal.

É recomendado desabilitar o armazenamento em cache desses dados, pois pode conter informações sensíveis na requisição ou resposta. A lista a seguir mostra diferentes maneiras de alcançar isso:

1. É recomendado remover as respostas em cache após o logout. Isso pode ser feito com o método fornecido pela Apple chamado removeAllCachedResponses. Você pode chamar este método da seguinte forma:

URLCache.shared.removeAllCachedResponses()

Este método removerá todas as requisições e respostas em cache do arquivo Cache.db. 2. Se você não precisar usar a vantagem dos cookies, seria recomendado usar a propriedade de configuração .ephemeral do URLSession, que desabilitará o salvamento de cookies e caches.

Documentação da Apple:

Um objeto de configuração de sessão efêmera é semelhante a uma configuração de sessão padrão (veja padrão), exceto que o objeto de sessão correspondente não armazena caches, armazenamentos de credenciais ou quaisquer dados relacionados à sessão no disco. Em vez disso, os dados relacionados à sessão são armazenados na RAM. A única vez que uma sessão efêmera grava dados no disco é quando você diz para ela gravar o conteúdo de uma URL em um arquivo. 3. O cache também pode ser desabilitado definindo a Política de Cache como .notAllowed. Isso desabilitará o armazenamento de cache de qualquer forma, seja na memória ou no disco.

Snapshots

Sempre que você pressiona o botão home, o iOS tira uma captura de tela da tela atual para poder fazer a transição para o aplicativo de uma maneira muito mais suave. No entanto, se dados sensíveis estiverem presentes na tela atual, eles serão salvos na imagem (que persiste através de reinicializações). Essas são as capturas que você também pode acessar tocando duas vezes na tela inicial para alternar entre aplicativos.

A menos que o iPhone esteja com jailbreak, o atacante precisa ter acesso ao dispositivo desbloqueado para ver essas capturas de tela. Por padrão, a última captura é armazenada no sandbox do aplicativo na pasta Library/Caches/Snapshots/ ou Library/SplashBoard/Snapshots (os computadores confiáveis não podem acessar o sistema de arquivos a partir do iOS 7.0).

Uma maneira de prevenir esse comportamento indesejado é colocar uma tela em branco ou remover os dados sensíveis antes de tirar a captura usando a função ApplicationDidEnterBackground().

A seguir está um método de remediação de exemplo que definirá uma captura de tela padrão.

Swift:

private var backgroundImage: UIImageView?

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

func applicationWillEnterForeground(_ application: UIApplication) {
backgroundImage?.removeFromSuperview()
}

Objetivo-C:

@property (UIImageView *)backgroundImage;

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

- (void)applicationWillEnterForeground:(UIApplication *)application {
[self.backgroundImage removeFromSuperview];
}

Isso define a imagem de fundo como overlayImage.png sempre que o aplicativo é enviado para o segundo plano. Isso previne vazamentos de dados sensíveis porque overlayImage.png sempre substituirá a visualização atual.

Keychain

Para acessar e gerenciar o keychain do iOS, ferramentas como Keychain-Dumper estão disponíveis, adequadas para dispositivos com jailbreak. Além disso, Objection fornece o comando ios keychain dump para propósitos semelhantes.

Armazenando Credenciais

A classe NSURLCredential é ideal para salvar informações sensíveis diretamente no keychain, evitando a necessidade de NSUserDefaults ou outros wrappers. Para armazenar credenciais após o login, o seguinte código Swift é usado: