¿Hay alguna manera en C # para ver si una cadena está codificada en Base 64, aparte de tratar de convertirla y ver si hay un error? Tengo un código de código como este:

// Convert base64-encoded hash value into a byte array.
byte[] HashBytes = Convert.FromBase64String(Value);

Quiero evitar la excepción "Carácter inválido en una cadena Base-64" que ocurre si el valor no es una cadena base 64 válida. Solo quiero verificar y devolver falso en lugar de manejar una excepción porque espero que a veces este valor no sea una cadena base 64. ¿Hay alguna forma de verificar antes de usar la función Convert.FromBase64String?

¡Gracias!

Actualización:
Gracias por todas sus respuestas. Aquí hay un método de extensión que todos pueden usar hasta ahora, parece asegurarse de que su cadena pasará Convert.FromBase64String sin una excepción. .NET parece ignorar todos los espacios finales y finales al convertir a base 64, por lo que "1234" es válido y también "1234"

public static bool IsBase64String(this string s)
{
    s = s.Trim();
    return (s.Length % 4 == 0) && Regex.IsMatch(s, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);

}

Para aquellos que se preguntan sobre el rendimiento de las pruebas frente a la captura y la excepción, en la mayoría de los casos para esta cosa de base 64 es más rápido verificar que detectar la excepción hasta que alcance una cierta longitud. Cuanto menor es la longitud, más rápido es

En mis pruebas muy poco científicas: para 10000 iteraciones para la longitud de caracteres 100,000 - 110000, fue 2,7 veces más rápido probar primero.

Para 1000 iteraciones para caracteres de longitud 1 - 16 caracteres para un total de 16,000 pruebas, fue 10.9 veces más rápido.

Estoy seguro de que hay un punto en el que es mejor probar con el método basado en excepciones. Simplemente no sé en qué punto es eso.

Es bastante fácil reconocer una cadena Base64, ya que solo estará compuesta de caracteres 'A'..'Z', 'a'..'z', '0'..'9', '+', '/'y a menudo se rellena al final con hasta tres '=', para hacer que la longitud sea múltiplo de 4. Pero en lugar de compararlos, usted ' Sería mejor ignorar la excepción, si ocurre.

Use Convert. tryFromBase64String desde C # 7.2

public static bool IsBase64String(string base64)
{
   Span<byte> buffer = new Span<byte>(new byte[base64.Length]);
   return Convert.TryFromBase64String(base64, buffer , out int bytesParsed);
}

Sé que dijiste que no querías atrapar una excepción. Pero, dado que detectar una excepción es más confiable, seguiré adelante y publicaré esta respuesta.

public static bool IsBase64(this string base64String) {
     // Credit: oybek https://stackoverflow.com/users/794764/oybek
     if (string.IsNullOrEmpty(base64String) || base64String.Length % 4 != 0
        || base64String.Contains(" ") || base64String.Contains("\t") || base64String.Contains("\r") || base64String.Contains("\n"))
        return false;

     try{
         Convert.FromBase64String(base64String);
         return true;
     }
     catch(Exception exception){
     // Handle the exception
     }
     return false;
}

Actualización: He actualizado la condición gracias a oybek para mejorar aún más la confiabilidad.

Creo que la expresión regular debería ser:

    Regex.IsMatch(s, @"^[a-zA-Z0-9\+/]*={0,2}$")

Solo coincide con uno o dos signos '=' finales, no con tres.

sdebe ser la cadena que se verificará. Regexes parte del System.Text.RegularExpressionsespacio de nombres.

¿Por qué no capturar la excepción y devolver False?

Esto evita gastos generales adicionales en el caso común.

Solo en aras de la integridad, quiero proporcionar alguna implementación. En términos generales, Regex es un enfoque costoso, especialmente si la cadena es grande (lo que sucede al transferir archivos grandes). El siguiente enfoque intenta primero las formas más rápidas de detección.

public static class HelperExtensions {
    // Characters that are used in base64 strings.
    private static Char[] Base64Chars = new[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
    /// <summary>
    /// Extension method to test whether the value is a base64 string
    /// </summary>
    /// <param name="value">Value to test</param>
    /// <returns>Boolean value, true if the string is base64, otherwise false</returns>
    public static Boolean IsBase64String(this String value) {

        // The quickest test. If the value is null or is equal to 0 it is not base64
        // Base64 string's length is always divisible by four, i.e. 8, 16, 20 etc. 
        // If it is not you can return false. Quite effective
        // Further, if it meets the above criterias, then test for spaces.
        // If it contains spaces, it is not base64
        if (value == null || value.Length == 0 || value.Length % 4 != 0
            || value.Contains(' ') || value.Contains('\t') || value.Contains('\r') || value.Contains('\n'))
            return false;

        // 98% of all non base64 values are invalidated by this time.
        var index = value.Length - 1;

        // if there is padding step back
        if (value[index] == '=')
            index--;

        // if there are two padding chars step back a second time
        if (value[index] == '=')
            index--;

        // Now traverse over characters
        // You should note that I'm not creating any copy of the existing strings, 
        // assuming that they may be quite large
        for (var i = 0; i <= index; i++) 
            // If any of the character is not from the allowed list
            if (!Base64Chars.Contains(value[i]))
                // return false
                return false;

        // If we got here, then the value is a valid base64 string
        return true;
    }
}

EDITAR

Según lo sugerido por Sam , también puede cambiar ligeramente el código fuente. Proporciona un enfoque de mejor desempeño para el último paso de las pruebas. La rutina

    private static Boolean IsInvalid(char value) {
        var intValue = (Int32)value;

        // 1 - 9
        if (intValue >= 48 && intValue <= 57) 
            return false;

        // A - Z
        if (intValue >= 65 && intValue <= 90) 
            return false;

        // a - z
        if (intValue >= 97 && intValue <= 122) 
            return false;

        // + or /
        return intValue != 43 && intValue != 47;
    } 

se puede usar para reemplazar la if (!Base64Chars.Contains(value[i]))línea conif (IsInvalid(value[i]))

El código fuente completo con mejoras de Sam se verá así (comentarios eliminados para mayor claridad)

public static class HelperExtensions {
    public static Boolean IsBase64String(this String value) {
        if (value == null || value.Length == 0 || value.Length % 4 != 0
            || value.Contains(' ') || value.Contains('\t') || value.Contains('\r') || value.Contains('\n'))
            return false;
        var index = value.Length - 1;
        if (value[index] == '=')
            index--;
        if (value[index] == '=')
            index--;
        for (var i = 0; i <= index; i++)
            if (IsInvalid(value[i]))
                return false;
        return true;
    }
    // Make it private as there is the name makes no sense for an outside caller
    private static Boolean IsInvalid(char value) {
        var intValue = (Int32)value;
        if (intValue >= 48 && intValue <= 57)
            return false;
        if (intValue >= 65 && intValue <= 90)
            return false;
        if (intValue >= 97 && intValue <= 122)
            return false;
        return intValue != 43 && intValue != 47;
    }
}

La respuesta debe depender del uso de la cadena. Hay muchas cadenas que pueden ser "base64 válida" de acuerdo con la sintaxis sugerida por varios carteles, pero que pueden decodificar "correctamente", sin excepción, la basura. Ejemplo: la cadena 8char Portlandes válida Base64. ¿Cuál es el punto de afirmar que esto es válido Base64? Supongo que en algún momento querrás saber que esta cadena debería o no ser decodificada en Base64.

En mi caso, tengo cadenas de conexión Oracle que pueden estar en texto plano como:

Data source=mydb/DBNAME;User Id=Roland;Password=.....`

o en base64 como

VXNlciBJZD1sa.....................................==

Solo tengo que verificar la presencia de un punto y coma, porque eso prueba que NO es base64, que por supuesto es más rápido que cualquier método anterior.

Knibb High reglas de fútbol!

Esto debería ser relativamente rápido y preciso, pero admito que no lo sometí a una prueba exhaustiva, solo algunas.

Evita excepciones costosas, expresiones regulares, y también evita recorrer un conjunto de caracteres, en su lugar utiliza rangos ascii para la validación.

public static bool IsBase64String(string s)
    {
        s = s.Trim();
        int mod4 = s.Length % 4;
        if(mod4!=0){
            return false;
        }
        int i=0;
        bool checkPadding = false;
        int paddingCount = 1;//only applies when the first is encountered.
        for(i=0;i<s.Length;i++){
            char c = s[i];
            if (checkPadding)
            {
                if (c != '=')
                {
                    return false;
                }
                paddingCount++;
                if (paddingCount > 3)
                {
                    return false;
                }
                continue;
            }
            if(c>='A' && c<='z' || c>='0' && c<='9'){
                continue;
            }
            switch(c){ 
              case '+':
              case '/':
                 continue;
              case '=': 
                 checkPadding = true;
                 continue;
            }
            return false;
        }
        //if here
        //, length was correct
        //, there were no invalid characters
        //, padding was correct
        return true;
    }

public static bool IsBase64String1(string value)
        {
            if (string.IsNullOrEmpty(value))
            {
                return false;
            }
            try
            {
                Convert.FromBase64String(value);
                if (value.EndsWith("="))
                {
                    value = value.Trim();
                    int mod4 = value.Length % 4;
                    if (mod4 != 0)
                    {
                        return false;
                    }
                    return true;
                }
                else
                {

                    return false;
                }
            }
            catch (FormatException)
            {
                return false;
            }
        }

Usaré así para no tener que volver a llamar al método de conversión.

   public static bool IsBase64(this string base64String,out byte[] bytes)
    {
        bytes = null;
        // Credit: oybek http://stackoverflow.com/users/794764/oybek
        if (string.IsNullOrEmpty(base64String) || base64String.Length % 4 != 0
           || base64String.Contains(" ") || base64String.Contains("\t") || base64String.Contains("\r") || base64String.Contains("\n"))
            return false;

        try
        {
             bytes=Convert.FromBase64String(base64String);
            return true;
        }
        catch (Exception)
        {
            // Handle the exception
        }

        return false;
    }

Decodifique, vuelva a codificar y compare el resultado con la cadena original

public static Boolean IsBase64(this String str)
{
    if ((str.Length % 4) != 0)
    {
        return false;
    }

    //decode - encode and compare
    try
    {
        string decoded = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String(str));
        string encoded = System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(decoded));
        if (str.Equals(encoded, StringComparison.InvariantCultureIgnoreCase))
        {
            return true;
        }
    }
    catch { }
    return false;
}

En mi humilde opinión esto no es realmente posible. Todas las soluciones publicadas fallan para cadenas como "prueba", etc. Si pueden dividirse entre 4, no son nulos o están vacíos, y si son un carácter base64 válido, pasarán todas las pruebas. Eso puede ser muchas cadenas ...

Por lo tanto, no hay una solución real que no sea saber que esta es una cadena codificada en base 64 . Lo que se me ocurrió es esto:

if (base64DecodedString.StartsWith("<xml>")
{
    // This was really a base64 encoded string I was expecting. Yippie!
}
else
{
    // This is gibberish.
}

Espero que la cadena decodificada comience con una determinada estructura, así que verifico eso.

Por supuesto. Sólo asegúrese de que cada personaje está dentro a-z, A-Z, 0-9, /, o +, y los extremos de cadena con ==. (Al menos, esa es la implementación de Base64 más común. Es posible que encuentre algunas implementaciones que usan caracteres diferentes /o +para los dos últimos caracteres).

Sí, dado que Base64 codifica datos binarios en cadenas ASCII utilizando un conjunto limitado de caracteres, simplemente puede verificarlo con esta expresión regular:

/ ^ [A-Za-z0-9 \ = \ + \ / \ s \ n] + $ / s

lo que asegurará que la cadena solo contenga AZ, az, 0-9, '+', '/', '=' y espacios en blanco.

Sugeriría crear una expresión regular para hacer el trabajo. Tendrá que verificar algo como esto: [a-zA-Z0-9 + / =] También deberá verificar la longitud de la cadena. No estoy seguro de esto, pero estoy bastante seguro de que si algo se recorta (aparte del relleno "=") explotaría.

O mejor aún, mira esta pregunta de stackoverflow

Acabo de tener un requisito muy similar en el que dejo que el usuario realice alguna manipulación de imagen en un <canvas>elemento y luego envíe la imagen resultante recuperada .toDataURL()al backend. Quería hacer una validación del servidor antes de guardar la imagen y he implementado un ValidationAttributeuso del código de otras respuestas:

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class Bae64PngImageAttribute : ValidationAttribute
{
    public override bool IsValid(object value)
    {
        if (value == null || string.IsNullOrWhiteSpace(value as string))
            return true; // not concerned with whether or not this field is required
        var base64string = (value as string).Trim();

        // we are expecting a URL type string
        if (!base64string.StartsWith("data:image/png;base64,"))
            return false;

        base64string = base64string.Substring("data:image/png;base64,".Length);

        // match length and regular expression
        if (base64string.Length % 4 != 0 || !Regex.IsMatch(base64string, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None))
            return false;

        // finally, try to convert it to a byte array and catch exceptions
        try
        {
            byte[] converted = Convert.FromBase64String(base64string);
            return true;
        }
        catch(Exception)
        {
            return false;
        }
    }
}

Como puede ver, estoy esperando una cadena de tipo imagen / png, que es el valor predeterminado que se devuelve <canvas>al usar .toDataURL().

Verifique Base64 o cadena normal

public bool IsBase64Encoded (String str)

{

try

{
    // If no exception is caught, then it is possibly a base64 encoded string
    byte[] data = Convert.FromBase64String(str);
    // The part that checks if the string was properly padded to the
    // correct length was borrowed from d@anish's solution
    return (str.Replace(" ","").Length % 4 == 0);
}
catch
{
    // If exception is caught, then it is not a base64 encoded string
   return false;
}

}

Todas las respuestas fueron digeridas en 1 función que garantiza al 100% que sus resultados serán precisos.

1) Use la función de la siguiente manera:

    string encoded = "WW91ckJhc2U2NHN0cmluZw==";
    msgbox("Is string base64=" + IsBase64(encoded));

2) A continuación se muestra la función:

  public bool IsBase64(string base64String)
    {
        try
        {
            if (!base64String.Length < 1)
            {
                if (!base64String.Equals(Convert.ToBase64String(Encoding.UTF8.GetBytes(Encoding.UTF8.GetString(Convert.FromBase64String(base64String)))), StringComparison.InvariantCultureIgnoreCase) & !System.Text.RegularExpressions.Regex.IsMatch(base64String, @"^[a-zA-Z0-9\+/]*={0,2}$"))
                {
                    return false;
                    return;
                }
                if ((base64String.Length % 4) != 0 || string.IsNullOrEmpty(base64String) || base64String.Length % 4 != 0 || base64String.Contains(" ") || base64String.Contains(Constants.vbTab) || base64String.Contains(Constants.vbCr) || base64String.Contains(Constants.vbLf))
                {
                    return false;
                    return;
                }
            }
            else
            {
                return false;
                return;
            }

            return true;
            return;
        }
        catch (FormatException ex)
        {
            return false;
            return;
        }
    }

Me gusta la idea de un cheque de expresión regular. Las expresiones regulares pueden ser rápidas y a veces ahorran la sobrecarga de codificación. La consulta original, tenía una actualización que hizo justamente esto. Sin embargo, encuentro que nunca puedo asumir que las cadenas no serían nulas. Expandiría la función de Extensión para verificar que la cadena de origen no contenga caracteres nulos o en blanco.

    public static bool IsBase64String(this string s)
    {
        if (string.IsNullOrWhiteSpace(s))
            return false;

        s = s.Trim();
        return (s.Length % 4 == 0) && Regex.IsMatch(s, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);

    }