Cómo validar que una cadena no contiene HTML utilizando C#

Question

¿Alguien tiene una manera simple y eficiente de verificar que una cadena no contenga HTML? Básicamente, quiero verificar que ciertos campos solo contengan texto sin formato. Pensé en buscar el carácter <, pero eso se puede usar fácilmente en texto plano. Otra forma podría ser la creación de un nuevo System.Xml.Linq.XElement usando:

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

y comprobar que el XElement no contiene elementos secundarios, pero esto parece un poco pesado para lo que necesito.

Answer 1

simplemente he intentado mi solución XElement.Parse. He creado un método de extensión de la clase string para que pueda volver a utilizar el código fácilmente:

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 problema que encontré fue que signo texto plano y menos de caracteres provocan un XmlException e indican que el campo contiene HTML (que es incorrecto). Para solucionar esto, la cadena de entrada que se pasa primero debe tener los signos de unión y menos de caracteres convertidos a sus entidades XHTML equivalentes.Escribí otro método de extensión para hacer eso:

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; 
} 

Ahora puede tomar una cadena enviado por el usuario y comprobar que no contiene HTML usando el siguiente código:

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

No estoy seguro si esto es a prueba de balas, pero creo que es lo suficientemente bueno para mi situación.

Answer 2

Lo siguiente coincidirá con cualquier conjunto de etiquetas coincidentes. es decir < b> esta </b>

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

El siguiente coincidirá con cualquier etiqueta única. es decir, < b> (no tiene que estar cerrado).

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

entonces Se puede utilizar como tal

bool hasTags = tagRegex.IsMatch(myString); 

Answer 3

Aquí van:

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

Esa es la forma más sencilla, ya que los elementos entre corchetes son poco probable que se produzca de forma natural.

Answer 4

Los soportes angulares pueden no ser su único desafío. Otros caracteres también pueden ser inyecciones de script potencialmente dañinas. Como el doble guión común "-", que también se puede usar en inyección SQL. Y hay otros.

En una página ASP.Net, si validateRequest = true en machine.config, web.config o la directiva de página, el usuario obtendrá una página de error que indica "Se detectó un valor potencialmente potencialmente peligroso Request.Form del cliente" si se detecta una etiqueta HTML u otros posibles ataques de inyección de scripts. Probablemente desee evitar esto y proporcionar una experiencia de IU más elegante y menos atemorizante.

Puede probar las etiquetas de apertura y cierre <> utilizando una expresión regular, y permitir el texto si solo aparece una de ellas. Permitir < o>, pero no < seguido de texto y luego>, en ese orden.

Puede permitir los corchetes angulares y HtmlEncode el texto para conservarlos cuando los datos se mantienen.

Answer 5

Puede garantizar el texto sin formato codificando la entrada usando HttpUtility.HtmlEncode.

De hecho, dependiendo del grado de rigurosidad desea que el cheque sea, se podría utilizar para determinar si la cadena contiene HTML:

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

Answer 6

Tenga cuidado al utilizar el método HttpUtility.HtmlEncode mencionado anteriormente. Si está verificando texto con caracteres especiales, pero no HTML, se evaluará incorrectamente. Tal vez es por eso que J c usó "... dependiendo de qué tan estricto quieras que sea el cheque ..."

Answer 7

esto también comprueba cosas como < br /> etiquetas autocerradas con espacios en blanco opcionales. la lista no contiene nuevas etiquetas 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"); 
    } 
}