Java BASE64 utf8 string decoding

Question

Estoy usando org.apache.commons.codec.binary.Base64 do decode string que es utf8. A veces obtengo una cadena codificada en base64 que después de la decodificación se parece, por ejemplo, a ^@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

Se debe especificar el conjunto de caracteres durante la conversión a Stringbyte[] 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 el valor predeterminado plataforma de codificación será utilizado que no es necesariamente UTF-8 per se.

Answer 2

Prueba esto:

var B64 = { 
    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/=', 
    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 Here

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

, así que puede decodificar de base 64 characthers español como, n, i, u.

Ejemplo:

descodificarDeBase64("wr9xdcOpIHRhbD8="); 

devolverá: ¿qué tal?