Base64: java.lang.IllegalArgumentException: caractère Illégal

Je suis en train d'envoyer un e-mail de confirmation après l'inscription de l'utilisateur. Je suis à l'aide de la JavaMail de la bibliothèque à cette fin et la Java 8 Base64 util classe.

Je suis d'encodage de l'utilisateur e-mails de la manière suivante:

byte[] encodedEmail = Base64.getUrlEncoder().encode(user.getEmail().getBytes(StandardCharsets.UTF_8));
Multipart multipart = new MimeMultipart();
InternetHeaders headers = new InternetHeaders();
headers.addHeader("Content-type", "text/html; charset=UTF-8");
String confirmLink = "Complete your registration by clicking on following"+ "\n<a href='" + confirmationURL + encodedEmail + "'>link</a>";
MimeBodyPart link = new MimeBodyPart(headers,
confirmLink.getBytes("UTF-8"));
multipart.addBodyPart(link);

où confirmationURL est:

private final static String confirmationURL = "http://localhost:8080/project/controller?command=confirmRegistration&ID=";

Et puis le décodage de cette ConfirmRegistrationCommand dans une telle manière:

    String encryptedEmail = request.getParameter("ID");

    String decodedEmail = new String(Base64.getUrlDecoder().decode(encryptedEmail), StandardCharsets.UTF_8);

    RepositoryFactory repositoryFactory = RepositoryFactory
            .getFactoryByName(FactoryType.MYSQL_REPOSITORY_FACTORY);
    UserRepository userRepository = repositoryFactory.getUserRepository();
    User user = userRepository.find(decodedEmail);

    if (user.getEmail().equals(decodedEmail)) {
        user.setActiveStatus(true);
        return Path.WELCOME_PAGE;
    } else {
        return Path.ERROR_PAGE;
    }

Et quand j'essaie de décoder:

http://localhost:8080/project/controller?command=confirmRegistration&ID=[B@6499375d

Je suis java.lang.IllegalArgumentException: Illegal base64 character 5b.

J'ai essayé d'utiliser de base Encoder/Decoder (pas d'URL), sans succès.

RÉSOLU:

Le problème était le suivant - dans la ligne:

 String confirmLink = "Complete your registration by clicking on following"+ "\n<a href='" + confirmationURL + encodedEmail + "'>link</a>";

Je vais appeler toString sur un tableau d'octets, donc je doit faire ce qui suit:

String encodedEmail = new String(Base64.getEncoder().encode(
                user.getEmail().getBytes(StandardCharsets.UTF_8)));

Grâce à Jon Skeet et ByteHamster.

Par curiosité, pourquoi .getBytes(StandardCharsets.UTF_8) et .getBytes("UTF-8") dans la même fonction ? Semble comme un manque de cohérence pour moi 😐
Astuce: vous appelez toString() sur un byte[]. Vous ne voulez pas le faire.
oui ! Je pense qu'il provoque le problème. Comment dois-je le changer ?
probablement que je devrais appeler new String(encodedEmail)
Ou mieux, utiliser un base64 API qui code pour une chaîne de caractères, pas un byte[]. La bibliothèque de l' iharder.net/base64 est très bien fait...

OriginalL'auteur marknorkin | 2015-02-18

15

Votre texte codé est [B@6499375d. Ce n'est pas Base64, quelque chose s'est mal passé alors que encodage. Que le décodage de code semble bon.

Utiliser ce code pour convertir le byte[] pour une Chaîne de caractères avant de l'ajouter à l'URL:
```
String encodedEmailString = new String(encodedEmail, "UTF-8");
//...
String confirmLink = "Complete your registration by clicking on following"
    + "\n<a href='" + confirmationURL + encodedEmailString + "'>link</a>";
```
comme Jon Skeet souligné je vais appeler toString sur tableau de morsures. c'est la cause
Je déteste être que les gars, mais puisque c'est un forum technique: base64 n'est pas le cryptage, c'est l'encodage.

OriginalL'auteur ByteHamster

J'ai rencontré cette erreur depuis mon image encodée commencé avec data:image/png;base64,iVBORw0....

Cette réponse m'a conduit à la solution:

String partSeparator = ",";
if (data.contains(partSeparator) {
  String encodedImg = data.split(partSeparator)[1];
  byte[] decodedImg = Base64.getDecoder().decode(encodedImg.getBytes(StandardCharsets.UTF_8));
  Path destinationFile = Paths.get("/path/to/imageDir", "myImage.jpg");
  Files.write(destinationFile, decodedImg);
}

OriginalL'auteur Matthias Braun

Suffit d'utiliser le code ci-dessous pour résoudre ce problème:

JsonObject obj = Json.createReader(new ByteArrayInputStream(Base64.getDecoder().decode(accessToken.split("\\.")[1].
                        replace('-', '+').replace('_', '/')))).readObject();

Dans le code ci-dessus replace('-', '+').replace('_', '/') a fait le travail. Pour plus de détails, voir le https://jwt.io/js/jwt.js. J'ai compris le problème de la partie du code obtenu à partir de ce lien:

function url_base64_decode(str) {
  var output = str.replace(/-/g, '+').replace(/_/g, '/');
  switch (output.length % 4) {
    case 0:
      break;
    case 2:
      output += '==';
      break;
    case 3:
      output += '=';
      break;
    default:
      throw 'Illegal base64url string!';
  }
  var result = window.atob(output); //polifyll https://github.com/davidchambers/Base64.js
  try{
    return decodeURIComponent(escape(result));
  } catch (err) {
    return result;
  }
}

OriginalL'auteur Esakkiappan .E

Le Base64.Codeur.encodeToString méthode utilise automatiquement l'ISO-8859-1 jeu de caractères.

Pour un utilitaire de cryptage je suis en train d'écrire, j'ai pris de la chaîne d'entrée de texte chiffré et encodées en Base64 pour transmission, alors inversé le processus. Les parties pertinentes indiqué ci-dessous. NOTE: Mon fichier.propriété de codage est défini à la norme ISO-8859-1 lors de l'invocation de la JVM de sorte que peut aussi avoir une incidence.

static String getBase64EncodedCipherText(String cipherText) {
    byte[] cText = cipherText.getBytes();
    //return an ISO-8859-1 encoded String
    return Base64.getEncoder().encodeToString(cText);
}

static String getBase64DecodedCipherText(String encodedCipherText) throws IOException {
    return new String((Base64.getDecoder().decode(encodedCipherText)));
}

public static void main(String[] args) {
    try {
        String cText = getRawCipherText(null, "Hello World of Encryption...");

        System.out.println("Text to encrypt/encode: Hello World of Encryption...");
        //This output is a simple sanity check to display that the text
        //has indeed been converted to a cipher text which 
        //is unreadable by all but the most intelligent of programmers.
        //It is absolutely inhuman of me to do such a thing, but I am a
        //rebel and cannot be trusted in any way.  Please look away.
        System.out.println("RAW CIPHER TEXT: " + cText);
        cText = getBase64EncodedCipherText(cText);
        System.out.println("BASE64 ENCODED: " + cText);
        //There he goes again!!
        System.out.println("BASE64 DECODED:  " + getBase64DecodedCipherText(cText));
        System.out.println("DECODED CIPHER TEXT: " + decodeRawCipherText(null, getBase64DecodedCipherText(cText)));
    } catch (Exception e) {
        e.printStackTrace();
    }

}

La sortie ressemble à ceci:

Text to encrypt/encode: Hello World of Encryption...
RAW CIPHER TEXT: q$;�C�l��<8��U���X[7l
BASE64 ENCODED: HnEPJDuhQ+qDbInUCzw4gx0VDqtVwef+WFs3bA==
BASE64 DECODED:  q$;�C�l��<8��U���X[7l``
DECODED CIPHER TEXT: Hello World of Encryption...

En fait, d'essayer d'afficher des données chiffrées en tant que texte ne fonctionne pas car il y a des valeurs d'octets qui n'ont pas la version imprimable de la représentation. Dans ce cas, le "�" des personnages. Pour cette raison, les données chiffrées sont meilleur affichage en hexadécimal.
C'est juste le code de débogage, mais l'affichage des données chiffrées que le texte fonctionne très bien si vos cryptage de sortie est déjà caractères imprimables. Dans ce cas, ils ne sont pas tous imprimable, mais il est également hors de propos.
Ce qui vous fait penser que je ne comprends pas les codages? C'est tout simplement un test de cohérence de sortie pour voir si elle s'est chiffré, et en tant que tel, les caractères non imprimables sont une meilleure représentation de ce que proprement formaté %02x caractères. La sortie est pour moi le seul, le seul développeur.
À la lumière de la lame de la cornue, j'ai ajouté des commentaires à mon code source.

OriginalL'auteur guitarpicva

0

J'ai eu cette erreur pour mon Linux Jenkins esclave. Je l'ai corrigé en modifiant à partir du nœud de "fichier d'hôtes Connus de Vérification de la Stratégie" à "Non vérification de la Vérification de la Stratégie".

OriginalL'auteur twasbrillig

Vous devez vous connecter pour publier un commentaire.