validationmessagefor - substring c#

Cómo validar que una cadena no contiene HTML usando 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 <personaje, pero eso se puede usar fácilmente en texto plano. Otra forma podría ser crear un nuevo System.Xml.Linq.XElement usando:

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

y verifique que XElement no contenga elementos secundarios, pero esto parece un poco pesado para lo que necesito.

Answer 1

esto también verifica cosas como <br /> etiquetas autoencerradas 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");
    }
}

Answer 2

Aqui tienes:

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

Esa es la forma más simple, ya que es poco probable que los elementos entre paréntesis ocurran de forma natural.

Answer 3

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

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

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

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

Puedes usarlo así

bool hasTags = tagRegex.IsMatch(myString);

Answer 4

Los corchetes 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 Request.Form potencialmente peligroso desde el cliente" si una etiqueta HTML o se detectan 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 <> usando una expresión regular, y permitir el texto si solo aparece una de ellas. Permitir <o>, pero no <seguido de un texto y luego>, en ese orden.

Podría permitir los corchetes angulares y HtmlEncode el texto para conservarlos cuando los datos se conservan.

Answer 5

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

Answer 6

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

De hecho, dependiendo de cuán estricto desee que sea el cheque, podría usarlo para determinar si la cadena contiene HTML:

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

Answer 7

Acabo de probar mi solución XElement.Parse. Creé un método de extensión en la clase de cadena para poder reutilizar 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 el ampersand de texto plano y menos de caracteres causa una XmlException e indica 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 puedo tomar una cadena enviada por el usuario y verificar que no contenga 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.