online - Descodificación de cadenas Java BASE64 utf8

java.util.base64 jar

Question

Estoy usando org.apache.commons.codec.binary.Base64 do decode cadena que es utf8. A veces obtengo una cadena codificada en base64 que después de la decodificación parece, por ejemplo, ^@k��@@ . ¿Cómo puedo verificar si base64 es correcto o si la cadena utf8 decodificada es una cadena utf8 válida?

Para aclarar. Estoy usando

public static String base64Decode(String str) {
try {
return new String(base64Decode(str.getBytes(Constants.UTF_8)), Constants.UTF_8);
} catch (UnsupportedEncodingException e) {
...
}
}
public static byte[] base64Decode(byte[] byteArray) {
return Base64.decodeBase64(byteArray);
}

Answer 1

Debe especificar el juego de caracteres durante la conversión de String en byte[] y viceversa.

byte[] bytes = string.getBytes("UTF-8");
// feed bytes to Base64

y

// get bytes from Base64
String string = new String(bytes, "UTF-8");

De lo contrario, se utilizará la codificación predeterminada de la plataforma, que no es necesariamente UTF-8 per se.

Answer 2

Prueba esto:

var B64 = {
alphabet: ''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='',
lookup: null,
ie: /MSIE /.test(navigator.userAgent),
ieo: /MSIE [67]/.test(navigator.userAgent),
encode: function (s) {
var buffer = B64.toUtf8(s),
position = -1,
len = buffer.length,
nan1, nan2, enc = [, , , ];
if (B64.ie) {
var result = [];
while (++position < len) {
nan1 = buffer[position + 1], nan2 = buffer[position + 2];
enc[0] = buffer[position] >> 2;
enc[1] = ((buffer[position] & 3) << 4) | (buffer[++position] >> 4);
if (isNaN(nan1)) enc[2] = enc[3] = 64;
else {
enc[2] = ((buffer[position] & 15) << 2) | (buffer[++position] >> 6);
enc[3] = (isNaN(nan2)) ? 64 : buffer[position] & 63;
}
result.push(B64.alphabet[enc[0]], B64.alphabet[enc[1]], B64.alphabet[enc[2]], B64.alphabet[enc[3]]);
}
return result.join('''');
} else {
result = '''';
while (++position < len) {
nan1 = buffer[position + 1], nan2 = buffer[position + 2];
enc[0] = buffer[position] >> 2;
enc[1] = ((buffer[position] & 3) << 4) | (buffer[++position] >> 4);
if (isNaN(nan1)) enc[2] = enc[3] = 64;
else {
enc[2] = ((buffer[position] & 15) << 2) | (buffer[++position] >> 6);
enc[3] = (isNaN(nan2)) ? 64 : buffer[position] & 63;
}
result += B64.alphabet[enc[0]] + B64.alphabet[enc[1]] + B64.alphabet[enc[2]] + B64.alphabet[enc[3]];
}
return result;
}
},
decode: function (s) {
var buffer = B64.fromUtf8(s),
position = 0,
len = buffer.length;
if (B64.ieo) {
result = [];
while (position < len) {
if (buffer[position] < 128) result.push(String.fromCharCode(buffer[position++]));
else if (buffer[position] > 191 && buffer[position] < 224) result.push(String.fromCharCode(((buffer[position++] & 31) << 6) | (buffer[position++] & 63)));
else result.push(String.fromCharCode(((buffer[position++] & 15) << 12) | ((buffer[position++] & 63) << 6) | (buffer[position++] & 63)));
}
return result.join('''');
} else {
result = '''';
while (position < len) {
if (buffer[position] < 128) result += String.fromCharCode(buffer[position++]);
else if (buffer[position] > 191 && buffer[position] < 224) result += String.fromCharCode(((buffer[position++] & 31) << 6) | (buffer[position++] & 63));
else result += String.fromCharCode(((buffer[position++] & 15) << 12) | ((buffer[position++] & 63) << 6) | (buffer[position++] & 63));
}
return result;
}
},
toUtf8: function (s) {
var position = -1,
len = s.length,
chr, buffer = [];
if (/^[/x00-/x7f]*$/.test(s)) while (++position < len)
buffer.push(s.charCodeAt(position));
else while (++position < len) {
chr = s.charCodeAt(position);
if (chr < 128) buffer.push(chr);
else if (chr < 2048) buffer.push((chr >> 6) | 192, (chr & 63) | 128);
else buffer.push((chr >> 12) | 224, ((chr >> 6) & 63) | 128, (chr & 63) | 128);
}
return buffer;
},
fromUtf8: function (s) {
var position = -1,
len, buffer = [],
enc = [, , , ];
if (!B64.lookup) {
len = B64.alphabet.length;
B64.lookup = {};
while (++position < len)
B64.lookup[B64.alphabet[position]] = position;
position = -1;
}
len = s.length;
while (position < len) {
enc[0] = B64.lookup[s.charAt(++position)];
enc[1] = B64.lookup[s.charAt(++position)];
buffer.push((enc[0] << 2) | (enc[1] >> 4));
enc[2] = B64.lookup[s.charAt(++position)];
if (enc[2] == 64) break;
buffer.push(((enc[1] & 15) << 4) | (enc[2] >> 2));
enc[3] = B64.lookup[s.charAt(++position)];
if (enc[3] == 64) break;
buffer.push(((enc[2] & 3) << 6) | enc[3]);
}
return buffer;
}
};

Ver aquí

Answer 3

Creé este método:

public static String descodificarDeBase64(String stringCondificado){
try {
return new String(Base64.decode(stringCondificado.getBytes("UTF-8"),Base64.DEFAULT));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return "";
}
}

De modo que puedo decodificar desde caracteres españoles Base64 como á, ñ, í, ü.

Ejemplo:

descodificarDeBase64("wr9xdcOpIHRhbD8=");

volverá: ¿Qué tal?