Convert.FromBase64 von C# für Java

[Nemo2478]

Hallo an alle,

ich habe diese Woche schon zwei Fragen gestellt, die mit der Übersetzung von bestimmten keywords (fixed und unsafe) von C# auf Java zu tun hatten.

Ich habe sie gestellt, weil ich ein kleines Problem eines GANZEN Problems lösen wollte.

Beim kleinen Problem geht es darum ein Äquivalent von Convert.FromBase64String für Java zu finden. Da ich nichts passendes gefunden habe / erreicht habe, dachte, mir würde nichts anderes übrig bleiben, selbst so eine Methode in Java zu schreiben (deswegen auch die Fragen mit dem keywords). Man hat mir aber empfohlen es nicht so locker zu sehen. "Möglicherweise kann man Probleme ganz anders lösen als bei einer anderen Sprache", hat man so ungefähr geschrieben.

Und zwar habe ich nichts passendes gefunden, weil die Alternativen nicht die gleichen Ergebnissen bringen (beispielsweise die Methode decodeBase64). Die Methode von C# dagegen gibt unsignierte 8bit-Werte aus, verwendet AES-Verschlüsselung, etc...

Kann man irgendwie mit der Methode decodeBase64 von Java arbeiten, sodass man die gleiche Ergebnisse sehen kann wie bei C# oder ist es doch besser eine ganz neue und eigene Methode zu schreiben?


Danke und Grüße

 

[mrBrown]

Das Äquivalent zu Convert.FromBase64String dürfte Base64.Decoder.decode sein.
bytes in Java sind zwar immer mit Vorzeichen, wenn du aber auf Bit-Ebene damit arbeitest ist es völlig egal, in C# und Java wird da binär das gleiche Ergebnis rauskommen.

Die Methode von C# dagegen [...], verwendet AES-Verschlüsselung, etc...

Wie kommst du darauf? Der Doku nach wird da nichts anderes außer das reine konvertieren gemacht...

Kann man irgendwie mit der Methode decodeBase64 von Java arbeiten

Wo hast du die Methode gefunden?

 

[mihe7]

Beim kleinen Problem geht es darum ein Äquivalent von Convert.FromBase64String für Java zu finden.

Base64 (Java Platform SE 8 )

docs.oracle.com

Base64.Decoder (Java Platform SE 8 )

docs.oracle.com

Die Methode von C# dagegen gibt unsignierte 8bit-Werte aus, verwendet AES-Verschlüsselung

Wenn die Methode Verschlüsselung verwenden sollte, wäre das kein Base64-Dekoder, und 8 Bit sind 8 Bit - ob mit oder ohne Vorzeichen ist ja nur eine Frage der Interpretation.

 

[Nemo2478]

Hallo ihr beide ,

mit unterschiedlichen Ergebnissen habe ich folgendes gemeint:

Bei C#:

using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;

namespace CSharp_Shell
{

    public static class Program
    {
        public static void Main()
        {
           string str = "BQoPFBke";
      byte[] val2 = Convert.FromBase64String(str);
      Console.WriteLine("Byte-Werte: {0}", BitConverter.ToString(val2));
        }
    }
}

bekomme ich die Ausgabe:

Byte-Werte: 05-0A-0F-14-19-1E

Und bei Java:

public class Main
{
    public static void main(String[] args)
    {
        String encodedString = "BQoPFBke";
        Base64.Decoder decoder = Base64.getDecoder();
        byte[] decodedByteArray = decoder.decode(encodedString);
        System.out.print(Arrays.toString(decodedByteArray));
    }
}

bekomme die Ausgabe:

[5, 10, 15, 20, 25, 30]

Also unterschiedliche Ergebnisse. Und so weit ich verstanden habe, weil ein Array signiert und der andere unsigniert ist, oder?

Wie kann ich ich die gleiche Ergebnissen bekommen?


Danke und Grüße

PD.:

Wo hast du die Methode gefunden?

Die Methode von (org.apache.commons.codec.binary.Base64) habe ich in dieser Webseite gefunden: https://www.baeldung.com/java-base64-encode-and-decode

 

[httpdigest]

Du bekommst in beiden Fällen die gleichen Ergebnisse... im C# Fall werden sie nur hexadezimal (zur Basis 16) ausgegeben, in Java dezimal (zur Basis 10).
10 dezimal ist A bzw. 0A hexadezimal, usw.
Die Byte-Werte im Array sind also in beiden Fällen exakt identisch.

 

[mihe7]

Also unterschiedliche Ergebnisse.

Du vergleichst Äpfel mit Birnen. Du müsstest val2 und decodedByteArray, also die Daten miteinander vergleichen, Du vergleichst dagegen lediglich String-Darstellungen dieser Daten und die ist halt einfach unterschiedlich.

Wenn Du in Java die gleiche Ausgabe wie in C# haben willst:

IntStream.range(0, values.length).mapToObj(i -> String.format("%02X", values[i])).collect(Collectors.joining("-"))

wobei values Deinem decodedByteArray entspricht.

Mit einer Funktion:

Function<byte[], String> format = values -> IntStream.range(0, values.length)
    .mapToObj(i -> String.format("%02X", values[i]))
    .collect(Collectors.joining("-"));

kannst Du z. B.

byte[] decodedByteArray = {5, 10, 15, 20, 25, 30};
System.out.println(format.apply(decodedByteArray));

schreiben und würdest als Ergebnis

05-0A-0F-14-19-1E

erhalten.

 

[Nemo2478]

Du vergleichst dagegen lediglich String-Darstellungen dieser Daten und die ist halt einfach unterschiedlich.

Wenn Du in Java die gleiche Ausgabe wie in C# haben willst:

IntStream.range(0, values.length).mapToObj(i -> String.format("%02X", values[i])).collect(Collectors.joining("-"))

wobei values Deinem decodedByteArray entspricht.

Spoiler

Es hat die ganze Zeit das gleiche ausgespuckt!?! Und ich dachte es liege an etwas ganz anderes...

Trotzdem brauche ich die gleiche Ausgabe zum Vergleich im weiteren Verlauf des Programms...

Leider habe ich kein Java 8 um deinen tollen Code ausprobieren. Allerdings reicht der folgende Code für Java 7, aber NUR für den String aus dem Beispiel (BQoPFBke):

public static void main(String[] args)
    {
        String encodedString = "BQoPFBke";
        Base64.Decoder decoder = Base64.getDecoder();
        byte[] decodedByteArray = decoder.decode(encodedString);
        String array = "";
        for (int f=0; f<decodedByteArray.length; f++) {
            if (f == decodedByteArray.length - 1) {
                array = array + decimal2hex(decodedByteArray[f]);
            }
            else {
                array = array + decimal2hex(decodedByteArray[f]) + " - ";
            }
        }
        System.out.print(array);
    }
    
    public static String decimal2hex(int d)
    {
        String digits = "0123456789ABCDEF";
        if (d <= 0) return "0";
        int base = 16;   // flexible to change in any base under 16
        String hex = "";
        while (d > 0)
        {
            int digit = d % base;              // rightmost digit
            hex = digits.charAt(digit) + hex;  // string concatenation
            d = d / base;
        }
        hex = hex.length() <= 1 ? String.format("0%s", hex) : hex;

        return hex;
    }

Aber für den String "F5fPxdTq8eJeuqSVejGmq7aTh6BJZ8J0jgt92MDDjxTIWf+mWa8Ld+01L2bVIV6FXhCO" funktioniert er nicht ...

Vielleicht bekomme ich es irgendwie hin...


Grüße und vielen Dank

 

[mrBrown]

Ersetz deine decimal2hex einfach mit String.format("%02X", decodedByteArray[f]), für sowas muss man dich nicht einfach komischen Code von irgendwo kopieren

EDIT zur Erklärung: Deine Methode erwartet einen positiven int, du übergibst aber einen Wert der negativ sein kann.



In deiner Signatur hast du dich übrigens verschrieben, du meintest sicher masochistisch

 

[mihe7]

In deiner Signatur hast du dich übrigens verschrieben, du meintest sicher masochistisch

ROFL.

 

[Nemo2478]

Ersetz deine decimal2hex einfach mit String.format("%02X", decodedByteArray[f]), für sowas muss man dich nicht einfach komischen Code von irgendwo kopieren

Vielen herzlichen Dank dafür.
Ich wusste nicht, dass es mit String.format geht. Wenn ich das gewusst hätte, hätte ich nicht den Code kopiert.

EDIT zur Erklärung: Deine Methode erwartet einen positiven int, du übergibst aber einen Wert der negativ sein kann.

😭😭 Das ist zum heulen. Die zweite Linie des Blocks wäre idiotsicher gewesen und trotzdem habe ich das Problem nicht verstanden...

In deiner Signatur hast du dich übrigens verschrieben, du meintest sicher masochistisch

😭😭😭😭😭

 

[mihe7]

Nochmal ein wenig was zum Code. Mit String.format sähe das ja erstmal so aus:

        String array = "";
        for (int f=0; f<decodedByteArray.length; f++) {
            if (f == decodedByteArray.length - 1) {
                array = array + String.format("%02X", decodedByteArray[f]);
            }
            else {
                array = array + String.format("%02X", decodedByteArray[f]) + " - ";
            }
        }
        System.out.print(array);

Da String.format in jedem Zweig - also in jedem Fall - hinzugefügt wird, kann man das vor die if-Abfragen ziehen. Dadurch wird offensichtlich, dass nur der else-Zweig benötigt wird. Mit geänderter Bedingung:

        String array = "";
        for (int f=0; f<decodedByteArray.length; f++) {
            array = array + String.format("%02X", decodedByteArray[f]);
            if (f < decodedByteArray.length - 1) {
                array = array + " - ";
            }
        }
        System.out.print(array);

Da Strings immutable sind, werden durch die String-Konkatenation nun ständig neue Objekte erzeugt. Das verhindert man durch den Einsatz eines StringBuilders. Außerdem lässt sich der Spaß gleich in eine Methode auslagern:

public static String hexlify(byte[] data) {
    StringBuilder b = new StringBuilder();
    for (int i = 0; i < data.length; i++) {
        b.append(String.format("%02X", data[i]));
        if (i < data.length - 1) {
            b.append("-");
        }
    }
    return b.toString();
}

 

[Nemo2478]

Da Strings immutable sind, werden durch die String-Konkatenation nun ständig neue Objekte erzeugt. Das verhindert man durch den Einsatz eines StringBuilders. Außerdem lässt sich der Spaß gleich in eine Methode auslagern:

public static String hexlify(byte[] data) {
StringBuilder b = new StringBuilder();
for (int i = 0; i < data.length; i++) {
b.append(String.format("%02X", data[i]));
if (i < data.length - 1) {
b.append("-");
}
}
return b.toString();
}

Hey!! Das macht ja richtig Spaß.

Ich habe es zu drei weniger Linien reduziert:

public static String hexlify(byte[] data) {
        StringBuilder b = new StringBuilder();
        for (byte bt: data)
            b.append(String.format("%02X", bt)).append("-");
        b.setLength(Math.max(b.length() - 1, 0));
        return b.toString();
    }