WebViews – unsichere Dateieinschlüsse

OWASP-Kategorie: MASVS-STORAGE: Speicher

Übersicht

In diesem Dokument werden mehrere Probleme im Zusammenhang mit der Dateieinbeziehung behandelt, die ähnliche Abhilfemaßnahmen erfordern. Diese Probleme beziehen sich auf Sicherheitslücken, die durch den Zugriff auf Dateien in WebViews entstehen. Sie reichen von gefährlichen WebSettings, die den Dateizugriff oder JavaScript zulassen, bis hin zu einer WebKit-Methode, die eine Dateiauswahlanfrage erstellt. Dieses Dokument sollte Ihnen helfen, Probleme in WebView zu beheben, die durch die Verwendung des file://-Schemas, den uneingeschränkten Zugriff auf lokale Dateien und Cross-Site-Scripting entstehen.

Im Detail werden in diesem Dokument die folgenden Themen behandelt:

  • WebSettings ist eine Klasse mit Methoden, die die Einstellungsstatus für WebViews verwalten. Diese Methoden können WebViews für verschiedene Angriffe öffnen, die später erläutert werden. In diesem Dokument werden die Methoden beschrieben, die sich auf den Zugriff auf Dateien beziehen, und die Einstellung, die die Ausführung von JavaScript ermöglicht:
  • Mit den Methoden setAllowFileAccess, setAllowFileAccessFromFileURLs und setAllowUniversalAccessFromFileURLs kann über eine Dateischema-URL (file://) Zugriff auf lokale Dateien gewährt werden. Sie können jedoch von schädlichen Scripts ausgenutzt werden, um auf beliebige lokale Dateien zuzugreifen, auf die die Anwendung Zugriff hat, z. B. auf den eigenen /data/-Ordner. Aus diesem Grund wurden diese Methoden als unsicher eingestuft und in API 30 zugunsten sichererer Alternativen wie WebViewAssetLoader eingestellt.
  • Mit der Methode setJavascriptEnabled können Sie die Ausführung von JavaScript in WebViews aktivieren. Dadurch sind Anwendungen anfällig für File-based Cross-Site Scripting. Insbesondere wenn das Laden lokaler Dateien oder nicht vertrauenswürdiger Webinhalte, die ausführbaren Code enthalten können, oder der Zugriff auf Dateien, die von externen Quellen erstellt oder geändert werden können, oder das Ausführen von JavaScript durch WebViews zugelassen wird, sind Nutzer und ihre Daten gefährdet.
  • WebChromeClient.onShowFileChooser ist eine Methode des Pakets android.webkit, das Tools zum Surfen im Web bereitstellt. Mit dieser Methode können Nutzer Dateien in einem WebView auswählen. Diese Funktion kann jedoch missbraucht werden, da WebViews keine Einschränkungen bei der Auswahl der Datei erzwingen.

Positiv beeinflussen

Die Auswirkungen des Dateieinschlusses können davon abhängen, welche WebSettings in WebView konfiguriert sind. Übermäßig weit gefasste Dateiberechtigungen können es Angreifern ermöglichen, auf lokale Dateien zuzugreifen und vertrauliche Daten, personenidentifizierbare Informationen oder private App-Daten zu stehlen. Wenn die Ausführung von JavaScript aktiviert ist, können Angreifer JavaScript in einer WebView oder auf dem Gerät eines Nutzers ausführen. Dateien, die mit der Methode onShowFileChooser ausgewählt werden, können die Sicherheit der Nutzer gefährden, da die Methode oder WebView nicht sicherstellen kann, dass die Dateiquelle vertrauenswürdig ist.

Risiko: Riskanter Zugriff auf Dateien über file://

Wenn Sie setAllowFileAccess, setAllowFileAccessFromFileURLs und setAllowUniversalAccessFromFileURLs aktivieren, können schädliche Intents und WebView-Anfragen mit einem file://-Kontext auf beliebige lokale Dateien zugreifen, einschließlich WebView-Cookies und privater App-Daten. Außerdem können Nutzer mit der onShowFileChooser-Methode Dateien aus nicht vertrauenswürdigen Quellen auswählen und herunterladen.

Diese Methoden können je nach Anwendungskonfiguration zur Ausschleusung von personenidentifizierbaren Informationen, Anmeldedaten oder anderen sensiblen Daten führen.

Abhilfemaßnahmen

Datei-URLs validieren

Wenn Ihre App Zugriff auf Dateien über file://-URLs benötigt, sollten Sie nur bestimmte URLs auf die Zulassungsliste setzen, die nachweislich legitim sind, um häufige Fehler zu vermeiden.

WebViewAssetLoader verwenden

Verwenden Sie stattdessen WebViewAssetLoader. Bei dieser Methode wird das http(s)//:-Schema anstelle eines file://-Schemas zum Zugriff auf lokale Dateisystem-Assets verwendet. Sie ist nicht anfällig für den beschriebenen Angriff.

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");

Gefährliche WebSettings-Methoden deaktivieren

Die Werte der Methoden setAllowFileAccess(), setAllowFileAccessFromFileURLs() und setAllowUniversalAccessFromFileURLs() sind standardmäßig auf TRUE für API-Level 29 und niedriger und auf FALSE für API-Level 30 und höher festgelegt.

Wenn andere WebSettings konfiguriert werden müssen, sollten Sie diese Methoden ausdrücklich deaktivieren, insbesondere für Apps, die auf API-Ebenen von maximal 29 ausgerichtet sind.

Risiko: File-Based XSS

Wenn Sie die setJavacriptEnabled-Methode auf TRUE festlegen, kann JavaScript in einer WebView ausgeführt werden. In Kombination mit dem oben beschriebenen aktivierten Dateizugriff ist dann dateibasiertes XSS möglich, indem Code in beliebigen Dateien oder schädlichen Websites ausgeführt wird, die in der WebView geöffnet werden.

Abhilfemaßnahmen

Verhindern, dass WebViews lokale Dateien laden

Wie beim vorherigen Risiko kann auch File-based XSS vermieden werden, wenn setAllowFileAccess(), setAllowFileAccessFromFileURLs() und setAllowUniversalAccessFromFileURLs() auf FALSE festgelegt sind.

Ausführen von JavaScript in WebViews verhindern

Setzen Sie die Methode setJavascriptEnabled auf FALSE, damit JavaScript nicht in WebViews ausgeführt werden kann.

Sorgen Sie dafür, dass WebViews keine nicht vertrauenswürdigen Inhalte laden

Manchmal ist es erforderlich, diese Einstellungen in WebViews zu aktivieren. In diesem Fall ist es wichtig, dass nur vertrauenswürdige Inhalte geladen werden. Wenn Sie die Ausführung von JavaScript auf die von Ihnen kontrollierten Funktionen beschränken und beliebiges JavaScript nicht zulassen, können Sie die Vertrauenswürdigkeit von Inhalten erhöhen. Andernfalls können Sie verhindern, dass Klartext-Traffic geladen wird, damit WebViews mit gefährlichen Einstellungen zumindest keine HTTP-URLs laden können. Das geht entweder über das Manifest, indem Sie android:usesCleartextTraffic auf False festlegen, oder indem Sie eine Network Security Config festlegen, die HTTP-Traffic blockiert.

Ressourcen