Comment valider qu'une chaîne ne contient pas de code HTML en utilisant C#

Question

Est-ce que quelqu'un a un moyen simple et efficace de vérifier qu'une chaîne ne contient pas de code HTML? Fondamentalement, je veux vérifier que certains champs contiennent uniquement du texte brut. J'ai pensé à la recherche du caractère <, mais cela peut facilement être utilisé en texte brut. Une autre façon peut-être de créer une nouvelle System.Xml.Linq.XElement en utilisant:

XElement.Parse("<wrapper>" + MyString + "</wrapper>") 

et vérifiez que le XElement ne contient aucun élément enfant, mais cela semble un peu lourd pour ce que je dois.

Answer 1

Je viens d'essayer ma solution XElement.Parse. J'ai créé une méthode d'extension de la classe de chaîne pour que je puisse réutiliser le code facilement:

public static bool ContainsXHTML(this string input) 
{ 
    try 
    { 
     XElement x = XElement.Parse("<wrapper>" + input + "</wrapper>"); 
     return !(x.DescendantNodes().Count() == 1 && x.DescendantNodes().First().NodeType == XmlNodeType.Text); 
    } 
    catch (XmlException ex) 
    { 
     return true; 
    } 
} 

Un problème que j'ai trouvé que esperluette texte brut et moins de caractères provoquent une XmlException et indiquent que le champ contient HTML (qui est faux). Pour corriger cela, la chaîne d'entrée transmise en premier doit avoir les esperluettes et moins que les caractères convertis en leurs entités XHTML équivalentes.J'ai écrit une autre méthode d'extension pour le faire:

public static string ConvertXHTMLEntities(this string input) 
{ 
    // Convert all ampersands to the ampersand entity. 
    string output = input; 
    output = output.Replace("&", "amp_token"); 
    output = output.Replace("&", "&"); 
    output = output.Replace("amp_token", "&"); 

    // Convert less than to the less than entity (without messing up tags). 
    output = output.Replace("< ", "&lt; "); 
    return output; 
} 

Maintenant, je peux prendre une chaîne fournie par l'utilisateur et vérifier qu'il ne contient pas de HTML en utilisant le code suivant:

bool ContainsHTML = UserEnteredString.ConvertXHTMLEntities().ContainsXHTML(); 

Je ne suis pas sûr si c'est une preuve de balle, mais je pense que c'est assez bon pour ma situation.

Answer 2

Ce qui suit correspond à tout ensemble de balises correspondant. à savoir < b> </b>

Regex tagRegex = new Regex(@"<\s*([^ >]+)[^>]*>.*?<\s*/\s*\1\s*>"); 

Ce qui suit correspond à aucun tag unique. c'est-à-dire < b> (il ne doit pas être fermé).

Regex tagRegex = new Regex(@"<[^>]+>"); 

Vous pouvez alors l'utiliser comme si

bool hasTags = tagRegex.IsMatch(myString); 

Answer 3

Ici, vous allez:

using System.Text.RegularExpressions; 
private bool ContainsHTML(string CheckString) 
{ 
    return Regex.IsMatch(CheckString, "<(.|\n)*?>"); 
} 

C'est la façon la plus simple, puisque les éléments entre crochets ne sont pas susceptibles de se produire naturellement.

Answer 4

Les cornières ne sont peut-être pas votre seul défi. D'autres caractères peuvent également être une injection de script potentiellement dangereux. Tels que le double trait d'union commun "-", qui peut également être utilisé dans l'injection SQL. Et il y en a d'autres.

Sur une page ASP.Net, si validateRequest = true dans machine.config, web.config ou la directive page, l'utilisateur recevra une page d'erreur indiquant "Une valeur Request.Form potentiellement dangereuse a été détectée sur le client" si une balise HTML ou d'autres attaques potentielles par injection de script sont détectées. Vous voulez probablement éviter cela et offrir une expérience d'interface utilisateur plus élégante et moins effrayante.

Vous pouvez tester les balises d'ouverture et de fermeture <> en utilisant une expression régulière, et autoriser le texte si un seul d'entre eux se produit. Autoriser < ou>, mais pas < suivi d'un texte, puis>, dans cet ordre.

Vous pouvez autoriser des chevrons et HtmlEncode le texte pour les conserver lorsque les données sont conservées.

Answer 5

Vous pouvez vous assurer du texte brut en codant l'entrée en utilisant HttpUtility.HtmlEncode.

En fait, selon la stricte que vous voulez que le chèque soit, vous pouvez l'utiliser pour déterminer si la chaîne contient HTML:

bool containsHTML = (myString != HttpUtility.HtmlEncode(myString)); 

Answer 6

Prenez garde lors de l'utilisation de la méthode HttpUtility.HtmlEncode mentionnée ci-dessus. Si vous vérifiez du texte avec des caractères spéciaux, mais pas HTML, il évaluera incorrectement. Peut-être est-ce la raison pour laquelle J c a utilisé "... selon la rigueur que vous voulez que la vérification soit ..."

Answer 7

Ceci vérifie aussi des choses comme < br /> étiquettes auto-jointes avec espace blanc optionnel. la liste ne contient pas de nouvelles balises html5.

internal static class HtmlExts 
{ 
    public static bool containsHtmlTag(this string text, string tag) 
    { 
     var pattern = @"<\s*" + tag + @"\s*\/?>"; 
     return Regex.IsMatch(text, pattern, RegexOptions.IgnoreCase); 
    } 

    public static bool containsHtmlTags(this string text, string tags) 
    { 
     var ba = tags.Split('|').Select(x => new {tag = x, hastag = text.containsHtmlTag(x)}).Where(x => x.hastag); 

     return ba.Count() > 0; 
    } 

    public static bool containsHtmlTags(this string text) 
    { 
     return 
      text.containsHtmlTags(
       "a|abbr|acronym|address|area|b|base|bdo|big|blockquote|body|br|button|caption|cite|code|col|colgroup|dd|del|dfn|div|dl|DOCTYPE|dt|em|fieldset|form|h1|h2|h3|h4|h5|h6|head|html|hr|i|img|input|ins|kbd|label|legend|li|link|map|meta|noscript|object|ol|optgroup|option|p|param|pre|q|samp|script|select|small|span|strong|style|sub|sup|table|tbody|td|textarea|tfoot|th|thead|title|tr|tt|ul|var"); 
    } 
}