it-swarm.com.de

Ein potenziell gefährlicher Request.QueryString-Wert wurde vom Client beim Senden von HTML-Markup vom jquery post-Aufruf an die asp.net-Seite festgestellt

Ich mache einen Ajax-Aufruf mit jQuery an eine ASP.NET-Seite, die als meine Ajax-Serverseite fungiert, um die Daten zu speichern, die ich in der Abfragezeichenfolge an sie sende. Wenn ich auf der ASP.NET-Seite versuche, den Querystring zu lesen, erhalte ich diese Fehlermeldung:

A potentially dangerous Request.QueryString value was detected from the client...

Ich habe den ValidateRequest="false" auf meiner Seite eingestellt. Ich möchte es nicht für alle Seiten festlegen. Also auf Seitenebene statt auf Konfigurationsebene:

  var content = "<h3>Sample header</h3><p>sample para</p>"
  content = encodeURIComponent(content);
  var url = "../Lib/ajaxhandler.aspx?mode=savecontent&page=home&ltxt=" + content;

     $.post(url, function (data) { 
       //check return value and do something
   });

und auf meiner asp.net-Seite:

 <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="ajaxhandler.aspx.cs" ValidateRequest="false" Inherits="MyProject.Lib.ajaxhandler" %>

Aber wenn ich statt des HTML-Markups Klartext sende, funktioniert das einwandfrei.

37
Shyju

Wenn dies ASP.NET 4 ist, gab es eine brechende Änderung mit ValidateRequest. Siehe diese StackOverflow-Frage für weitere Informationen zu requestValidationMode.

35

Hierfür gibt es bereits eine gute Antwort, und hier werde ich die Informationen bereitstellen, damit Sie nicht durch Links klicken müssen.

Wenn Sie ASP.NET 4.0 ausführen, müssen Sie Folgendes in Ihrer web.config-Datei RequestValidationMode="2.0" einstellen.

Wozu dient diese Eigenschaft?

Ein Wert, der angibt, welche Versionsspezifische Vorgehensweise von ASP.NET für .__ verwendet wird. Validierung wird verwendet. Der Standardwert ist 4.0.

Was sind die möglichen Werte?

  • 4.0 (Standardeinstellung). Das HttpRequest-Objekt setzt intern ein Flag, das angibt, dass die Anforderungsüberprüfung immer dann ausgelöst werden soll
    Auf HTTP-Anforderungsdaten wird zugegriffen. Dies garantiert, dass die Anfrage
    Die Validierung wird ausgelöst, bevor Daten wie Cookies und URLs angezeigt werden
    während der Anfrage aufgerufen. Die Anforderungsüberprüfungseinstellungen von
    pages Element (falls vorhanden) in der Konfigurationsdatei oder auf der @ Page
    Direktive auf einer einzelnen Seite werden ignoriert.

  • 2,0. Die Anforderungsüberprüfung ist nur für Seiten und nicht für alle HTTP-Anforderungen aktiviert. Darüber hinaus werden die Validierungseinstellungen für die Anforderung der Seiten Element (falls vorhanden) in der Konfigurationsdatei oder in der @ Page-Direktive In einer einzelnen Seite wird festgelegt, welche Seitenanforderungen an validieren. </ li> </ ul> Informationen von dieser Msdn-Site zitiert.

8
Jim Aho

Wenn Sie eine benutzerdefinierte Validierungslogik für eine bestimmte ASP.NET-Seite oder für einen oder mehrere Abfragezeichenfolgeparameter hinzufügen möchten, ohne ValidateRequest="false" für die gesamte Seite festzulegen, kann die folgende "hacky" -Lösung nützlich sein:

public partial class MyPage : System.Web.UI.Page
{
    private string SomeUnvalidatedValue { get; set; }

    public override void ProcessRequest(HttpContext context)
    {
        var queryString = context.Request.QueryString;

        var readOnly = queryString.GetType().GetProperty("IsReadOnly",
            System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

        readOnly.SetValue(queryString, false);

        var unvalidatedValue = context.Request.Unvalidated.QueryString["SomeKey"];
        // for RequestValidationMode="2.0"
        //var unvalidatedValue = context.Request.QueryString["SomeKey"];

        // custom logic goes here

        // you could store unvalidated value here and then remove it from the query string
        SomeUnvalidatedValue = unvalidatedValue;
        queryString["SomeKey"] = string.Empty;
        // or just remove all "potentially dangerous" symbols, for example
        if (!string.IsNullOrEmpty(unvalidatedValue))
        {
            queryString["SomeKey"] = Regex.Replace(unvalidatedValue,
                "(\\<+[a-z!/\\?])|(&\\#)", new MatchEvaluator((m) =>
                {
                    return m.Value.Replace("<", string.Empty).Replace("&#", string.Empty);
                }), RegexOptions.IgnoreCase);
        }

        readOnly.SetValue(queryString, true);

        // keep other request validation logic as is
        base.ProcessRequest(context);
    }
}

Der reguläre Ausdruck, der als Ergebnis dieser ASP.NET-Methode erstellt wird, wobei Folgendes analysiert wird: CrossSiteScriptingValidation.IsDangerousString

Mit .NET 4.5.2, integrierter Modus IIS getesteter Code, mit und ohne RequestValidationMode="2.0".

2
VAV

Ich habe ein paar wiederverwendbare Methoden erstellt, basierend auf VAVs Antwort

   public static string ExtractUnvalidatedValue(HttpRequest request, string key)
        {
            var unvalidatedValue =  HttpUtility.UrlDecode(request.Unvalidated.QueryString[key]);
            // for RequestValidationMode="2.0"
            //var unvalidatedValue = context.Request.QueryString["SomeKey"];

          // remove all "potentially dangerous" symbols
            return ReplacePotentiallyDangerousSymbols(unvalidatedValue, string.Empty);
        }

    public static string ReplacePotentiallyDangerousSymbols(string unvalidatedValue, string valueToReplace="")
        {
            if (!string.IsNullOrEmpty(unvalidatedValue))
            {
                //The regular expression made as result of this ASP.NET method analyzing: CrossSiteScriptingValidation.IsDangerousString http://referencesource.Microsoft.com/#System.Web/CrossSiteScriptingValidation.cs,3c599cea73c5293b
                unvalidatedValue = Regex.Replace(unvalidatedValue,
                    "(\\<+[a-z!/\\?])|(&\\#)",
                    new MatchEvaluator((m) => { return m.Value.Replace("<", valueToReplace).Replace("&#", valueToReplace); }), RegexOptions.IgnoreCase);
            }
            return unvalidatedValue;
        }
1