WebView - Inclusione di file non sicuri

Categoria OWASP: MASVS-STORAGE: Storage

Panoramica

Questo documento tratta diversi problemi relativi all'inclusione di file che condividono mitigazioni simili. Questi problemi riguardano le vulnerabilità derivanti dall'accesso ai file all'interno dei componenti WebView e vanno da WebSettings pericolose che consentono l'accesso ai file o l'attivazione di JavaScript a un metodo WebKit che crea una richiesta di selezione dei file. Questo documento dovrebbe essere utile se stai cercando indicazioni sulla correzione dei problemi all'interno di WebView derivanti dall'utilizzo dello schema file://, dall'accesso illimitato ai file locali e dal cross-site scripting.

Più concretamente, questo documento tratta i seguenti argomenti:

  • WebSettings è una classe che contiene metodi che gestiscono gli stati delle impostazioni per i componenti WebView. Questi metodi possono aprire i componenti WebView a diversi attacchi che verranno descritti in seguito. In questo documento esamineremo i metodi relativi alla modalità di accesso ai file e l'impostazione che consente l'esecuzione di JavaScript:
  • I metodi setAllowFileAccess, setAllowFileAccessFromFileURLs e setAllowUniversalAccessFromFileURLs possono essere utilizzati per concedere l'accesso ai file locali utilizzando un URL dello schema file (file://). Tuttavia, possono essere sfruttati da script dannosi per accedere a file locali arbitrari a cui l'applicazione ha accesso, ad esempio la propria cartella /data/. Per questo motivo, questi metodi sono stati contrassegnati come non sicuri e sono stati ritirati nell'API 30 a favore di alternative più sicure, come WebViewAssetLoader.
  • Il metodo setJavascriptEnabled può essere utilizzato per attivare l'esecuzione di JavaScript all'interno dei componenti WebView. In questo modo, le applicazioni sono vulnerabili al cross-site scripting (XSS) basato su file. In particolare, quando è configurato per consentire il caricamento di file locali o contenuti web non attendibili che potrebbero contenere codice eseguibile, configurato per consentire l'accesso a file che possono essere creati o modificati da fonti esterne o consentire ai componenti WebView di eseguire JavaScript, gli utenti e i loro dati sono a rischio.
  • WebChromeClient.onShowFileChooser è un metodo appartenente al pacchetto android.webkit, che fornisce strumenti di navigazione web. Questo metodo può essere utilizzato per consentire agli utenti di selezionare i file all'interno di un componente WebView. Tuttavia, questa funzionalità può essere utilizzata in modo improprio perché i componenti WebView non applicano restrizioni sul file selezionato.

Impatto

L'impatto dell'inclusione dei file può dipendere dalle impostazioni WebSettings configurate in WebView. Autorizzazioni di file eccessivamente ampie possono consentire agli attaccanti di accedere ai file locali e rubare dati sensibili, informazioni che consentono l'identificazione personale (PII) o dati privati delle app. L'attivazione dell'esecuzione di JavaScript può consentire agli utenti malintenzionati di eseguire JavaScript all'interno di un componente WebView o sul dispositivo di un utente. I file selezionati utilizzando il metodo onShowFileChooser potrebbero compromettere la sicurezza degli utenti, poiché il metodo o il componente WebView non possono garantire che l'origine del file sia attendibile.

Rischio: accesso rischioso ai file tramite file://

L'attivazione di setAllowFileAccess, setAllowFileAccessFromFileURLs e setAllowUniversalAccessFromFileURLs può consentire a intent dannosi e richieste WebView con un contesto file:// di accedere a file locali arbitrari, inclusi i cookie WebView e i dati privati delle app. Inoltre, l'utilizzo del metodo onShowFileChooser può consentire agli utenti di selezionare e scaricare file da fonti non attendibili.

A seconda della configurazione dell'applicazione, tutti questi metodi possono portare all'esfiltrazione di IIP, credenziali di accesso o altri dati sensibili.

Mitigazioni

Convalida gli URL dei file

Se la tua app richiede l'accesso ai file tramite URL file://, è importante consentire solo URL specifici noti per essere legittimi, evitando errori comuni.

Utilizza WebViewAssetLoader

Utilizza WebViewAssetLoader anziché i metodi menzionati. Questo metodo utilizza lo schema http(s)//: anziché uno schema file:// per accedere agli asset del file system locale e non è vulnerabile all'attacco descritto.

Kotlin

val assetLoader: WebViewAssetLoader = Builder()
  .addPathHandler("/assets/", AssetsPathHandler(this))
  .build()

webView.setWebViewClient(object : WebViewClientCompat() {
  @RequiresApi(21)
  override fun shouldInterceptRequest(view: WebView?, request: WebResourceRequest): WebResourceResponse {
    return assetLoader.shouldInterceptRequest(request.url)
  }

  @Suppress("deprecation") // for API < 21
  override fun shouldInterceptRequest(view: WebView?, url: String?): WebResourceResponse {
    return assetLoader.shouldInterceptRequest(Uri.parse(url))
  }
})

val webViewSettings: WebSettings = webView.getSettings()
// Setting this off for security. Off by default for SDK versions >= 16.
webViewSettings.allowFileAccessFromFileURLs = false
// Off by default, deprecated for SDK versions >= 30.
webViewSettings.allowUniversalAccessFromFileURLs = false
// Keeping these off is less critical but still a good idea, especially if your app is not
// using file:// or content:// URLs.
webViewSettings.allowFileAccess = false
webViewSettings.allowContentAccess = false

// Assets are hosted under http(s)://appassets.androidplatform.net/assets/... .
// If the application's assets are in the "main/assets" folder this will read the file
// from "main/assets/www/index.html" and load it as if it were hosted on:
// https://appassets.androidplatform.net/assets/www/index.html
webView.loadUrl("https://appassets.androidplatform.net/assets/www/index.html")

Java

final WebViewAssetLoader assetLoader = new WebViewAssetLoader.Builder()
         .addPathHandler("/assets/", new AssetsPathHandler(this))
         .build();

webView.setWebViewClient(new WebViewClientCompat() {
    @Override
    @RequiresApi(21)
    public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
        return assetLoader.shouldInterceptRequest(request.getUrl());
    }

    @Override
    @SuppressWarnings("deprecation") // for API < 21
    public WebResourceResponse shouldInterceptRequest(WebView view, String url) {
        return assetLoader.shouldInterceptRequest(Uri.parse(url));
    }
});

WebSettings webViewSettings = webView.getSettings();
// Setting this off for security. Off by default for SDK versions >= 16.
webViewSettings.setAllowFileAccessFromFileURLs(false);
// Off by default, deprecated for SDK versions >= 30.
webViewSettings.setAllowUniversalAccessFromFileURLs(false);
// Keeping these off is less critical but still a good idea, especially if your app is not
// using file:// or content:// URLs.
webViewSettings.setAllowFileAccess(false);
webViewSettings.setAllowContentAccess(false);

// Assets are hosted under http(s)://appassets.androidplatform.net/assets/... .
// If the application's assets are in the "main/assets" folder this will read the file
// from "main/assets/www/index.html" and load it as if it were hosted on:
// https://appassets.androidplatform.net/assets/www/index.html
webview.loadUrl("https://appassets.androidplatform.net/assets/www/index.html");

Disattiva i metodi WebSettings pericolosi

Il valore del metodo setAllowFileAccess() è impostato su TRUE per impostazione predefinita nel livello API 29 e precedenti e su FALSE nel livello API 30 e successivi. I metodi setAllowFileAccessFromFileURLs() e setAllowUniversalAccessFromFileURLs() sono impostati su FALSE per impostazione predefinita nel livello API 16 e successivi. (Questi valori predefiniti sono stati modificati nel livello API 16 per applicare una sicurezza più rigorosa limitando l'accesso alla stessa origine per i file locali, proteggendo le app da potenziali cross-site scripting (XSS) e accesso non autorizzato ai file.)

Se è necessario configurare altre WebSettings, è consigliabile disattivare esplicitamente questi metodi, soprattutto per le app che hanno come target livelli API inferiori o uguali a 29.

Rischio: XSS basato su file

Se imposti il metodo setJavacriptEnabled su TRUE, JavaScript può essere eseguito all'interno di un componente WebView e, in combinazione con l'accesso ai file attivato come descritto in precedenza, è possibile eseguire XSS basato su file tramite l'esecuzione di codice all'interno di file arbitrari o siti web dannosi aperti all'interno del componente WebView.

Mitigazioni

Impedisci ai componenti WebView di caricare file locali

Come per il rischio precedente, è possibile evitare l'XSS basato su file se setAllowFileAccess(), setAllowFileAccessFromFileURLs() e setAllowUniversalAccessFromFileURLs() sono impostati su FALSE.

Impedisci ai componenti WebView di eseguire JavaScript

Imposta il metodo setJavascriptEnabled su FALSE in modo che JavaScript non possa essere eseguito all'interno dei componenti WebView.

Assicurati che i componenti WebView non carichino contenuti non attendibili

A volte è necessario attivare queste impostazioni all'interno dei componenti WebView. In questo caso, è importante assicurarsi che vengano caricati solo contenuti attendibili. Un buon modo per garantire l'attendibilità dei contenuti è limitare l'esecuzione di JavaScript solo a quello che controlli e non consentire JavaScript arbitrario. In caso contrario, impedire il caricamento del traffico in chiaro garantisce che i componenti WebView con impostazioni pericolose non siano in grado di caricare gli URL HTTP. Questa operazione può essere eseguita tramite il manifest, impostando android:usesCleartextTraffic su False, o impostando una Network Security Config che non consenta il traffico HTTP.

Risorse