Prévenir les attaques par injection dans ASP.NET [Français]

Auteur：Eve Cole Date de mise à jour：2009-06-30 16:03:51

Source : MSDN
Traduction :

Champ d'application du BLOG Yunzhongcheng :

ASP.NET version 1.1
ASP.NET version 2.0

Résumé :

Ce texte explique principalement comment vérifier les entrées de l'utilisateur pour empêcher les attaques par injection. Il est très nécessaire de vérifier les entrées de l'utilisateur. Presque toutes les attaques au niveau du programme contiennent des méthodes de saisie malveillantes,

notamment les champs, les paramètres de chaîne de requête, les cookies et d'autres utilisateurs. Les éléments d'entrée sont utilisés pour protéger votre programme contre les attaques par injection. Vous devez supposer que toutes les entrées utilisateur sont malveillantes et vous assurer que toutes les entrées utilisateur sont vérifiées côté serveur. L'utilisation de la validation basée sur le client peut réduire le nombre de séjours de la page. améliorez les performances et l'expérience utilisateur, mais ne vous fiez pas uniquement à cela, car la validation côté client peut facilement être trompée par les pirates informatiques.

Afin de valider le contenu d'entrée, vous devez définir des règles de saisie acceptables pour chaque champ de saisie. consiste à créer des contraintes basées sur la longueur, la plage, le format et le type du champ de saisie. Utilisez une liste de contraintes de caractères acceptables au lieu d'une liste de caractères illégale pour limiter la saisie. L'utilisation de contraintes de liste de caractères illégales n'est pas bonne car c'est presque impossible. pour filtrer toutes les entrées nuisibles.

Si vous devez accepter la saisie de caractères HTML, il est préférable d'utiliser une méthode telle que HtmlEncode pour l'encoder en toute sécurité avant de l'afficher.

Contenu :

Présentation

de l'objectif

Flux de mise en œuvre étape par étape

Étape 1. Utilisation d'ASP. NET.

Étape 2. Utiliser l'entrée de contrainte de droits.

Étape 3. Encoder l'entrée non sécurisée.

Étape 4. Utiliser les paramètres de commande

pour

les instructions SQL.

Vérifiez que les erreurs ASP.NET ne sont pas renvoyées au client.

-------------------------------------------------- ------------------------------

But:

Contraindre la longueur, la plage, le format et le type de la chaîne d'entrée.
Utilisez la validation des demandes pour empêcher les attaques par injection lors du développement de programmes ASP.NET.
Utilisez les contrôles de validation ASP.NET pour la validation des entrées.
Encodez la sortie dangereuse.
Empêchez les attaques par injection à l’aide du modèle de jeu de paramètres de commande.
Empêcher que les détails de l'erreur soient renvoyés au client.
Présentation :

vous devez valider toutes les entrées non fiables dans votre application. Vous devez supposer que toutes les entrées utilisateur sont invalides. Les utilisateurs peuvent fournir des champs de formulaire, des chaînes de requête, des cookies clients et des valeurs d'environnement de navigateur dans l'application, telles que les chaînes de proxy utilisateur et. Adresses IP, etc.

Une validation d'entrée faible offre généralement des opportunités d'attaques par injection. Voici les méthodes d'attaque courantes utilisant une validation d'entrée faible ou aucune validation d'entrée.

Injection SQL. Si vous utilisez des valeurs d'entrée utilisateur pour construire dynamiquement des instructions SQL, la base de données peut exécuter des instructions SQL offensantes et nuisibles.
Scripts intersites. Les attaques de scripts intersites exploitent les vulnérabilités de validation des pages Web pour injecter des scripts côté client. Ces codes sont ensuite envoyés à l'ordinateur client de confiance et interprétés et exécutés par le navigateur. Le navigateur n'a aucun moyen de savoir que le code est nuisible.
Accès aux fichiers non autorisé. Si votre code accepte les entrées de l'appelant, un utilisateur malveillant peut voir vos opérations sur les fichiers et accéder aux fichiers protégés ou utiliser votre code pour injecter des données illégales.

Remarque : Les attaques par injection peuvent être effectuées à l'aide de connexions HTTP ou HTTPS Secure Socket Layer (SSL). Les techniques de chiffrement de transport ne peuvent pas être utilisées pour empêcher les attaques.

Les méthodes courantes de validation des entrées sont résumées ci-dessous. Vous devez effectuer une validation partout où une entrée est requise sur le réseau. , tels que les zones de texte et autres champs de saisie de formulaire, les paramètres de chaîne de requête, les cookies, les variables côté serveur et les paramètres de méthode réseau. Notez que la stratégie de filtrage ne doit autoriser que les entrées correctes et rejeter les entrées illégales. mieux que de tout filtrer Il est plus facile de détecter les entrées illégales, mais il est généralement difficile d'inclure toutes les entrées illégales.

Vérifiez le contenu de l'entrée à travers les aspects suivants :

Contraintes. Vérifiez que l'entrée est du type, de la longueur de caractère, du format et de la plage corrects. Des contrôles de validation ASP.NET peuvent être appliqués pour limiter l'entrée du contrôle du serveur. Des expressions régulières et des règles de validation personnalisées peuvent être utilisées pour limiter l'entrée provenant d'autres sources.
Rejeter. Détectez les entrées de données nuisibles connues et rejetez-les.
Filtrage : Parfois, vous souhaiterez filtrer les parties de la saisie utilisateur qui présentent des risques de sécurité. Par exemple, si votre application autorise les saisies de forme libre, telles que les champs mémo, vous autoriserez certaines balises HTML sécurisées telles que <b>, <i. > et d'autres balises HTML.

Résumé de l'étape

Protégez votre application ASP.NET contre les attaques par injection en suivant ces étapes :

Étape 1. Utilisez la vérification des requêtes ASP.NET.
Étape 2. Limiter la saisie.
Étape 3. Encodez la sortie non sécurisée.
Étape 4. Utilisez les paramètres de commande pour les instructions de requête SQL.
Étape 5. Vérifiez que les informations d'erreur ASP.NET ne sont pas divulguées au client.

Les chapitres suivants aborderont ces étapes en détail.

Étape 1. Utiliser la validation des requêtes ASP.NET

Par défaut, la validation des requêtes ASP.NET 1.1 et 2.0 vérifie si les données envoyées au serveur contiennent des éléments de balisage HTML et des caractères réservés. de saisir des scripts dans le programme. La validation de la demande sera comparée à une liste de chaînes potentiellement menaçantes, et si une exception est trouvée, elle lancera une exception de type HttpRequestValidationException.

Vous pouvez le faire dans votre fichier web.config en < Add validateRequest=. "false" à l'élément pages> ou définissez ValidateRequest = "false" dans l'élément @Pages d'une page séparée pour désactiver cette fonctionnalité.

Si vous souhaitez désactiver la validation des demandes, vous pouvez la désactiver uniquement sur les pages où vous en avez besoin. Par exemple, si vous incluez un champ sur la page du programme qui accepte les entrées au format HTML,

assurez-vous que la fonctionnalité de validation des demandes est activée dans le fichier Machine.config

. La fonctionnalité de validation des demandes est activée par défaut dans ASP.NET. pouvez le faire dans le fichier Machine.config.comments. Vous voyez les paramètres par défaut suivants.

Assurez-vous de ne pas avoir modifié les paramètres par défaut dans le fichier Machine.config de votre serveur et dans le Web de l'application. Fichiers de configuration.

Tester la validation des requêtes ASP.NET

Vous pouvez tester l'effet de la validation des requêtes. Créez une page ASP.NET et désactivez la validation des requêtes en définissant ValidateRequest = "fasle" comme suit :

<%@ Language="C#" ValidateRequest="false" %>
<html>
<script runat="serveur">
void btnSubmit_Click (expéditeur de l'objet, EventArgs e)
{
// Si ValidateRequest est faux, alors 'bonjour' est affiché
// Si ValidateRequest est vrai, alors ASP.NET renvoie une exception
Réponse.Write(txtString.Text);
}
</script>
<corps>
<form id="form1" runat="serveur">
<asp:TextBox id="txtString" runat="serveur"
Text="<script>alerte('bonjour');</script>" />
<asp:Button id="btnSubmit" runat="server" OnClick="btnSubmit_Click"
Text="Soumettre" />
</form>
</corps>
</html>

Lorsque vous exécutez la page, « Bonjour » s'affiche dans une boîte de message car le script dans txtString est exécuté et traité par le navigateur du client.

Si vous définissez ValidateRequest = « true » ou supprimez l'attribut de page ValidateRequest, la validation de la demande ASP .NET. rejettera l'entrée du script et générera un message d'erreur comme celui ci-dessous.

Une valeur Request.Form potentiellement dangereuse a été détectée auprès du client (txtString="<script>alert('hello").

Veillez à ne pas vous fier uniquement à la fonction de vérification des demandes, mais à l'utiliser uniquement comme méthode de guidage pour la vérification personnalisée.

Étape 2. Contraindre l'entrée

Pour contraindre l'entrée, utilisez la méthode suivante :

Utilisez la validation des entrées côté serveur. Ne vous fiez pas à la validation côté client, car elle peut être facilement contournée. Utilisez la validation côté client pour réduire le nombre de rebonds de page, améliorer les performances et l'expérience utilisateur.
Validez la longueur, la plage, le format et le type de l'entrée. Assurez-vous que le contenu de l'entrée est correct et répond aux exigences.
Utilisez des types de données forts. Spécifiez un type tel que Integer ou Double pour la saisie numérique. Spécifiez le type de données String pour la saisie de caractères. Spécifiez le type DateTime pour la saisie de la date et de l'heure.
Pour valider les champs d'entrée de contrôle HTML dans un formulaire, effectuez une validation dans le code côté serveur. L'utilisation du type d'expression régulière Regex peut aider à limiter la saisie de caractères. La section suivante décrit comment contraindre les variables des types d'entrée courants

Pour valider les champs de chaîne tels que le nom, l'adresse, le fax et le numéro d'acte de naissance, utilisez des expressions régulières.
Limite la plage acceptable de caractères.
Activez les règles de formatage. Par exemple, les champs basés sur des modèles tels que le numéro d'identification fiscale, le code postal et le code postal nécessitent des modèles de caractères spécifiés.
Vérifiez la longueur.

Utiliser le contrôle de validation d'expression régulière (RegularExpressionValidator)

Pour utiliser le contrôle de validation d'expression régulière, vous devez définir le nom du contrôle à vérifier (ControlToValidate), l'expression de validation (ValidationExpression) et le message d'erreur (ErrorMessage). Pour les paramètres de propriété associés, veuillez consulter le code. exemple ci-dessous.

Dans le code ci-dessus, une expression régulière est utilisée pour limiter le nom d'entrée aux lettres (les lettres majuscules et minuscules sont autorisées), aux espaces, aux ellipses de nom unique comme O'Dell et aux points. De plus, la longueur des caractères d'entrée est limitée à 40 caractères. Caractères.

Notez que le contrôle de validation de l'expression régulière (RegularExpressionValidator) ajoutera automatiquement le caret (^) et le signe dollar ($) comme délimiteurs de début et de fin. Si vous ne les avez pas ajoutés dans l'expression personnalisée, il est préférable de les ajouter. L'ajout de délimiteurs permet simplement à votre expression d'obtenir la partie des données souhaitée.

Utilisez la classe d'expression régulière (classe Regex)

si vous n'utilisez pas de contrôles côté serveur (ce qui signifie que vous ne pouvez pas utiliser de contrôles de validation) ou si vous en avez besoin d'autres. Pour les sources de champs de saisie autres que les champs de formulaire (tels que les paramètres de chaîne de requête et les cookies), vous pouvez utiliser une classe d'expression régulière (classe Regex).

Utilisez la classe d'expression régulière

pour importer l'espace de noms System.Text.RegularExpressions en ajoutant une instruction avec l'utilisation. préfixe.
Assurez-vous que l'expression régulière contient "^" et "$" (au début de la chaîne, à la fin de la chaîne).
Appelez la méthode IsMatch de la classe Regex, voici un exemple de code.

//Méthode d'instance :
Regex reg = new Regex (@"^[a-zA-Z'.s]{1,40}$");
Response.Write(reg.IsMatch(txtName.Text));

// Méthode statique :
if (!Regex.IsMatch(txtName.Text,@"^[a-zA-Z'.s]{1,40}$"))
{
// Le nom ne correspond pas à l'expression
}

Si vous ne pouvez pas mettre en cache les expressions régulières fréquemment utilisées, vous devez utiliser la méthode statique IsMatch pour améliorer les performances et empêcher la création d'objets inutiles.

Validation des champs numériques

Dans la plupart des cas, vous devez valider les entrées et les plages numériques. Utiliser les contrôles du serveur pour vérifier l'entrée et la plage. Pour les champs numériques, utilisez le contrôle RangeValidator. RangeValidator prend en charge les données de type devise, date, entier, double précision et chaîne.

Pour utiliser le contrôle RangeValidator, vous devez définir le nom du contrôle (ControlToValidate), le type (Type) et la valeur minimale (MinimumValue). ), la valeur maximale (MaximumValue) et les propriétés du message d'erreur (ErrorMessage). Voici l'exemple de code :

<asp:RangeValidator
ID="RangeValidator1"
Runat="serveur"
ErrorMessage="Plage non valide. Le nombre doit être compris entre 0 et 255."
ControlToValidate="rangeInput"
Valeur maximale="255"
Valeur Minimum="0" Type="Entier" />

Si vous n'utilisez pas de contrôle serveur, vous pouvez effectuer la vérification de la plage de nombres en convertissant la valeur d'entrée en nombre entier, puis en la validant. Par exemple, pour vérifier si un entier est légal, utilisez la nouvelle méthode Int32.TryParse fournie par ASP.NET 2.0 pour convertir la valeur d'entrée en type de variable System.Int32. Cette méthode renverra false si la conversion échoue.

Int32 je;
if (Int32.TryParse(txtInput.Text, out i) == false)
{
//La conversion a échoué
}

Si vous utilisez une version antérieure d'ASP.NET, vous pouvez utiliser la méthode Int32.Parse ou Convert.ToInt32 dans un bloc try/catch et gérer l'exception FormatException levée lorsque la conversion échoue.

L'exemple de code suivant montre comment valider. from HTML Le type et la plage du type entier de la zone de texte.

<%@ Page Language="C#" %>

void Page_Load (expéditeur de l'objet, EventArgs e)
{
si (Request.RequestType == "POST")
{
int je;
if (Int32.TryParse(Request.Form["integerTxt"], out i) == true)
{
// TryParse renvoie true si la conversion réussit
si ((0 <= i && i <= 255) == vrai)
{
Response.Write("Les données d'entrée sont valides.");
}
autre
Response.Write("Les données d'entrée sont hors plage");
}
autre
Response.Write("Les données d'entrée ne sont pas un entier");
}
}

</script>

<html>
<corps>
<form id="form1" action="NumericInput.aspx" method="post">
<div>
Saisissez un entier compris entre 0 et 255 :
<input name="integerTxt" type="text" />
<input name="Soumettre" type="soumettre" value="soumettre" />
</div>
</form>
</corps>
</html>

Validation des champs de date

Vous devez vérifier que les champs de date sont du type correct. Dans la plupart des cas, vous devrez également vérifier leur plage, par exemple en vérifiant s'ils sont dans le futur ou dans le passé si vous utilisez un contrôle serveur. pour capturer une valeur d'entrée de date, et si vous souhaitez que la valeur soit dans une plage spécifique, vous pouvez utiliser le contrôle de validation de plage (RangeValidator) et définir son type autorisé sur le type Date. Ce contrôle vous permet de spécifier une période de temps spéciale. en définissant le moment de départ. Si vous devez utiliser l'heure du jour comme référence pour vérifier, par exemple pour vérifier si une heure est dans le futur ou dans le passé, vous pouvez utiliser le contrôle de validation CustomValidator.
L’utilisation du contrôle CustomValidator pour valider une date nécessite la définition des propriétés ControlToValidate et ErrorMessage et la spécification d’une méthode logique de validation personnalisée dans l’événement OnServerValidate. Voici un exemple de code.

<%@ Page Language="C#" %>

void ValidateDateInFuture (source de l'objet, arguments ServerValidateEventArgs)
{
DateTime dt;

// Vérifie la date valide et que la date est dans le futur
if ((DateTime.TryParse(args.Value, out dt) == false) ||
(dt <= DateHeure.Aujourd'hui))
{
args.IsValid = false;
}
}

</script>

Notez que le code ci-dessus utilise la méthode DateTime.TryParse qui est une nouvelle méthode fournie par ASP.NET 2.0.

Pour filtrer les champs de texte libre

afin de filtrer les entrées, vous devez vous assurer que les entrées non sécurisées ne sont pas traitées comme du code.

permet

à l'utilisateur de Les données de la base de données partagée ne peuvent pas être lues. Vous devez d'abord filtrer les données afin qu'elles ne soient pas dangereuses lors de la sortie. Utilisez la méthode HttpUtility.HtmlEncode pour encoder d'abord la valeur d'entrée.

Ajoutez les champs suivants à l'élément de page @Page ValidateRequest = "false" pour désactiver la validation de la demande ASP.NET. Utilisez la méthode HtmlEncode pour coder la chaîne d'entrée. Utilisez l'objet StringBuilder et appelez sa méthode Replace pour remplacer le code HTML dans les caractères. Le code suivant donne Voici un exemple de cette approche. Cette page désactive la validation des requêtes ASP.NET en définissant ValidateRequest = "fasle". Son encodage HTML permet l'utilisation des balises <b> et <i> afin d'afficher une mise en forme de texte simple. .

<%@ Page Language="C#" ValidateRequest="false"%>

void submitBtn_Click (expéditeur de l'objet, EventArgs e)
{
// Encode la chaîne d'entrée
StringBuilder sb = nouveau StringBuilder (
HttpUtility.HtmlEncode(htmlInputTxt.Text));
// Autoriser sélectivement et <i>
sb.Replace("<b>", "<b>");
sb.Replace("</b>", "");
sb.Replace("<i>", "<i>");
sb.Replace("</i>", "");
Réponse.Write(sb.ToString());
}
</script>

Valider la valeur de la chaîne de requête

Validez la longueur, la plage, le format et le type d'une chaîne de requête. En règle générale, vous utilisez une expression régulière combinée pour accomplir les tâches suivantes :

Contraindre les valeurs d'entrée Définir des vérifications de plage explicites Spécifier le type d'entrée et le convertir en ASP.NET. platform Le type suivant gère toutes les exceptions provoquées par les conversions de type. L'exemple de code suivant montre l'utilisation de la classe Regex pour valider la chaîne de nom transmise dans la chaîne de requête.

void Page_Load (expéditeur de l'objet, EventArgs e)
{
si (!System.Text.RegularExpressions.Regex.IsMatch(
Request.QueryString["Nom"], @"^[a-zA-Z'.s]{1,40}$"))
Response.Write("Paramètre de nom invalide");
autre
Response.Write("Le nom est " + Request.QueryString["Nom"]);
}

Valider les valeurs des cookies

Les valeurs stockées dans les cookies comme les chaînes de requête peuvent facilement être modifiées par l'utilisateur. Validez également la longueur, la plage, le format et le type de ces valeurs.

Validez les adresses de fichier et d'URL

si votre programme autorise la saisie de fichiers

noms, adresse de fichier ou chemin de stockage du fichier, vous devez vérifier qu'ils sont dans le format correct et qu'ils pointent vers un emplacement valide en fonction de la situation réelle de votre programme. Si cette vérification échoue, votre programme peut être invité par erreur à y accéder. le fichier.

Vérifiez le chemin du fichier

afin d'éviter que votre programme ne soit exploité par les utilisateurs pour accéder aux fichiers, empêchez-le d'accepter les fichiers ou les chemins de fichiers saisis par le code écrit par l'utilisateur. Par exemple :

Si vous acceptez les noms de fichiers d'entrée, utilisez le système. Méthode .IO.Path.GetFileName pour obtenir le nom complet du fichier. Si vous le devez. Accepte un chemin de fichier d'entrée et utilise System.IO.Path.GetFullPath pour obtenir le chemin de fichier complet. Utilisez la méthode MapPath pour empêcher le mappage entre applications. .

Si vous utilisez la méthode MapPath pour mapper un répertoire virtuel fourni à un répertoire physique sur le serveur, utilisez une version surchargée de la méthode Request.MapPath avec un paramètre bool pour empêcher le mappage entre applications. Voici un exemple de code pour cette technique :

essayer
{
chaîne mappedPath = Request.MapPath( inputPath.Text,
Request.ApplicationPath, faux);
}
attraper (HttpException)
{
// Tentative de mappage inter-applications
}

Le dernier paramètre false empêchera le mappage entre applications. Cela signifie que les utilisateurs ne sont pas autorisés à utiliser la syntaxe "..." pour fournir un chemin illégal qui ne se trouve pas dans le répertoire virtuel que vous avez spécifié.

Si vous utilisez des contrôles serveur, vous pouvez utiliser la méthode Control.MapPathSecure pour obtenir l'adresse de répertoire réelle correspondant au répertoire virtuel.
La méthode Control.MapPathSecure lève une HttpException lors de l'accès à un fichier non autorisé. Pour plus d’informations, consultez l’introduction de la méthode Control.MapPathSecure dans la documentation du .NET Framework.

Utilisation de la sécurité d'accès au code pour limiter les entrées et sorties de fichiers

Les administrateurs peuvent limiter la capacité d'un programme à lire et à écrire des fichiers dans le répertoire virtuel où il réside en définissant sa crédibilité sur « moyenne ». Le mécanisme de sécurité du code .NET garantit que le programme ne dispose d'aucun droit d'accès aux fichiers en dehors du répertoire virtuel où il se trouve.

Pour définir le niveau de confiance d'une application sur "moyen", vous pouvez ajouter :

< niveau de confiance = "Moyen". />

Vérifier l'URL

Vous pouvez utiliser des expressions régulières telles que celles-ci pour faire correspondre les URL

^(?:http|https|ftp)://[a-zA-Z0-9 .-]+(?::d. {1,5})?(?:[A-Za-z0-9.;:@&=+$,? /]|%u[0-9A-Fa- f]{4}|%[0-9A-Fa-f]{2})*$

Cela limite uniquement le format d'entrée et ne vérifie pas s'il est acceptable dans l'application dans le cadre de votre application. Vous devez vérifier cela. il est valide dans le contexte de votre application. Par exemple, votre application communique-t-elle avec le serveur que vous spécifiez ?

Étape 3. Encoder le code non sécurisé

Si vous entrez du texte dans une page Web, utilisez la méthode HttpUtility.HtmlEncode pour l'encoder. Si le texte provient d'une saisie utilisateur, d'une base de données ou d'un fichier local, veillez à toujours le faire.

De même, si vous écrivez une URL contenant des caractères non sécurisés car ils proviennent du contenu saisi par l'utilisateur, de bases de données, etc., utilisez le

Méthode HttpUtility.UrlEncode pour encoder.

Afin d'éviter l'encodage avant le stockage des données, ce qui pourrait endommager les données stockées, assurez-vous de les encoder le plus tard possible lors de leur affichage.

Pour un encodage de sortie dangereux,

HtmlEncode remplace les balises HTML. avec des chaînes textuelles spéciales pour représenter ces symboles et empêche le navigateur de les interpréter comme des balises HTML. Par exemple, "<" est remplacé par < " (deux points) est remplacé par " Ces balises sont affichées sous forme de texte inoffensif.

<%@ Page Language="C#" ValidateRequest="false" %>

Pour voir l'effet de l'encodage HTML, veuillez créer un répertoire virtuel et y placer les fichiers susmentionnés, exécutez cette page, entrez du code HTML dans la zone de texte et cliquez sur le bouton Soumettre. Par exemple, l'entrée suivante s'affiche comme d'habitude. text.

Exécutez le script et dites bonjour <script>alert('hello');</script>

Si vous supprimez l'appel à la méthode HtmlEncode et entrez simplement le contenu du texte, le navigateur exécutera le code et affichera une boîte de dialogue.

L'utilisation de la méthode UrlEncode n'est pas sûre. Encodage de l'adresse URL

Si vous devez obtenir les paramètres d'URL avec la partie saisie par l'utilisateur, ce qui peut entraîner certains risques de sécurité, utilisez la méthode HttpUtility.UrlEncode pour encoder la chaîne d'adresse

HttpUtility.UrlEncode(urlString)

;

Étape 4. SQL L'instruction utilise la méthode des paramètres de commande.

Pour éviter les attaques par injection, veuillez utiliser la méthode des paramètres SQL. La collection Parameters fournit une détection de type et une détection de longueur. Si vous utilisez la collection de paramètres, le contenu d'entrée sera traité comme un. valeur de texte, et la base de données ne sera pas exécutée. Un avantage supplémentaire de l'utilisation de la méthode de jeu de paramètres est que vous pouvez limiter strictement le type et la longueur de l'entrée. Si le type d'entrée est hors plage, un. Une exception sera déclenchée.

Lors de l'appel d'une procédure stockée, utilisez le jeu de paramètres

ci-dessous. L'extrait de code montre un exemple d'utilisation de jeux de paramètres lors de l'appel d'une procédure stockée.

SqlDataAdapter myCommand = new SqlDataAdapter("AuthorLogin",
maConnexion);
myCommand.SelectCommand.CommandType = CommandType.StoredProcedure ;
SqlParameter parm = myCommand.SelectCommand.Parameters.Add(
"@LoginId", SqlDbType.VarChar, 11 );
parm.Value = Login.Text;

Utilisez des jeux de paramètres lors de la création de vos propres instructions SQL.

Si vous ne pouvez pas utiliser de procédures stockées, vous pouvez toujours utiliser des jeux de paramètres, consultez le code ci-dessous.

SqlDataAdapter myCommand = nouveau SqlDataAdapter (
"SELECT au_lname, au_fname FROM Auteurs WHERE au_id = @au_id", myConnection);
SQLParameter parm = myCommand.SelectCommand.Parameters.Add(
"@au_id",SqlDbType.VarChar, 11);
Parm.Value = Login.Text ;

Pour plus d'informations sur la façon d'empêcher les attaques par injection SQL, consultez Comment : protéger contre l'injection SQL dans ASP.NET

Étape 5. Pour vérifier que les messages d'erreur ASP.NET ne sont pas renvoyés au client,

vous pouvez utiliser l'élément <customErrors>. . Pour configurer le client, des messages d'erreur généraux doivent être renvoyés au client par le mécanisme de détection des erreurs du programme.

Veuillez confirmer que vous avez modifié l'attribut mode dans web.config en "remoteOnly", ce qui suit est un exemple

<customErrors mode =

"remoteOnly">

Dans Après l'installation d'un programme ASP.NET, vous pouvez spécifier la page de message d'erreur du client comme suit.

Pour des ressources supplémentaires, veuillez consulter les rubriques connexes :

Comment utiliser des expressions régulières pour limiter les entrées dans ASP.NET

Empêcher les attaques par injection SQL

et empêcher les attaques de scripts intersites.

PS : J'ai enfin fini de le lire. Je suis tellement fatigué. Cela m'a pris près de trois jours. En fait, ces phrases sont très simples si on les regarde. C'est la première fois que je fais une traduction. Veuillez me pardonner si la traduction n'est pas bonne, merci.