Appliquer une stratégie de sécurité du contenu pour ASP.NET Core Blazor

Cet article explique comment utiliser une stratégie de sécurité de contenu (CSP) avec des applications de base Blazor ASP.NET pour vous protéger contre certains types d’attaques malveillantes, telles que les attaques par script intersites (XSS) et les attaques par détournement de clics . XSS est une vulnérabilité de sécurité où un cyber-attaque place un ou plusieurs scripts côté client malveillants dans le contenu rendu d’une application. Dans une attaque par clickjacking, un utilisateur est trompé par des interactions avec un site web piège qui intègre votre application.

Un fournisseur de solutions Cloud vous permet de vous protéger contre ces types d’attaques en informant le navigateur d’une valeur valide :

• Sources du contenu chargé, y compris les scripts, les feuilles de style, les images et les plug-ins.
• Actions effectuées par une page, spécifiant les cibles d’URL autorisées des formulaires.
• Lorsque votre application peut être incorporée dans un autre site web via <frame>, , <iframe>ou <object><embed> des balises.

Nous vous recommandons de lire les ressources MDN suivantes lors de l’implémentation d’un fournisseur de solutions Cloud :

• Stratégie de sécurité du contenu (CSP)
• Guide de référence CSP
• Implémentation de la stratégie de sécurité du contenu (CSP)

Pour appliquer une stratégie de sécurité du contenu à une application, le développeur spécifie plusieurs directives de sécurité du contenu CSP dans un ou plusieurs en-têtes Content-Security-Policy ou balises <meta>. Pour obtenir des conseils sur l’application d’une politique de sécurité de contenu (CSP) à une application en code C# au démarrage, consultez le démarrage d’ASP.NET CoreBlazor et la section la directive frame-ancestors plus loin dans cet article.

Les stratégies sont évaluées par le navigateur pendant le chargement d’une page. Le navigateur inspecte les sources de la page et détermine si elles répondent aux exigences des directives de sécurité du contenu. Lorsque les directives de stratégie ne sont pas respectées pour une ressource, le navigateur ne charge pas cette ressource. Par exemple, imaginez une stratégie qui n’autorise pas les scripts tiers. Lorsqu’une page contient une balise <script> avec une origine tierce dans l’attribut src, le navigateur empêche le chargement du script.

La stratégie de sécurité du contenu est prise en charge dans la plupart des navigateurs mobiles et de bureau modernes, notamment Chrome, Edge, Firefox, Opera et Safari. La stratégie de sécurité du contenu est recommandée pour les applications Blazor.

Directives de stratégie

Les directives et sources suivantes sont couramment utilisées pour Blazor les applications. Ajoutez des directives et des sources supplémentaires, si nécessaire. Les directives suivantes sont utilisées dans la section Appliquer la stratégie de cet article, où des exemples de stratégies de sécurité pour Blazor les applications sont fournis :

Les directives précédentes sont prises en charge par tous les navigateurs, à l’exception de Microsoft Internet Explorer.

Pour obtenir des hachages SHA pour des scripts intralignes supplémentaires :

• Appliquez la stratégie de sécurité du contenu indiquée dans la section Appliquer la stratégie.
• Accédez à la console des outils de développement du navigateur lors de l’exécution locale de l’application. Le navigateur calcule et affiche des hachages des scripts bloqués lorsqu’un en-tête de fournisseur de solutions Cloud ou une balise meta est présent(e).
• Copiez les hachages fournis par le navigateur dans les sources script-src. Utilisez des guillemets simples autour de chaque hachage.

Pour obtenir une matrice de prise en charge du navigateur de niveau 2 de stratégie de sécurité du contenu, consultez Puis-je utiliser : stratégie de sécurité du contenu niveau 2.

Application de la stratégie

Vous pouvez appliquer un CSP via :

• En-tête de réponse émis par l’hôte (par exemple, IIS) ou émis par l’application (voir en-têtes de contrôle dans le code C# au démarrage).
• Une balise <meta>. Cet article illustre uniquement l'approche de la balise <meta>.

Pour utiliser une <meta> balise pour appliquer la stratégie :

• Définissez la valeur de l’attribut http-equiv sur Content-Security-Policy.
• Placez les directives dans la valeur de l’attribut content . Des directives distinctes avec un point-virgule (;). Un point-virgule de fin pour la dernière directive de la chaîne de stratégie n’est pas obligatoire conformément à la spécification de la stratégie de sécurité du contenu 3.
• Placez le tag <meta> dans le contenu <head> à l'intérieur de la balise <head> d'ouverture. La politique est évaluée et appliquée lorsque le balisage CSP est analysé, pour que la politique apparaisse en tête du <head> balisage afin de garantir qu'elle soit appliquée à toutes les balises <script> et <link>.

Les sections suivantes présentent des exemples de stratégie. Ces exemples sont versionnés avec cet article pour chaque édition de Blazor. Pour utiliser une version appropriée pour votre édition, sélectionnez la version du document à l’aide du sélecteur de liste déroulante Version sur cette page web.

Directive frame-ancestors

La directive frame-ancestors spécifie les parents valides qui peuvent incorporer une page avec des balises <frame>, <iframe>, <object>, ou <embed>. Une frame-ancestors directive ne peut pas être appliquée via une CSP basée sur des <meta> balises. La directive doit être appliquée par un en-tête de réponse. Un en-tête de réponse CSP peut être ajouté par un hôte de serveur, ou le code C# de l’application peut ajouter ou mettre à jour un fournisseur de solutions Cloud avec une frame-ancestors directive.

Blazor Web Apps (.NET 8 ou version ultérieure) incluent automatiquement un en-tête de réponse qui définit la valeur à 'self'.

Content-Security-Policy: frame-ancestors 'self'

Pour remplacer la valeur par défaut par la valeur la plus restrictive 'none' et empêcher tous les parents d’incorporer l’application, définissez l’option ContentSecurityFrameAncestorsPolicy dans l’appel AddInteractiveServerRenderMode dans le Program fichier. Le code suivant prend effet uniquement lorsque la compression WebSocket est activée (ConfigureWebSocketAcceptContext est définie, qui est la valeur par défaut pour les Blazor applications).

.AddInteractiveServerRenderMode(o => o.ContentSecurityFrameAncestorsPolicy = "'none'")

Dans Blazor Server les applications, une directive par défaut frame-ancestors n’est pas ajoutée à la collection d’en-têtes de réponse. Vous pouvez ajouter manuellement un en-tête CSP avec middleware dans le pipeline de traitement des demandes :

app.Use(async (context, next) =>
{
    context.Response.Headers.Add("Content-Security-Policy", "frame-ancestors 'none'");
    await next();
});

Pour plus d’informations, consultez CSP : frame-ancestors (documentation MDN).

Applications Blazor côté serveur

L’exemple suivant est un point de départ pour le développement ultérieur. En haut du <head> contenu, appliquez les directives décrites dans la section Directives de politique, ainsi que toutes les autres directives requises par votre application.

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' 'wasm-unsafe-eval' 'unsafe-hashes' 
        'sha256-qnHnQs7NjQNHHNYv/I9cW+I62HzDJjbnyS/OFzqlix0=';
    style-src https:;
    connect-src 'self' http: ws: wss:;
    upgrade-insecure-requests;" />

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self';
    style-src 'self';
    connect-src 'self' http: ws: wss:;
    upgrade-insecure-requests">

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' https://stackpath.bootstrapcdn.com/;
    style-src 'self' 'unsafe-inline' https://stackpath.bootstrapcdn.com/;
    connect-src 'self' http: ws: wss:;
    upgrade-insecure-requests">

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' https://stackpath.bootstrapcdn.com/ 
        'sha256-34WLX60Tw3aG6hylk0plKbZZFXCuepeQ6Hu7OqRf8PI=';
    style-src 'unsafe-inline' https://stackpath.bootstrapcdn.com/;
    connect-src 'self' http: ws: wss:;
    upgrade-insecure-requests">

Ajoutez les hachages supplémentaires script-src et style-src selon les besoins de l’application. Pendant le développement, utilisez un outil en ligne ou des outils de développement de navigateur pour calculer les hachages pour vous. Par exemple, l’erreur suivante dans la console des outils de navigateur signale le hachage d’un script obligatoire non couvert par la stratégie :

Refus d’exécuter un script intraligne parce qu’il enfreint la directive de stratégie de sécurité du contenu suivante : « ... ». Le mot clé « unsafe-inline », un hachage (« sha256-v8v3RKRPmN4odZ1CWM5gw80QKPCCWMcpNeOmimNL2AA= ») ou un nonce (« nonce-... ») est obligatoire pour activer l’exécution intraligne.

Le script particulier associé à l’erreur s’affiche dans la console après l’erreur.

Pour obtenir des conseils sur l’application d’un fournisseur de solutions Cloud à une application en code C# au démarrage, consultez Démarrage de ASP.NET Core Blazor.

Applications Blazor côté client

L’exemple suivant est un point de départ pour le développement ultérieur. Dans le <head> contenu, appliquez les directives décrites dans la section Directives de stratégie :

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' 'wasm-unsafe-eval';
    style-src 'self';
    connect-src 'none';
    upgrade-insecure-requests">

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' 'unsafe-eval';
    style-src 'self';
    connect-src 'none';
    upgrade-insecure-requests">

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' 'unsafe-eval' 
        'sha256-v8v3RKRPmN4odZ1CWM5gw80QKPCCWMcpNeOmimNL2AA=';
    style-src 'self';
    connect-src 'none';
    upgrade-insecure-requests">

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' 'unsafe-eval' https://stackpath.bootstrapcdn.com/ 
        'sha256-v8v3RKRPmN4odZ1CWM5gw80QKPCCWMcpNeOmimNL2AA=';
    style-src 'self' 'unsafe-inline' https://stackpath.bootstrapcdn.com/;
    upgrade-insecure-requests">

<meta http-equiv="Content-Security-Policy" content="
    base-uri 'self';
    default-src 'self';
    img-src data: https:;
    object-src 'none';
    script-src 'self' 'unsafe-eval' https://stackpath.bootstrapcdn.com/ 
        'sha256-v8ZC9OgMhcnEQ/Me77/R9TlJfzOBqrMTW8e1KuqLaqc=' 
        'sha256-If//FtbPc03afjLezvWHnC3Nbu4fDM04IIzkPaf3pH0=' 
        'sha256-v8v3RKRPmN4odZ1CWM5gw80QKPCCWMcpNeOmimNL2AA=';
    style-src 'self' 'unsafe-inline' https://stackpath.bootstrapcdn.com/;
    upgrade-insecure-requests">

Ajoutez les hachages supplémentaires script-src et style-src selon les besoins de l’application. Pendant le développement, utilisez un outil en ligne ou des outils de développement de navigateur pour calculer les hachages pour vous. Par exemple, l’erreur suivante dans la console des outils de navigateur signale le hachage d’un script obligatoire non couvert par la stratégie :

Refus d’exécuter un script intraligne parce qu’il enfreint la directive de stratégie de sécurité du contenu suivante : « ... ». Le mot clé « unsafe-inline », un hachage (« sha256-v8v3RKRPmN4odZ1CWM5gw80QKPCCWMcpNeOmimNL2AA= ») ou un nonce (« nonce-... ») est obligatoire pour activer l’exécution intraligne.

Le script particulier associé à l’erreur s’affiche dans la console après l’erreur.

Résolution des violations CSP avec l’Intégrité des Sous-Ressources (SRI) ou un nonce de chiffrement

Deux approches pour résoudre les violations csp, décrites dans les deux sections suivantes, sont les suivantes :

• Intégrité des sous-ressources (SRI)Recommandé
• Nonce de chiffrement

Adopter l’intégrité des sous-ressources (SRI)

L’intégrité des sous-ressources (SRI) permet aux navigateurs de confirmer que les ressources extraites ne sont pas falsifiées en transit. Un hachage de chiffrement fourni sur la ressource doit correspondre au hachage calculé par le navigateur pour la ressource extraite et au hachage répertorié dans le csp. La compatibilité du navigateur peut être évaluée à l'adresse "Can I use? Subresource Integrity".

Dans l’exemple suivant pour une Blazor Server application, une intégrité est calculée à l’aide d’un outil tiers et spécifiée pour le script (Blazor) et cspblazor.server.js. Le Blazor script ne change pas dynamiquement dans ce scénario et a un hachage SHA stable. Vous pouvez donc encoder en dur la valeur de l’attribut integrity .

<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="Content-Security-Policy" content="
        base-uri 'self';
        default-src 'self';
        img-src data: https:;
        object-src 'none';
        script-src 'sha256-FyuamsHhg0nWZUnu/f5qrt2DlL1XKt5AX+cgRhtxtfg=';
        style-src https:;
        connect-src 'self' http: ws: wss:;
        upgrade-insecure-requests;" />
    ...
</head>
<body>
    ...
    <script src="_framework/blazor.server.js" 
        integrity="sha256-FyuamsHhg0nWZUnu/f5qrt2DlL1XKt5AX+cgRhtxtfg="></script>
</body>
</html>

Dans l’exemple suivant pour un Blazor Web App (.NET 8 ou version ultérieure), une intégrité est calculée pour le ImportMap composant (.NET 9 ou version ultérieure). La ImportMap valeur d’intégrité est calculée pour chaque demande d’application, car le ImportMap composant génère du contenu unique chaque fois que la page est produite pour les ressources à empreinte numérique.

Le mappage d’importation rendu à partir du ImportMap composant est généré par l’application à son origine. L’attributcrossorigin n’est donc pas inclus dans la ImportMap balise. Pour plus d’informations, consultez le Guide csp MDN : Hachages et intégrité des sous-ressources (documentation MDN).

@using System.Security.Cryptography
<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="Content-Security-Policy" content="
        base-uri 'self';
        default-src 'self';
        img-src data: https:;
        object-src 'none';
        script-src 'self' 'wasm-unsafe-eval' 'unsafe-hashes' '@integrity'
            'sha256-qnHnQs7NjQNHHNYv/I9cW+I62HzDJjbnyS/OFzqlix0=';
        style-src https:;
        connect-src 'self' http: ws: wss:;
        upgrade-insecure-requests;" />
    ...
    <ImportMap integrity="@integrity" />
    ...
</head>
...
</html>

@code {
    private string? integrity;

    [CascadingParameter]
    private HttpContext? HttpContext { get; set; }

    protected override void OnInitialized()
    {
        var metadata = HttpContext?.GetEndpoint()?.Metadata
            .GetOrderedMetadata<ImportMapDefinition>();
        var utf8 = new System.Text.UTF8Encoding();
        var metadataBytes = utf8.GetBytes(
            metadata?.FirstOrDefault<ImportMapDefinition>()?.ToString()
                .ReplaceLineEndings("\n") ?? string.Empty);
        integrity = 
            $"sha256-{Convert.ToBase64String(SHA256.HashData(metadataBytes))}";
    }
}

Avant .NET 6, utilisez .Replace("\r\n", "\n") plutôt que d’appeler ReplaceLineEndings dans le code précédent.

Adopter un nonce cryptographique

Un nonce de chiffrement (nombre utilisé une seule fois) permet aux navigateurs de confirmer que les ressources récupérées n'ont pas été altérées en transit. Un nonce de chiffrement à usage unique fourni dans le CSP doit correspondre à celui spécifié sur la ressource. La compatibilité du navigateur peut être évaluée sur Can I use? Nonce.

Dans l’exemple suivant pour un Blazor Web App (.NET 8 ou version ultérieure), un nonce est créé pour le ImportMap composant (.NET 9 ou version ultérieure) avec une valeur unique chaque fois que l’application est chargée.

Pour plus d’informations, consultez le Guide du fournisseur de solutions Cloud MDN : Nonces et CSP : script-src : Script inline non sécurisé (documentation MDN).

@using System.Security.Cryptography
<!DOCTYPE html>
<html lang="en">
<head>
    <meta http-equiv="Content-Security-Policy" content="
        base-uri 'self';
        default-src 'self';
        img-src data: https:;
        object-src 'none';
        script-src 'self' 'wasm-unsafe-eval' 'unsafe-hashes' 'nonce-@nonce' 
            'sha256-qnHnQs7NjQNHHNYv/I9cW+I62HzDJjbnyS/OFzqlix0=';
        style-src https:;
        connect-src 'self' http: ws: wss:;
        upgrade-insecure-requests;" />
    ...
    <ImportMap nonce="@nonce" />
    ...
</head>
...
</html>

@code {
    private string? nonce;

    protected override void OnInitialized()
    {
        using (var rng = RandomNumberGenerator.Create())
        {
            var nonceBytes = new byte[32];
            rng.GetBytes(nonceBytes);
            nonce = Convert.ToBase64String(nonceBytes);
        }
    }
}

@inject IHostEnvironment Env

@if (!Env.IsDevelopment())
{
    <meta ...>
}

@inject IHostEnvironment Env

@if (!Env.IsDevelopment())
{
    <HeadContent>
        <meta ...>
    </HeadContent>
}

@using Microsoft.AspNetCore.Components.WebAssembly.Hosting
@inject IWebAssemblyHostEnvironment Env

@if (!Env.IsDevelopment())
{
    <HeadContent>
        <meta ...>
    </HeadContent>
}

Limitations des balises meta

Une stratégie de balise <meta> ne prend pas en charge les directives suivantes :

• frame-ancestors
• report-to
• report-uri
• sandbox

Pour prendre en charge les directives précédentes, utilisez un en-tête nommé Content-Security-Policy. La chaîne de directive est la valeur de l’en-tête.

Tester une stratégie et recevoir des rapports de violation

Le test permet de vérifier que les scripts tiers ne sont pas bloqués par inadvertance lors de la création d’une stratégie initiale.

Pour tester une stratégie sur une certaine période sans appliquer les directives de stratégie, définissez l’attribut <meta> de la balise http-equiv ou le nom d’en-tête d’une stratégie basée sur l’en-tête sur Content-Security-Policy-Report-Only. Les rapports d’échec sont envoyés sous forme de documents JSON vers une URL spécifiée. Pour plus d’informations, consultez Documentation web sur notification de réception du message : rapports de stratégie de sécurité du contenu uniquement.

Pour la création de rapports sur les violations pendant qu’une stratégie est active, consultez les articles suivants :

• report-to
• report-uri

Bien que l’utilisation de report-uri ne soit plus recommandée, les deux directives doivent être utilisées jusqu’à ce que report-to soit pris en charge par tous les principaux navigateurs. N’utilisez pas report-uri exclusivement, car la prise en charge de report-uri peut être supprimée des navigateurs à tout moment. Supprimez la prise en charge de report-uri dans vos stratégies lorsque report-to est entièrement pris en charge. Pour suivre l’adoption de report-to, consultez Puis-je utiliser : report-to.

Testez et mettez à jour la stratégie d’une application à chaque édition.

Résoudre des problèmes

• Les erreurs s’affichent dans la console des outils de développement du navigateur. Les navigateurs fournissent des informations sur :
  • Les éléments qui ne sont pas conformes à la stratégie.
  • Comment modifier la stratégie pour autoriser un élément bloqué.
• Une stratégie n’est totalement efficace que lorsque le navigateur du client prend en charge toutes les directives comprises. Pour obtenir une matrice de prise en charge du navigateur actuel, consultez Puis-je utiliser : stratégie de sécurité du contenu.

Ressources supplémentaires

• Appliquer une stratégie de sécurité du contenu dans le code C# au démarrage
• MDN web docs : stratégie de sécurité du contenu (CSP)
• MDN web docs : en-tête de réponse Content-Security-Policy
• Niveau de stratégie de sécurité du contenu 3
• Évaluateur de stratégie de sécurité du contenu de Google