WebViews – Inclusion de fichiers non sécurisée

Catégorie OWASP : MASVS-STORAGE : stockage

Présentation

Ce document aborde plusieurs problèmes liés à l'inclusion de fichiers qui partagent des mesures d'atténuation similaires. Ces problèmes concernent les failles découlant de l'accès aux fichiers dans les classes WebView. Ils vont de WebSettings dangereux autorisant l'accès aux fichiers ou activant JavaScript à une méthode WebKit qui crée une demande de sélection de fichier. Ce document devrait vous être utile si vous recherchez des conseils pour résoudre les problèmes liés à WebView qui découlent de l'utilisation du schéma file://, de l'accès illimité aux fichiers locaux et du script intersites.

Plus concrètement, ce document aborde les thèmes suivants :

  • WebSettings est une classe contenant des méthodes qui gèrent les états des paramètres pour les WebView. Ces méthodes peuvent ouvrir des WebViews à différentes attaques qui seront décrites plus loin. Dans ce document, nous allons examiner les méthodes qui permettent d'accéder aux fichiers et le paramètre qui permet d'exécuter JavaScript :
  • Les méthodes setAllowFileAccess, setAllowFileAccessFromFileURLs et setAllowUniversalAccessFromFileURLs peuvent être utilisées pour accorder l'accès aux 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 leur propre dossier /data/. C'est pourquoi 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 peut être utilisée pour activer l'exécution de JavaScript dans les WebViews. Les applications sont ainsi vulnérables aux failles XSS basées sur des fichiers. Les utilisateurs et leurs données sont exposés à des risques, en particulier lorsque les classes WebView sont configurées pour autoriser le chargement de fichiers locaux ou de contenu Web non fiable 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 l'exécution de JavaScript par les classes WebView.
  • 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 aucune restriction 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 aux pirates informatiques d'accéder aux fichiers locaux et de voler 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 de 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 peuvent pas s'assurer que la source du fichier est fiable.

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

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

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

Stratégies d'atténuation

Valider les URL des fichiers

Si votre application nécessite d'accéder à des fichiers via des URL file://, il est important de n'autoriser que les URL spécifiques connues pour être légitimes, en évitant 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 ressources 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 inférieur, et sur FALSE au niveau d'API 30 et supérieur.

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 des fichiers

Si la méthode setJavacriptEnabled est définie sur TRUE, JavaScript peut être exécuté dans une WebView. Combiné à l'accès aux fichiers activé comme indiqué précédemment, cela permet d'effectuer des attaques XSS basées sur des fichiers en exécutant du code dans des fichiers arbitraires ou des sites Web malveillants ouverts dans la WebView.

Stratégies d'atténuation

Empêcher les classes WebView de charger des fichiers locaux

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

Empêcher les WebView d'exécuter JavaScript

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

S'assurer que les classes 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 de confiance est chargé. Limiter l'exécution de JavaScript à ce que vous contrôlez et interdire le JavaScript arbitraire est un bon moyen de s'assurer que le contenu est fiable. Sinon, empêcher le chargement du trafic en texte clair garantit que les classes WebView avec des paramètres dangereux ne peuvent au moins 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