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 stratégies d'atténuation similaires. Ces problèmes sont centrés sur les failles résultant de l'accès aux fichiers dans les classes WebView et vont des WebSettings dangereux autorisant l'accès aux fichiers ou activant JavaScript à une méthode WebKit qui crée une demande de sélection de fichiers. Ce document devrait vous être utile si vous recherchez des conseils sur la correction des problèmes dans WebView résultant de l'utilisation du schéma file://, d'un accès illimité aux fichiers locaux et des scripts intersites.

Plus concrètement, ce document aborde les sujets suivants :

  • WebSettings est une classe contenant des méthodes qui gèrent les états des paramètres pour les classes WebView. Ces méthodes peuvent ouvrir des classes WebView à différentes attaques, qui seront décrites plus loin. Dans ce document, nous examinerons les méthodes qui concernent la manière dont les fichiers sont accessibles 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/. 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 peut être utilisée pour activer l'exécution de JavaScript dans les classes WebView. Les applications sont ainsi vulnérables aux scripts intersites basés sur les fichiers. En particulier lorsqu'elles sont configurées pour autoriser le chargement de fichiers locaux ou de contenu Web non approuvé pouvant contenir du code exécutable, configurées pour autoriser l'accès aux fichiers pouvant être créés ou modifiés par des sources externes, ou autorisant les classes WebView à 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 sur le Web. Cette méthode peut être utilisée pour permettre aux utilisateurs de sélectionner des fichiers dans une classe WebView. Toutefois, cette fonctionnalité peut être utilisée de manière abusive, car les classes WebView 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 fichiers trop larges peuvent permettre aux pirates informatiques d'accéder à des fichiers locaux et de voler des données sensibles, des informations permettant d'identifier personnellement l'utilisateur (PII) ou des données de l'application privées. L'activation de l'exécution de JavaScript peut permettre aux pirates d'exécuter JavaScript dans une classe 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 la classe WebView ne peuvent pas s'assurer que la source du fichier est approuvée.

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

L'activation de setAllowFileAccess, setAllowFileAccessFromFileURLs, et setAllowUniversalAccessFromFileURLs peut permettre aux intents malveillants et aux 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, l'utilisation de la méthode onShowFileChooser peut permettre aux utilisateurs de sélectionner et de télécharger des fichiers provenant de sources non approuvées.

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 de fichier

Si votre application nécessite d'accéder aux fichiers via des URL file://, il est important d' autoriser uniquement 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 assets 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

La valeur de la méthode setAllowFileAccess() est définie par défaut sur TRUE dans le niveau d'API 29 et inférieur, et sur FALSE dans le niveau d'API 30 et supérieur. Les méthodes setAllowFileAccessFromFileURLs() et setAllowUniversalAccessFromFileURLs() sont définies par défaut sur FALSE dans le niveau d'API 16 et supérieur. (Ces valeurs par défaut ont été modifiées dans le niveau d'API 16 pour appliquer une sécurité plus stricte en limitant l'accès de même origine aux fichiers locaux, en protégeant les applications contre les scripts intersites (XSS) potentiels et l'accès non autorisé aux fichiers.)

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 classe 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 classe WebView.

Stratégies d'atténuation

Empêcher les classes WebView de charger des fichiers locaux

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

Empêcher les classes WebView d'exécuter JavaScript

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

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 classes WebView. Dans ce cas, il est important de s'assurer que seul le contenu approuvé est chargé. Limiter l'exécution de JavaScript à celui 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 brut garantit que les classes WebView aux 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 une Network Security Config qui interdit le trafic HTTP.

Ressources