Cómo verificar si una cadena tiene codificación Base64 o no

Quiero decodificar una cadena codificada en Base64 y luego almacenarla en mi base de datos. Si la entrada no está codificada en Base64, necesito lanzar un error.

¿Cómo puedo verificar si una cadena está codificada en Base64?

Puede usar la siguiente expresión regular para verificar si una cadena está codificada en base64 o no:

^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$

En la codificación base64, el conjunto de caracteres es [A-Z, a-z, 0-9, and + /]. Si la longitud restante es inferior a 4, la cadena se rellena con '='caracteres.

^([A-Za-z0-9+/]{4})* significa que la cadena comienza con 0 o más grupos base64.

([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$significa que los extremos de cadena en una de tres formas: [A-Za-z0-9+/]{4}, [A-Za-z0-9+/]{3}=o [A-Za-z0-9+/]{2}==.

Si está utilizando Java, en realidad puede usar la biblioteca de códec commons

import org.apache.commons.codec.binary.Base64;

String stringToBeChecked = "...";
boolean isBase64 = Base64.isArrayByteBase64(stringToBeChecked.getBytes());

Bien tu puedes:

• Compruebe que la longitud es un múltiplo de 4 caracteres.
• Verifique que cada carácter esté en el conjunto AZ, az, 0-9, +, / excepto el relleno al final que es 0, 1 o 2 caracteres '='

Si usted está esperando que va a ser base 64, entonces probablemente puede utilizar cualquier biblioteca está disponible en su plataforma para tratar de decodificar a una matriz de bytes, lanzar una excepción si no es válido para la base 64. Eso depende de la plataforma, por supuesto.

A partir de Java 8, simplemente puede usar java.util.Base64 para intentar decodificar la cadena:

String someString = "...";
Base64.Decoder decoder = Base64.getDecoder();

try {
    decoder.decode(someString);
} catch(IllegalArgumentException iae) {
    // That string wasn't valid.
}

Prueba así para PHP5

//where $json is some data that can be base64 encoded
$json=some_data;

//this will check whether data is base64 encoded or not
if (base64_decode($json, true) == true)
{          
   echo "base64 encoded";          
}
else 
{
   echo "not base64 encoded"; 
}

Use esto para PHP7

 //$string parameter can be base64 encoded or not

function is_base64_encoded($string){
 //this will check if $string is base64 encoded and return true, if it is.
 if (base64_decode($string, true) !== false){          
   return true;        
 }else{
   return false;
 }
}

var base64Rejex = /^(?:[A-Z0-9+\/]{4})*(?:[A-Z0-9+\/]{2}==|[A-Z0-9+\/]{3}=|[A-Z0-9+\/]{4})$/i;
var isBase64Valid = base64Rejex.test(base64Data); // base64Data is the base64 string

if (isBase64Valid) {
    // true if base64 formate
    console.log('It is base64');
} else {
    // false if not in base64 formate
    console.log('it is not in base64');
}

Compruebe SI longitud de la cadena es un múltiplo de 4. Aftwerwards utilizar esta expresión regular para asegurarse de que todos los caracteres de la cadena son base64 caracteres.

\A[a-zA-Z\d\/+]+={,2}\z

Si la biblioteca que usa agrega una nueva línea como una forma de observar los 76 caracteres máximos por regla de línea, reemplácelos con cadenas vacías.

Hay muchas variantes de Base64 , por lo tanto, considere determinar si su cadena se parece a la variante que espera manejar. Como tal, es posible que tenga que ajustar la expresión regular a continuación con respecto a los caracteres de índice y de relleno (es decir +, /, =).

class String
  def resembles_base64?
    self.length % 4 == 0 && self =~ /^[A-Za-z0-9+\/=]+\Z/
  end
end

Uso:

raise 'the string does not resemble Base64' unless my_string.resembles_base64?

Prueba esto:

public void checkForEncode(String string) {
    String pattern = "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$";
    Pattern r = Pattern.compile(pattern);
    Matcher m = r.matcher(string);
    if (m.find()) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }
}

Es imposible verificar si una cadena está codificada en base64 o no. Solo es posible validar si esa cadena es de un formato de cadena codificada en base64, lo que significa que podría ser una cadena producida por la codificación base64 (para verificar que la cadena podría validarse contra una expresión regular o se podría usar una biblioteca, muchas otras respuestas a esta pregunta proporcionan buenas formas de verificar esto, por lo que no entraré en detalles).

Por ejemplo, la cadena flowes una cadena codificada en base64 válida. Pero es imposible saber si es solo una cadena simple, una palabra en inglés flowo si es una cadena codificada en base 64~Z0

/^([A-Za-z0-9+\/]{4})*([A-Za-z0-9+\/]{4}|[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)$/

esta expresión regular me ayudó a identificar la base64 en mi aplicación en rails, solo tuve un problema, es que reconoce la cadena "errorDescripcion", genero un error, para resolverlo solo validar la longitud de una cadena.

Esto funciona en Python:

import base64

def IsBase64(str):
    try:
        base64.b64decode(str)
        return True
    except Exception as e:
        return False

if IsBase64("ABC"):
    print("ABC is Base64-encoded and its result after decoding is: " + str(base64.b64decode("ABC")).replace("b'", "").replace("'", ""))
else:
    print("ABC is NOT Base64-encoded.")

if IsBase64("QUJD"):
    print("QUJD is Base64-encoded and its result after decoding is: " + str(base64.b64decode("QUJD")).replace("b'", "").replace("'", ""))
else:
    print("QUJD is NOT Base64-encoded.")

Resumen: IsBase64("string here") devuelve verdadero si string hereestá codificado en Base64, y devuelve falso si string hereNO fue codificado en Base64.

C # Esto está funcionando muy bien:

static readonly Regex _base64RegexPattern = new Regex(BASE64_REGEX_STRING, RegexOptions.Compiled);

private const String BASE64_REGEX_STRING = @"^[a-zA-Z0-9\+/]*={0,3}$";

private static bool IsBase64(this String base64String)
{
    var rs = (!string.IsNullOrEmpty(base64String) && !string.IsNullOrWhiteSpace(base64String) && base64String.Length != 0 && base64String.Length % 4 == 0 && !base64String.Contains(" ") && !base64String.Contains("\t") && !base64String.Contains("\r") && !base64String.Contains("\n")) && (base64String.Length % 4 == 0 && _base64RegexPattern.Match(base64String, 0).Success);
    return rs;
}

No hay forma de codificar una cadena distinta y una base64, excepto que la cadena en su sistema tiene alguna limitación o identificación específica.

Este fragmento puede ser útil cuando conoce la longitud del contenido original (por ejemplo, una suma de verificación). Comprueba que la forma codificada tiene la longitud correcta.

public static boolean isValidBase64( final int initialLength, final String string ) {
  final int padding ;
  final String regexEnd ;
  switch( ( initialLength ) % 3 ) {
    case 1 :
      padding = 2 ;
      regexEnd = "==" ;
      break ;
    case 2 :
      padding = 1 ;
      regexEnd = "=" ;
      break ;
    default :
      padding = 0 ;
      regexEnd = "" ;
  }
  final int encodedLength = ( ( ( initialLength / 3 ) + ( padding > 0 ? 1 : 0 ) ) * 4 ) ;
  final String regex = "[a-zA-Z0-9/\\+]{" + ( encodedLength - padding ) + "}" + regexEnd ;
  return Pattern.compile( regex ).matcher( string ).matches() ;
}

Si el RegEx no funciona y conoce el estilo de formato de la cadena original, puede revertir la lógica, regexing para este formato.

Por ejemplo, trabajo con archivos xml codificados en base64 y solo verifico si el archivo contiene un marcado xml válido. Si no es así, puedo suponer que es decodificado en base64. Esto no es muy dinámico, pero funciona bien para mi pequeña aplicación.

Esto funciona en Python:

def is_base64(string):
    if len(string) % 4 == 0 and re.test('^[A-Za-z0-9+\/=]+\Z', string):
        return(True)
    else:
        return(False)

Pruebe esto usando una expresión regular mencionada anteriormente:

String regex = "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$";
if("TXkgdGVzdCBzdHJpbmc/".matches(regex)){
    System.out.println("it's a Base64");
}

... También podemos hacer una validación simple como, si tiene espacios, no puede ser Base64:

String myString = "Hello World";
 if(myString.contains(" ")){
   System.out.println("Not B64");
 }else{
    System.out.println("Could be B64 encoded, since it has no spaces");
 }

si al decodificar obtenemos una cadena con caracteres ASCII, entonces la cadena no fue codificada

(RoR) solución de rubí:

def encoded?(str)
  Base64.decode64(str.downcase).scan(/[^[:ascii:]]/).count.zero?
end

def decoded?(str)
  Base64.decode64(str.downcase).scan(/[^[:ascii:]]/).count > 0
end

Intento usar esto, sí, este está funcionando

^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$

pero agregué la condición para verificar que al menos el final del carácter sea =

string.lastIndexOf("=") >= 0