online - Cómo comprobar si la cadena está codificada en base64 o no

no se puede decodificar el base64

Question

Quiero decodificar la cadena codificada en base64 y luego almacenarla en mi base de datos. Si la entrada no codifica base64, necesita lanzar un error. ¿Cómo puedo verificar si la cadena fue codificada en base6464?

Answer 1

/ ^ ([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 el base64 en mi aplicación en rieles, solo tuve un problema, es que reconoce la cadena "errorDescripcion", genero un error, para solucionarlo solo valido el largo de la cadena.

Answer 2

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

String someString = "...";
Base64.Decoder decoder = Base64.getDecoder();
try {
decoder.decode(someString);
} catch(IllegalArgumentException iae) {
// That string wasn''t valid.
}

Answer 3

Bien tu puedes:

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

Si está esperando que sea base64, entonces probablemente solo pueda usar la biblioteca que esté disponible en su plataforma para intentar decodificarla en una matriz de bytes, lanzando una excepción si no es una base 64 válida. Eso depende de su plataforma, por supuesto.

Answer 4

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

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

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

Answer 5

Este fragmento puede ser útil cuando conoces la longitud del contenido original (por ejemplo, una suma de comprobació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() ;
}

Answer 6

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)

Answer 7

Hay muchas variantes de Base64 , así que considere determinar si su cadena se parece a la varient que espera manejar. Como tal, es posible que deba ajustar la expresión regular a continuación con respecto a los caracteres índice y 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?

Answer 8

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

Answer 9

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

Answer 10

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

Answer 11

Pruebe esto usando una expresión regular previamente mencionada:

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

Answer 12

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+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$

En la codificación base64, el conjunto de caracteres es [AZ, az, 0-9, and + /] . Si la longitud del resto es menor que 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 la cuerda termina en una de tres formas: [A-Za-z0-9+/]{4} , [A-Za-z0-9+/]{3}= o [A-Za-z0-9+/]{2}== .

Answer 13

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

Por ejemplo, trabajo con archivos xml codificados en base64 y solo compruebo si el archivo contiene marcas XML válidas. Si no lo hago, puedo suponer que está decodificado en base64. Esto no es muy dinámico, pero funciona bien para mi pequeña aplicación.

Answer 14

Si está utilizando Java, puede usar la biblioteca commons-codec

import org.apache.commons.codec.binary.Base64;
String stringToBeChecked = "...";
boolean isBase64 = Base64.isArrayByteBase64(stringToBeChecked.getBytes());

Answer 15

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

Answer 16

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