Base64: java.lang.IllegalArgumentException: Illegal character

Ich versuche, das senden einer Bestätigungs-E-Mail nach der Registrierung der Nutzer. Ich bin mit der JavaMail-Bibliothek für diesen Zweck, und die Java-8 Base64-util-Klasse.

Ich bin-Kodierung Benutzer E-Mails in der folgenden Weise:

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

wo confirmationURL ist:

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

Und dann decodieren Sie diese in ConfirmRegistrationCommand so:

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

Und wenn ich versuche zu entschlüsseln:

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

Ich bin immer java.lang.IllegalArgumentException: Illegal base64 character 5b.

Ich habe versucht, die grundlegenden Encode/Decoder (nicht URL sind), ohne Erfolg.

GELÖST:

Das problem war die nächste in der Reihe:

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

Ich bin Aufruf von toString auf ein array von bytes, also sollte ich Folgendes tun:

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

Dank Jon Skeet und ByteHamster.

Aus Neugier, warum .getBytes(StandardCharsets.UTF_8) und .getBytes("UTF-8") in der gleichen Funktion ? Scheint wie eine mangelnde Kohärenz zu mir 😐
Hinweis: Sie fordern toString() auf eine byte[]. Sie wollen nicht, das zu tun.
ja ! Ich denke, dass es das problem verursacht. Wie sollte ich es ändern ?
wahrscheinlich sollte ich einfach rufen new String(encodedEmail)
Oder besser, verwenden Sie eine base64-API, die kodiert einen string, nicht ein byte[]. Die Bibliothek in iharder.net/base64 ist ziemlich gut...

InformationsquelleAutor marknorkin | 2015-02-18

17

Ihren kodierten text ist [B@6499375d. Das ist nicht Base64, ging etwas schief, während Codierung. Sie, dass die Decodierung der code sieht gut aus.

Diesen code verwenden, zum konvertieren des byte[] in einen String, bevor Sie ihn auf die URL:
```
String encodedEmailString = new String(encodedEmail, "UTF-8");
//...
String confirmLink = "Complete your registration by clicking on following"
    + "\n<a href='" + confirmationURL + encodedEmailString + "'>link</a>";
```
- wie Jon Skeet darauf hingewiesen, ich bin Aufruf von toString auf array der Bisse. dies ist die Ursache
- Ich hasse es, dass Kerl, aber da dies ein technisches forum: base64 ist keine Verschlüsselung, es ist die Codierung.
InformationsquelleAutor ByteHamster

Dass ich auf diese Fehler seit meinem codierten Bildes begann mit data:image/png;base64,iVBORw0....

Diese Antwort führte mich zu der Lösung:

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

InformationsquelleAutor Matthias Braun

Benutzen Sie einfach den untenstehenden code zur Lösung dieses Problems:

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

Im obigen code replace('-', '+').replace('_', '/') hat den job. Weitere details finden Sie in der https://jwt.io/js/jwt.js. Ich Verstand das problem von dem Teil des Codes, bekam von diesem link:

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

InformationsquelleAutor Esakkiappan .E

Base64.Encoder.encodeToString Methode verwendet automatisch die ISO-8859-1-Zeichensatz.

Für ein Verschlüsselungswerkzeug ich Schreibe, ich nahm den input-string des cipher text, der und Base64 kodiert es für die übertragung, die dann Umgekehrt den Prozess. Relevante Teile nachfolgend dargestellt. HINWEIS: Meine Datei.encoding-Eigenschaft festgelegt ist auf ISO-8859-1 nach dem Aufruf der JVM, so dass möglicherweise auch eine Bedeutung hat.

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

}

Die Ausgabe sieht so aus:

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...

Im Grunde versucht die Anzeige von verschlüsselten Daten als text funktioniert nicht, weil es byte-Werte, die nicht über eine druckbare Darstellung. In diesem Fall werden die " � " - Zeichen. Aus diesem Grund verschlüsselte Daten beste Darstellung in hexadezimal.
Das ist nur debug-code, aber die Anzeige von verschlüsselten Daten als text funktioniert nur gut, wenn Sie Ihre Verschlüsselung Ausgabe ist bereits druckbaren Zeichen. In diesem Fall sind Sie nicht alle gedruckt werden, aber es ist auch irrelevant.
Was macht Sie denken, ich verstehe nicht, Codierungen? Es ist einfach ein sanity-check-Ausgabe, um zu sehen, wenn es verschlüsselt ist, und als solche, die nicht druckbare Zeichen sind eine bessere Darstellung, die als ordentlich formatiert sind: %02x Zeichen. Der Ausgang ist für mich allein, der einzige Entwickler.
In Anbetracht, dass lahm Retorte, ich habe Kommentare zu meinem source-code.

InformationsquelleAutor guitarpicva

0

Ich habe diesen Fehler bei meinem Linux-Jenkins-slave. Ich habe es behoben durch den Wechsel von der Knoten von der "Bekannten hosts file Verification" - Strategie, die "Nicht überprüfen, Überprüfung Strategie".

InformationsquelleAutor twasbrillig

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.