WebViews – Inclusion de fichiers non sécurisée

Catégorie OWASP : MASVS-STORAGE : stockage

Présentation

Ce document traite de plusieurs problèmes liés à l'inclusion de fichiers qui partagent des mesures d'atténuation similaires. Ces problèmes portent sur les failles liées à l'accès aux fichiers dans les WebViews. Ils vont de WebSettings dangereux permettant l'accès aux fichiers ou l'activation de JavaScript à une méthode WebKit qui crée une requête de sélection de fichiers. Ce document devrait vous aider si vous recherchez des conseils pour résoudre les problèmes dans WebView liés à l'utilisation du schéma file://, à l'accès illimité aux fichiers locaux et au script intersites.

Plus précisément, ce document traite des sujets suivants:

  • WebSettings est une classe contenant des méthodes qui gèrent les états des paramètres pour les WebViews. Ces méthodes peuvent ouvrir les WebViews à différentes attaques, qui seront décrites plus tard. Dans ce document, nous allons examiner les méthodes concernant l'accès aux fichiers et le paramètre permettant d'exécuter JavaScript:
  • Les méthodes setAllowFileAccess, setAllowFileAccessFromFileURLs et setAllowUniversalAccessFromFileURLs peuvent être utilisées pour accorder l'accès à des fichiers locaux à l'aide d'une URL de schéma de fichier (file://). Toutefois, elles peuvent être exploitées par des scripts malveillants pour accéder à des fichiers locaux arbitraires auxquels l'application a accès, tels que son propre dossier /data/. Pour cette raison, ces méthodes ont été signalées comme non sécurisées et ont été abandonnées dans l'API 30 au profit d'alternatives plus sûres, telles que WebViewAssetLoader.
  • La méthode setJavascriptEnabled permet d'activer l'exécution de JavaScript dans les WebViews. Les applications sont ainsi vulnérables aux XSS basés sur les fichiers. En particulier lorsqu'elles sont configurées pour autoriser le chargement de fichiers locaux ou de contenus Web non approuvés pouvant contenir du code exécutable, pour autoriser l'accès à des fichiers pouvant être créés ou modifiés par des sources externes, ou pour autoriser les WebViews à exécuter JavaScript, les utilisateurs et leurs données sont exposés à des risques.
  • WebChromeClient.onShowFileChooser est une méthode appartenant au package android.webkit, qui fournit des outils de navigation Web. Cette méthode peut être utilisée pour permettre aux utilisateurs de sélectionner des fichiers dans une WebView. Toutefois, cette fonctionnalité peut être utilisée de manière abusive, car les WebViews n'appliquent pas de restrictions sur le fichier sélectionné.

Impact

L'impact de l'inclusion de fichiers peut dépendre des WebSettings configurés dans WebView. Des autorisations de fichier trop larges peuvent permettre à des pirates informatiques d'accéder aux fichiers locaux et de dérober des données sensibles, des informations permettant d'identifier personnellement l'utilisateur (PII) ou des données d'application privées. L'activation de l'exécution JavaScript peut permettre aux pirates informatiques d'exécuter JavaScript dans une WebView ou sur l'appareil d'un utilisateur. Les fichiers sélectionnés à l'aide de la méthode onShowFileChooser peuvent compromettre la sécurité des utilisateurs, car la méthode ou WebView ne peut pas s'assurer que la source de fichier est fiable.

Risque: accès risqué aux fichiers via file://

L'activation de setAllowFileAccess, setAllowFileAccessFromFileURLs et setAllowUniversalAccessFromFileURLs peut autoriser les intents et les requêtes WebView malveillants avec un contexte file:// à accéder à des fichiers locaux arbitraires, y compris aux cookies WebView et aux données privées de l'application. De plus, l'utilisation de la méthode onShowFileChooser peut permettre aux utilisateurs de sélectionner et de télécharger des fichiers à partir de sources non approuvées.

Selon la configuration de l'application, ces méthodes peuvent toutes entraîner l'exfiltration d'informations permettant d'identifier l'utilisateur, d'identifiants de connexion ou d'autres données sensibles.

Stratégies d'atténuation

Valider les URL de fichiers

Si votre application nécessite l'accès à des fichiers via des URL file://, il est important de n'ajouter à la liste d'autorisation que des URL spécifiques connues pour être légitimes, afin d'éviter les erreurs courantes.

Utiliser WebViewAssetLoader

Utilisez WebViewAssetLoader au lieu des méthodes mentionnées. Cette méthode utilise le schéma http(s)//: au lieu d'un schéma file:// pour accéder aux éléments du système de fichiers local et n'est pas vulnérable à l'attaque décrite.

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

Désactiver les méthodes WebSettings dangereuses

Les valeurs des méthodes setAllowFileAccess(), setAllowFileAccessFromFileURLs() et setAllowUniversalAccessFromFileURLs() sont définies par défaut sur TRUE au niveau d'API 29 et versions antérieures, et sur FALSE au niveau d'API 30 et versions ultérieures.

Si vous devez configurer d'autres WebSettings, il est préférable de désactiver explicitement ces méthodes, en particulier pour les applications ciblant des niveaux d'API inférieurs ou égaux à 29.

Risque: XSS basé sur les fichiers

Définir la méthode setJavacriptEnabled sur TRUE permet d'exécuter JavaScript dans une WebView. En combinaison avec l'accès aux fichiers activé comme indiqué précédemment, le XSS basé sur les fichiers est possible via l'exécution de code dans des fichiers arbitraires ou des sites Web malveillants ouverts dans la WebView.

Stratégies d'atténuation

Empêcher les WebView de charger des fichiers locaux

Comme pour le risque précédent, les attaques XSS basées sur des fichiers peuvent être évitées si setAllowFileAccess(), setAllowFileAccessFromFileURLs() et setAllowUniversalAccessFromFileURLs() sont définis sur FALSE.

Empêcher les WebViews d'exécuter JavaScript

Définissez la méthode setJavascriptEnabled sur FALSE afin que JavaScript ne puisse pas être exécuté dans les WebViews.

Assurez-vous que les WebView ne chargent pas de contenu non approuvé

Il est parfois nécessaire d'activer ces paramètres dans les WebViews. Dans ce cas, il est important de s'assurer que seul le contenu fiable est chargé. Limiter l'exécution de JavaScript à ce que vous contrôlez et interdire le code JavaScript arbitraire est un bon moyen de s'assurer que le contenu est fiable. Sinon, en empêchant le chargement du trafic en texte clair, vous vous assurez que les WebView avec des paramètres dangereux ne peuvent pas charger d'URL HTTP. Pour ce faire, vous pouvez utiliser le fichier manifeste, en définissant android:usesCleartextTraffic sur False, ou en définissant un Network Security Config qui interdit le trafic HTTP.

Ressources