Injektionsangriffe in ASP.NET verhindern [Übersetzung]

Autor：Eve Cole Aktualisierungszeit：2009-06-30 16:03:51

Quelle: MSDN
Übersetzung: Yunzhongcheng BLOG

Anwendungsbereich:

ASP.NET-Version 1.1
ASP.NET-Version 2.0

Zusammenfassung:

In diesem Text wird hauptsächlich erläutert, wie Benutzereingaben überprüft werden, um Injektionsangriffe zu verhindern. Fast alle Angriffe auf Programmebene enthalten schädliche Eingabemethoden,

einschließlich Felder, Abfragezeichenfolgenparameter, Cookies und andere Benutzer Eingabeelemente werden verwendet, um Ihr Programm vor Injektionsangriffen zu schützen. Sie müssen davon ausgehen, dass alle Benutzereingaben böswillig sind, und sicherstellen, dass alle Benutzereingaben auf der Serverseite überprüft werden. Die Verwendung einer clientbasierten Validierung kann die Anzahl der Aufenthalte auf der Seite verringern. Verbessern Sie die Leistung und verbessern Sie die Benutzererfahrung, aber verlassen Sie sich nicht nur darauf, denn die clientseitige Validierung kann leicht von Hackern getäuscht werden.

Um Eingabeinhalte zu validieren, sollten Sie akzeptable Eingaberegeln für jedes Eingabefeld definieren Es ist nicht gut, Einschränkungen basierend auf der Länge, dem Bereich, dem Format und dem Typ des Eingabefelds anstelle einer Liste illegaler Zeichen festzulegen. Die Verwendung von Einschränkungen für eine Liste illegaler Zeichen ist fast unmöglich Um alle schädlichen Eingaben zu filtern

, verwenden Sie am besten eine Methode wie HtmlEncode, um sie sicher zu kodieren, bevor Sie sie anzeigen.

Inhalt:

Schritt-für-Schritt-

Übersicht

über

die Implementierung.

Schritt 1. Verwendung von ASP. NET-Anforderungsüberprüfung.

Schritt

3. Verwenden Sie unsichere Eingaben.

Schritt 5.

Überprüfen Sie, ob ASP.NET

Fehler an den Client zurückgegeben werden

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

Zweck:

Beschränken Sie die Länge, den Bereich, das Format und den Typ der Eingabezeichenfolge.
Verwenden Sie die Anforderungsvalidierung, um Injektionsangriffe bei der Entwicklung von ASP.NET-Programmen zu verhindern.
Verwenden Sie ASP.NET-Validierungssteuerelemente für die Eingabevalidierung.
Codieren Sie unsichere Ausgaben.
Verhindern Sie Injektionsangriffe mithilfe des Befehlsparametersatzmusters.
Verhindern Sie, dass Fehlerdetails an den Client zurückgegeben werden.
Übersicht:

Sie sollten alle nicht vertrauenswürdigen Eingaben in Ihrer Anwendung validieren. Sie sollten davon ausgehen, dass alle Benutzereingaben ungültig sind. Benutzer können Formularfelder, Abfragezeichenfolgen, Client-Cookies und Browserumgebungswerte wie Benutzer-Proxy-Zeichenfolgen usw. bereitstellen IP-Adressen usw.

Eine schwache Eingabevalidierung bietet normalerweise Möglichkeiten für Injektionsangriffe. Im Folgenden sind gängige Angriffsmethoden aufgeführt, die eine schwache Eingabevalidierung oder keine Eingabevalidierung verwenden.

Wenn Sie Benutzereingabewerte verwenden, um SQL-Anweisungen dynamisch zu erstellen, führt die Datenbank möglicherweise anstößige und schädliche SQL-Anweisungen aus.
Cross-Site-Scripting-Angriffe nutzen Schwachstellen bei der Webseitenvalidierung aus, um clientseitige Skripte einzuschleusen und vom Browser zu interpretieren und auszuführen Der Browser kann nicht erkennen, dass der Code schädlich ist.
Unbefugter Dateizugriff: Wenn Ihr Code Eingaben vom Aufrufer akzeptiert, kann ein böswilliger Benutzer Ihre Dateivorgänge sehen und auf geschützte Dateien zugreifen oder Ihren Code verwenden, um illegale Daten einzuschleusen.

Hinweis: Injektionsangriffe können über HTTP- oder HTTPS-Secure-Socket-Layer-Verbindungen (SSL) durchgeführt werden, um Angriffe zu verhindern.

Im Folgenden werden allgemeine Eingabevalidierungsmethoden zusammengefasst B. Textfelder und andere Formulareingabefelder, Abfragezeichenfolgenparameter, Cookies, serverseitige Variablen und Netzwerkmethodenparameter. Beachten Sie, dass die Filterstrategie nur korrekte Eingaben zulassen und illegale Eingaben ablehnen sollte Besser als das Filtern aller. Es ist einfacher, illegale Eingaben zu erkennen, aber es ist normalerweise schwierig, alle illegalen Eingaben einzubeziehen.

Überprüfen Sie den Eingabeinhalt anhand der folgenden Aspekte:

Einschränkungen. Stellen Sie sicher, dass die Eingabe den richtigen Typ, die richtige Zeichenlänge und das richtige Format hat. Mithilfe von ASP.NET-Validierungskontrollen können Sie die Eingabe aus anderen Quellen einschränken.
Ablehnen. Erkennen Sie bekanntermaßen schädliche Dateneingaben und lehnen Sie sie ab.
Filtern. Manchmal möchten Sie die Teile der Benutzereingabe herausfiltern, die ein Sicherheitsrisiko darstellen. Wenn Ihre Anwendung beispielsweise Freiformeingaben wie Memofelder zulässt, lassen Sie bestimmte sichere HTML-Tags wie <b>, <i zu > und andere HTML-Tags.

Zusammenfassung der Schritte

Schützen Sie Ihre ASP.NET-Anwendung vor Injektionsangriffen, indem Sie die folgenden Schritte ausführen:

Schritt 1: Verwenden Sie die ASP.NET-Anforderungsüberprüfung.
Schritt 2: Eingabe einschränken.
Schritt 3. Unsichere Ausgabe kodieren.
Schritt 4: Verwenden Sie Befehlsparameter für SQL-Abfrageanweisungen.
Schritt 5: Stellen Sie sicher, dass ASP.NET-Fehlerinformationen nicht an den Client weitergegeben werden.

In den folgenden Kapiteln werden diese Schritte im Detail erläutert.

Schritt 1. Verwenden Sie die ASP.NET-Anforderungsvalidierung.

Standardmäßig prüft die ASP.NET-Anforderungsvalidierung, ob die an den Server gesendeten Daten HTML-Markup-Elemente und reservierte Zeichen enthalten Die Anforderungsvalidierung wird mit einer Liste potenziell bedrohlicher Zeichenfolgen abgeglichen, und wenn eine Ausnahme gefunden wird, wird eine Ausnahme vom Typ HttpRequestValidationException ausgelöst.

Sie können dies in Ihrer web.config-Datei tun, indem Sie „validateRequest=“ hinzufügen „false“ für das Element „pages>“ oder legen Sie ValidateRequest = „false“ im Element „@Pages“ einer separaten Seite fest, um diese Funktion zu deaktivieren.

Wenn Sie die Anforderungsvalidierung deaktivieren möchten, können Sie sie nur auf den Seiten deaktivieren, auf denen Sie sie benötigen. Wenn Sie beispielsweise ein Feld auf der Programmseite einfügen, das Eingaben im HTML-Format akzeptiert,

stellen Sie sicher, dass die Anforderungsvalidierungsfunktion in der Datei Machine.config aktiviert ist

. Die Anforderungsvalidierungsfunktion ist in ASP.NET You standardmäßig aktiviert

Sie können dies in der Datei „Machine.config.comments

“

tun. Sie sehen die folgenden Standardeinstellungen

in „Machine.config“ und „Web“ Ihrer Anwendung. Konfigurationsdateien.

Testen Sie die ASP.NET-Anforderungsvalidierung.

Sie können die Wirkung der Anforderungsvalidierung testen. Erstellen Sie eine ASP.NET-Seite und deaktivieren Sie die Anforderungsvalidierung, indem Sie ValidateRequest = „fasle“ wie folgt festlegen:

<%@ Language="C#" ValidateRequest="false" %>
<html>
<script runat="server">
void btnSubmit_Click(Object sender, EventArgs e)
{
// Wenn ValidateRequest falsch ist, wird „Hallo“ angezeigt
// Wenn ValidateRequest wahr ist, gibt ASP.NET eine Ausnahme zurück
Response.Write(txtString.Text);
}
</script>
<Körper>
<form id="form1" runat="server">
<asp:TextBox id="txtString" runat="server"
Text="<script>alert('hello');</script>" />
<asp:Button id="btnSubmit" runat="server" OnClick="btnSubmit_Click"
Text="Senden" />
</form>
</body>
</html>

Wenn Sie die Seite ausführen, wird „Hallo“ in einem Meldungsfeld angezeigt, da das Skript im txtString vom Browser des Clients ausgeführt und verarbeitet wird.

Wenn Sie ValidateRequest = „true“ festlegen oder das ValidateRequest-Seitenattribut entfernen, fordert ASP .NET eine Validierung an lehnt die Skripteingabe ab und gibt eine Fehlermeldung wie die folgende aus.

Vom Client wurde ein potenziell gefährlicher Request.Form-Wert erkannt (txtString="<script>alert('hello").

Achten Sie darauf, dass Sie sich nicht ausschließlich auf die Anforderungsüberprüfungsfunktion verlassen, sondern sie nur als Orientierungsmethode für die benutzerdefinierte Überprüfung verwenden.

Schritt 2: Beschränken Sie die Eingabe

, indem Sie die folgende Methode verwenden:

Verwenden Sie die serverseitige Eingabevalidierung. Verlassen Sie sich nicht auf die clientseitige Validierung, da diese leicht umgangen werden kann, um die Anzahl der Seitenabbrüche zu reduzieren, die Leistung zu verbessern und das Benutzererlebnis zu verbessern.
Überprüfen Sie Länge, Bereich, Format und Typ der Eingabe. Stellen Sie sicher, dass der Eingabeinhalt korrekt ist und den Anforderungen entspricht.
Verwenden Sie starke Datentypen wie „Integer“ oder „Double“ für die numerische Eingabe. Geben Sie den Datentyp „DateTime“ für die Eingabe von Datum und Uhrzeit an.
Um HTML-Steuerelement-Eingabefelder in einem Formular zu validieren, führen Sie eine Validierung im serverseitigen Code durch. Die Verwendung des regulären Ausdruckstyps kann dabei helfen, die Zeicheneingabe einzuschränken. Im folgenden Abschnitt wird beschrieben, wie Sie Variablen gängiger Eingabetypen

einschränken

Verwenden Sie reguläre Ausdrücke, um Zeichenfolgenfelder wie Name, Adresse, Fax und Geburtsurkundennummer zu validieren.
Beschränkt den zulässigen Zeichenbereich.
Aktivieren Sie Formatierungsregeln. Beispielsweise erfordern musterbasierte Felder wie Steuer-ID, Postleitzahl und Postleitzahl bestimmte Zeichenmuster.
Länge überprüfen.

Verwenden Sie die Validierungssteuerung für reguläre Ausdrücke (RegularExpresionValidator).

Um die Validierungssteuerung für reguläre Ausdrücke zu verwenden, müssen Sie den zu überprüfenden Steuerelementnamen (ControlToValidate), den Validierungsausdruck (ValidationExpression) und die Fehlermeldung (ErrorMessage) festlegen. Weitere Informationen zu den zugehörigen Eigenschaftseinstellungen finden Sie im Code Beispiel unten.

Im obigen Code wird ein regulärer Ausdruck verwendet, um den Eingabenamen auf Buchstaben (Groß- und Kleinbuchstaben sind zulässig), Leerzeichen, Einzelnamen-Ellipsen wie O'Dell und Punkte zu beschränken. Darüber hinaus ist die Länge der Eingabezeichen auf 40 Zeichen begrenzt Zeichen.

Beachten Sie, dass das Validierungssteuerelement für reguläre Ausdrücke (RegularExpressionValidator) automatisch das Caret-Zeichen (^) und das Dollarzeichen ($) als Start- und Endtrennzeichen hinzufügt. Wenn Sie diese nicht im benutzerdefinierten Ausdruck hinzugefügt haben, ist es am besten, sie hinzuzufügen Das Hinzufügen von Trennzeichen dient lediglich dazu, dass Ihr Ausdruck den gewünschten Teil der Daten erhält.

Verwenden Sie die Klasse für reguläre Ausdrücke (Regex-Klasse),

wenn Sie keine serverseitigen Steuerelemente verwenden (d. h. Sie können keine Validierungssteuerelemente verwenden) oder andere benötigen Für andere Eingabefeldquellen als Formularfelder (z. B. Abfragezeichenfolgenparameter und Cookies) können Sie eine reguläre Ausdrucksklasse (Regex-Klasse) verwenden.

Verwenden Sie die reguläre Ausdrucksklasse,

um den System.Text.RegularExpressions-Namespace zu importieren, indem Sie eine Anweisung mit dem using hinzufügen Präfix.
Stellen Sie sicher, dass der reguläre Ausdruck „^“ und „$“ enthält (am Anfang der Zeichenfolge, am Ende der Zeichenfolge).
Rufen Sie die IsMatch-Methode der Regex-Klasse auf. Das Folgende ist ein Codebeispiel.

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

// Statische Methode:
if (!Regex.IsMatch(txtName.Text,@"^[a-zA-Z'.s]{1,40}$"))
{
// Name stimmt nicht mit Ausdruck überein
}

Wenn Sie häufig verwendete reguläre Ausdrücke nicht zwischenspeichern können, sollten Sie die statische Methode IsMatch verwenden, um die Leistung zu verbessern und unnötige Objekterstellung zu verhindern.

In den meisten Fällen sollten Sie

numerische

Eingaben und Bereiche validieren. Verwenden Sie Serversteuerelemente, um die Eingabe und den Bereich zu überprüfen Für numerische Felder verwenden Sie das RangeValidator-Steuerelement.

Um das RangeValidator-Steuerelement verwenden zu können, müssen Sie den Steuerelementnamen (ControlToValidate), den Mindestwert (MinimumValue) festlegen ), Maximalwert (MaximumValue) und Fehlermeldung (ErrorMessage). Hier ist das Codebeispiel:

<asp:RangeValidator
ID="RangeValidator1"
Runat="server"
ErrorMessage="Ungültiger Bereich. Zahl muss zwischen 0 und 255 liegen."
ControlToValidate="rangeInput"
MaximumValue="255"
MinimumValue="0" Type="Integer" />

Wenn Sie kein Serversteuerelement verwenden, können Sie die Bereichsüberprüfung von Zahlen abschließen, indem Sie den Eingabewert in eine Ganzzahl konvertieren und ihn dann validieren. Um beispielsweise zu überprüfen, ob eine Ganzzahl zulässig ist, verwenden Sie die neue Methode Int32.TryParse von ASP.NET 2.0, um den Eingabewert in den Variablentyp System.Int32 zu konvertieren. Diese Methode gibt false zurück, wenn die Konvertierung fehlschlägt.

Int32 i;
if (Int32.TryParse(txtInput.Text, out i) == false)
{
//Konvertierung fehlgeschlagen
}

Wenn Sie eine frühere Version von ASP.NET verwenden, können Sie die Methode Int32.Parse oder Convert.ToInt32 in einem try/catch-Block verwenden und die FormatException behandeln, die ausgelöst wird, wenn die Konvertierung fehlschlägt.

Der folgende Beispielcode zeigt, wie die Validierung durchgeführt wird aus HTML Der Typ und Bereich des Ganzzahltyps des Textfelds.

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

void Page_Load(object sender, EventArgs e)
{
if (Request.RequestType == "POST")
{
int i;
if (Int32.TryParse(Request.Form["integerTxt"], out i) == true)
{
// TryParse gibt true zurück, wenn die Konvertierung erfolgreich ist
if ((0 <= i && i <= 255) == true)
{
Response.Write("Eingabedaten sind gültig.");
}
anders
Response.Write("Eingabedaten liegen außerhalb des Bereichs");
}
anders
Response.Write("Eingabedaten sind keine Ganzzahl");
}
}

</script>

<html>
<Körper>
<form id="form1" action="NumericInput.aspx" method="post">
<div>
Geben Sie eine ganze Zahl zwischen 0 und 255 ein:
<input name="integerTxt" type="text" />
<input name="Submit" type="submit" value="submit" />
</div>
</form>
</body>
</html>

Validieren von Datumsfeldern

Sie müssen überprüfen, ob Datumsfelder den richtigen Typ haben. In den meisten Fällen müssen Sie auch ihren Bereich überprüfen, z. B. überprüfen, ob sie in der Zukunft oder in der Vergangenheit liegen, wenn Sie ein Serversteuerelement verwenden Um einen Datumseingabewert zu erfassen und wenn der Wert innerhalb eines bestimmten Bereichs liegen soll, können Sie das Bereichsvalidierungssteuerelement (RangeValidator) verwenden und seinen zulässigen Typ auf den Datumstyp festlegen. Mit diesem Steuerelement können Sie einen speziellen Zeitraum angeben Durch Festlegen des Startzeitpunkts können Sie die heutige Zeit als Referenz zur Überprüfung verwenden, z. B. um zu überprüfen, ob eine Zeit in der Zukunft oder in der Vergangenheit liegt. Sie können das Validierungssteuerelement CustomValidator verwenden.
Die Verwendung des CustomValidator-Steuerelements zur Validierung eines Datums erfordert das Festlegen der Eigenschaften „ControlToValidate“ und „ErrorMessage“ sowie die Angabe einer benutzerdefinierten Validierungslogikmethode im OnServerValidate-Ereignis. Im Folgenden finden Sie Beispielcode.

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

void ValidateDateInFuture(object source, ServerValidateEventArgs args)
{
DateTime dt;

// Auf gültiges Datum prüfen und prüfen, ob das Datum in der Zukunft liegt
if ((DateTime.TryParse(args.Value, out dt) == false) ||
(dt <= DateTime.Today))
{
args.IsValid = false;
}
}

</script>

Beachten Sie, dass der obige Code die Methode DateTime.TryParse verwendet, eine neue Methode von ASP.NET 2.0.

Um Freitextfelder

zum Filtern von Eingaben zu filtern, müssen Sie sicherstellen, dass unsichere Eingaben nicht als Code behandelt werden

Ermöglicht

dem Benutzer, die Daten in der freigegebenen Datenbank nicht zu lesen, damit sie bei der Ausgabe nicht gefährlich sind. Verwenden Sie die Methode HttpUtility.HtmlEncode, um den Eingabewert zunächst zu codieren

Fügen Sie dem @Page-Seitenelement „ValidateRequest = „false““ die folgenden Felder hinzu, um die ASP.NET-Anforderungsvalidierung zu deaktivieren. Verwenden Sie das StringBuilder-Objekt und rufen Sie dessen „Replace“-Methode auf, um den HTML-Code in den Zeichen zu ersetzen. Der folgende Code zeigt ein Beispiel für diesen Ansatz. Diese Seite deaktiviert die ASP.NET-Anfragevalidierung durch Festlegen von ValidateRequest = „fasle“. Die HTML-Kodierung ermöglicht die Verwendung von <b>- und <i>-Tags, um einfache Textformatierungen anzuzeigen .

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

void subscribeBtn_Click(object sender, EventArgs e)
{
// Codieren Sie die String-Eingabe
StringBuilder sb = new StringBuilder(
HttpUtility.HtmlEncode(htmlInputTxt.Text));
// Selektiv zulassen und <i>
sb.Replace("<b>", "<b>");
sb.Replace("</b>", "");
sb.Replace("<i>", "<i>");
sb.Replace("</i>", "");
Response.Write(sb.ToString());
}
</script>

Validieren Sie den Wert der Abfragezeichenfolge

Überprüfen Sie die Länge, den Bereich, das Format und den Typ einer Abfragezeichenfolge. Normalerweise verwenden Sie einen kombinierten regulären Ausdruck, um die folgenden Aufgaben auszuführen:

Eingabewerte einschränken, explizite Bereichsprüfungen festlegen, den Eingabetyp angeben und ihn in ASP.NET konvertieren Plattform Der folgende Typ behandelt alle durch Typkonvertierungen verursachten Ausnahmen. Das folgende Codebeispiel zeigt die Verwendung der Regex-Klasse zur Validierung der in der Abfragezeichenfolge übergebenen Namenszeichenfolge.

void Page_Load(object sender, EventArgs e)
{
if (!System.Text.RegularExpressions.Regex.IsMatch(
Request.QueryString["Name"], @"^[a-zA-Z'.s]{1,40}$"))
Response.Write("Ungültiger Namensparameter");
anders
Response.Write("Name ist " + Request.QueryString["Name"]);
}

Validieren Sie Cookie-Werte.

In Cookies gespeicherte Werte wie Abfragezeichenfolgen können vom Benutzer leicht geändert werden. Überprüfen Sie auch die Länge, den Bereich, das Format und den Typ dieser Werte,

wenn Ihr Programm die Eingabe von Dateien

zulässt

Namen, Dateiadressen oder Dateispeicherpfade müssen Sie überprüfen, ob sie das richtige Format haben und auf einen gültigen Speicherort entsprechend der tatsächlichen Situation Ihres Programms verweisen. Wenn diese Überprüfung fehlschlägt, wird Ihr Programm möglicherweise fälschlicherweise zum Zugriff aufgefordert

Überprüfen Sie den Dateipfad

um zu verhindern, dass Ihr Programm von Benutzern zum Zugriff auf Dateien missbraucht wird. Verhindern Sie, dass es Dateien oder Dateipfade akzeptiert, die durch vom Benutzer geschriebenen Code eingegeben wurden. Wenn Sie beispielsweise

Eingabedateinamen akzeptieren, verwenden Sie das System .IO.Path.GetFileName-Methode, um den vollständigen Namen der Datei zu erhalten. Wenn Sie einen Eingabedateipfad akzeptieren und System.IO.Path.GetFullPath verwenden müssen, verwenden Sie die MapPath-Methode, um eine anwendungsübergreifende Zuordnung zu verhindern .

Wenn Sie die MapPath-Methode verwenden, um ein bereitgestelltes virtuelles Verzeichnis einem physischen Verzeichnis auf dem Server zuzuordnen, verwenden Sie eine überladene Version der Request.MapPath-Methode mit einem Bool-Parameter, um eine anwendungsübergreifende Zuordnung zu verhindern. Hier ist Beispielcode für diese Technik:

versuchen
{
string mappedPath = Request.MapPath( inputPath.Text,
Request.ApplicationPath, false);
}
Catch(HttpException)
{
// Anwendungsübergreifendes Mapping versucht
}

Der letzte Parameter „false“ verhindert eine anwendungsübergreifende Zuordnung. Dies bedeutet, dass Benutzer die „…“-Syntax nicht verwenden dürfen, um einen ungültigen Pfad anzugeben, der nicht innerhalb des von Ihnen angegebenen virtuellen Verzeichnisses liegt.

Wenn Sie Serversteuerelemente verwenden, können Sie die Control.MapPathSecure-Methode verwenden, um die tatsächliche Verzeichnisadresse abzurufen, die dem virtuellen Verzeichnis entspricht.
Die Control.MapPathSecure-Methode löst beim Zugriff auf eine nicht autorisierte Datei eine HttpException aus. Weitere Informationen finden Sie in der Einführung zur Control.MapPathSecure-Methode in der .NET Framework-Dokumentation.

Verwenden von Codezugriffssicherheit zur Einschränkung der Dateieingabe und -ausgabe

Administratoren können die Fähigkeit eines Programms zum Lesen und Schreiben von Dateien in das virtuelle Verzeichnis, in dem es sich befindet, einschränken, indem sie die Glaubwürdigkeit auf „Mittel“ setzen. Der .NET-Code-Sicherheitsmechanismus stellt sicher, dass das Programm keine Dateizugriffsrechte außerhalb des virtuellen Verzeichnisses hat, in dem es sich befindet.

Um die Vertrauensstufe einer Anwendung auf „Mittel“ zu setzen, können Sie Folgendes hinzufügen:

< Vertrauensstufe = „Mittel“ />

URL überprüfen

Sie können reguläre Ausdrücke wie die folgenden verwenden, um URLs abzugleichen

^(?: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})*$

Dies schränkt nur das Eingabeformat ein und überprüft nicht, ob es in der Anwendung im Rahmen Ihrer Anwendung akzeptabel ist. Sie sollten dies überprüfen Es ist beispielsweise im Kontext Ihrer Anwendung gültig. Kommuniziert Ihre Anwendung mit dem von Ihnen angegebenen Server.

Schritt 3. Codieren Sie unsicheren Code.

Wenn Sie Text in eine Webseite eingeben, verwenden Sie die Methode HttpUtility.HtmlEncode, um ihn zu codieren. Wenn der Text aus Benutzereingaben, einer Datenbank oder einer lokalen Datei stammt, tun Sie dies unbedingt.

Wenn Sie eine URL schreiben, die unsichere Zeichen enthält, weil diese aus Benutzereingabeinhalten, Datenbanken usw. stammen, verwenden Sie ebenfalls die HttpUtility.UrlEncode-Methode zum Kodieren.

Um eine Kodierung vor dem Speichern der Daten zu verhindern, die die gespeicherten Daten beschädigen könnte, achten Sie bitte darauf, sie bei der Anzeige so spät wie möglich zu kodieren.

Verwenden Sie HtmlEncode. Bei unsicherer Ausgabekodierung

ersetzt HtmlEncode HTML-Tags mit speziellen Textzeichenfolgen zur Darstellung dieser Symbole und verhindert, dass der Browser sie als HTML-Tags interpretiert. Beispielsweise wird „<“ durch „<“ (Doppelpunkt) ersetzt. Diese Tags werden als harmloser Text angezeigt.

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

Um den Effekt der HTML-Codierung zu sehen, erstellen Sie bitte ein virtuelles Verzeichnis und legen Sie die oben genannten Dateien darin ab, führen Sie diese Seite aus, geben Sie HTML-Code in das Textfeld ein und klicken Sie auf die Schaltfläche „Senden“. Die folgende Eingabe wird beispielsweise wie gewohnt angezeigt Text.

Führen Sie das Skript aus und sagen Sie Hallo <script>alert('hello');</script>

Wenn Sie den Aufruf der HtmlEncode-Methode entfernen und einfach den Textinhalt eingeben, führt der Browser den Code aus und öffnet ein Eingabeaufforderungsfeld.

Die Verwendung der UrlEncode-Methode ist nicht sicher. Kodieren der URL-Adresse

Wenn Sie die URL-Parameter mit dem Benutzereingabeteil abrufen müssen, was bestimmte Sicherheitsrisiken mit sich bringen kann, verwenden Sie die Methode HttpUtility.UrlEncode, um die Adresszeichenfolge zu kodieren

. ;

Schritt 4. Die SQL-Anweisung verwendet die Befehlsparametermethode,

um Injektionsangriffe zu vermeiden. Die Parametersammlung bietet eine Typerkennung und eine Längenerkennung Textwert, und die Datenbank wird nicht ausgeführt. Ein zusätzlicher Vorteil der Verwendung der Parametersatzmethode besteht darin, dass Sie den Typ und die Länge der Eingabe streng einschränken können

Beim Aufruf einer gespeicherten Prozedur

wird eine Ausnahme ausgelöst.

Verwenden Sie den

folgenden Parametersatz. Das Codefragment zeigt ein Beispiel für die Verwendung von Parametersätzen beim Aufruf einer gespeicherten Prozedur.

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

Verwenden Sie Parametersätze, wenn Sie Ihre eigenen SQL-Anweisungen erstellen.

Wenn Sie keine gespeicherten Prozeduren verwenden können, können Sie trotzdem Parametersätze verwenden, siehe den Code unten.

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

Weitere Informationen zum Verhindern von SQL-Injection-Angriffen finden Sie unter Vorgehensweise: Schutz vor SQL-Injection in ASP.NET,

Schritt 5. Um zu überprüfen, dass ASP.NET-Fehlermeldungen nicht an den Client zurückgegeben werden,

können Sie das Element <customErrors> verwenden . Um den Client zu konfigurieren, sollten vom Programmfehlererkennungsmechanismus allgemeine Fehlermeldungen zurückgegeben werden.

Bitte bestätigen Sie

dass Sie das Modusattribut in „remoteOnly“ geändert haben. Das Folgende ist ein Beispiel

„remoteOnly“>

Nach der Installation eines ASP.NET-Programms können Sie die Fehlermeldungsseite des Clients wie folgt angeben.

Weitere Ressourcen finden Sie in verwandten Themen:

So verwenden Sie reguläre Ausdrücke, um Eingaben in ASP.NET einzuschränken

und

Cross-Site-Scripting-Angriffe zu verhindern.

PS: Ich habe es endlich zu Ende gelesen. Es hat fast drei Tage gedauert. Tatsächlich sind diese Sätze sehr einfach. Dies ist das erste Mal, dass ich eine Übersetzung mache. Bitte verzeihen Sie mir, wenn die Übersetzung nicht gut ist. Vielen Dank.