# Xor Warum kommt Flasches Zeichen in Java



## nitschchedu (27. Dez 2008)

Hallo ich mache wie im PHP nun im Java Xor.

Nun kommt es vor das im Java manche Zeichen nicht so wie im PHP richtig rauskommen.
Dabei habe ich hier ein Zeichen gefunden bei dem das so ist:


```
char test = HexString.hexToString("8a").charAt(0);
        test ^= HexString.hexToString("EF").charAt(0);

        System.out.println(test);
```

Rauskommen müsste wie im PHP ein 





> e


das tut es aber nicht .... was mache ich Falsch ?


----------



## Marco13 (27. Dez 2008)

Die Klasse 'HexString' kenne ich zwar nicht, aber ... du rechnest da vermutlich mit Zeichen (chars) und nicht mit Werten... 

char test = HexString.hexToString("8a").charAt(0); // test is jetzt vermutlich das ZEICHEN '8', und hat darum den Wert 56


----------



## nitschchedu (27. Dez 2008)

Also auf Test steht bei mir 96 ... nicht richtig ?

Sehe gerade das meine Klasse Bugi ist ... hast du eine Idee wie ich Hex zu Char mache ?


----------



## 0x7F800000 (27. Dez 2008)

ich würde eher drauf tippen, dass da '1' aus 138 mit der '2' aus 239 mit XOR verrechnet wird, was sicherlich nicht 'e' ergibt, weil '1' und '2' sich gerade mal in den zwei ersten Bits unterscheidet, es kommt also dem 3. char entspricht, was irgendein Zeichen ist, das ich auf der eclipse-console nicht lesen kann.

Aber was soll dieser ganze Kram mit HexString usw? Hab nicht mal unter den ersten 10 Google-Treffern was gefunden, was soll das sein, wo kommt das her?

=> IMMER KLEINES KOMPILIERBARES BEISPIEL BASTELN!!!


----------



## 0x7F800000 (27. Dez 2008)

nitschchedu hat gesagt.:
			
		

> hast du eine Idee wie ich Hex zu Char mache ?


hmmm, merkwürdig... mir fällt nichts besseres als

```
char t=(char)Integer.parseInt("EF", 0x10);
```
ein.

Kannst du die Hex-Werte nicht direkt eintippen? etwa:

```
char c=0xEF;
```


----------



## nitschchedu (27. Dez 2008)

ne die kommen aus einen String der sich jedesmal ändert ^^

Ist das so nicht besser ? 

```
char t=(char)Integer.parseInt("EF", 16);
```

Basis ist ja 16 bei Hex ^^ ! ?

@obwohl ist das selbe wenn ich mir das mal anschaue ^^


----------



## 0x7F800000 (27. Dez 2008)

nitschchedu hat gesagt.:
			
		

> @obwohl ist das selbe wenn ich mir das mal anschaue ^^


ääää... jjjja^^


----------



## nitschchedu (27. Dez 2008)

Kannste mir auch noch Zeigen wie ich String zu Hex mache ?


----------



## 0x7F800000 (27. Dez 2008)

wie mach ich Kubikmeter zu einem Ölgemälde? :autsch:
was soll das heißen "String zu Hex"?


----------



## nitschchedu (27. Dez 2008)

Lol xD .. ok für dich 



> test



zu 



> 233b23fb



beides vom String 

2 Inhalt stimmt nicht mit Test ... nur bsp


----------



## 0x7F800000 (27. Dez 2008)

du willst text zeichen für zeichen in hexadezimaldarstellungen von einzelnen zeichen übersetzen? wozu soll sowas gut sein?
Aber naja, deine Sache...

```
public static String demolateString(String text){
		StringBuilder builder=new StringBuilder(text.length()*2);
		for(int i=0; i<text.length(); builder.append(Integer.toHexString(text.charAt(i))), i++);
		return builder.toString();
	}
```


----------



## nitschchedu (28. Dez 2008)

Wie kann es sein das bei Hex 160 bei deiner Funktion rauskommt ? Wenn HexChars doch nur bis FF gehen !? 
Java veralbert mich  :?

@Anscheinend liegt es an charAt das gibt mir falsche Zeichen zurück oO


----------



## 0x7F800000 (28. Dez 2008)

aaachhhhh, dann muss man das ebn noch die breite auf 2 zeichen festsetzen, dass da alles mit nullen aufgefüllt wird:

```
public static String demolishString(String text){
		StringWriter writer=new StringWriter(text.length()*2);
		PrintWriter printer=new PrintWriter(writer);
		for(int i=0; i<text.length(); printer.printf("%02X", (int)text.charAt(i)), i++);
		return writer.getBuffer().toString();
	}
```
dann bekommt man bei sowas:

```
String s=""+(char)0x00+(char)0xFF+(char)0x45+(char)0x65;
	System.out.println(s+"\t"+demolishString(s));
```
wieder genau 00FF4565 zurück. Ist das was du haben wolltest? ???:L

ansonsten könntest du wenigstens mal angeben bei welchem string "160" auskommen soll.
vielleicht ist das die korrekte hexadezimal darstellung für ein char, das außerhalb von ascii ist, und daher nicht auf zwei hexadezimalstellen passt. Bist du dir sicher, dass du nur mit ascii zeichen herumhantierst?


----------



## hdi (28. Dez 2008)

> wie mach ich Kubikmeter zu einem Ölgemälde?



Also Andrey, dass _du_ das nicht weisst. Schon schwach... 

http://www.stupidedia.org/stupi/Kubikmeter_in_Ölgemälde


----------



## 0x7F800000 (28. Dez 2008)

:### 
:lol: lol, du held^^


----------



## Spacerat (28. Dez 2008)

Huch... das kenn' ich doch...

@hdi: Was hat denn wohl dein Link mit diesem Thema zu tun? Willst du uns etwa so mitteilen, dass PHP Äpfel und Birnen zusammenzählt oder fehlt da nur der Name zum Zitat?

@PHP: (ehrlich... ich mein die Sprache...  ) Wie kommt man eigentlich dazu, Datentypen so dermassen zusammenzuwürfeln, das sogar Zeichenketten zusammengerechnet werden? Ach ja... zum verknüpfen gibts ja den Punkt... hua, hua, hua... absolut 'TYPESAFE'... ehrlich...

Nee... mal ernsthaft... das ist genau das, worüber man stolpert, wenn man PHP-Anwendungen in Sprachen wie z.B. Java konvertieren will. PHP 'rechnet' mit Strings! "1234" + "5678" macht in PHP "6912" und in Java "12345678". Na merkt er was? Während die HexStrings in PHP schlicht als Zahlen interpretiert werden, muss man in Java einen recht weiten Umweg gehen. Fakt ist, das (char) '1' z.B. in Java nicht 1 sondern 49 (0x31) ergibt. Das falsche Zeichen kommt also wohl eher in PHP.

Sagte ich Eingangs das kommt mir bekannt vor? Hier meine Lösung des Problems...


```
public final class HexMath
{
  private static final String NUMBERS = "0123456789abcdefABCDEF";
  private static final int RADIX = 0x10; // Basis 16

  public static class MD5String
  extends HexString
  {
    private static final long serialVersionUID = 8423109029732380666L;

    public MD5String(String value)
    {
      super((value != null && value.length() >= 32)? value.substring(value.length() - 32) : "");
    }
  }

  public static class HexString
  extends Number
  implements Cloneable
  {
    private static final long serialVersionUID = 6216050881224903751L;
    private final String value;

    public HexString(long value)
    {
      this(Long.valueOf(value).toString());
    }

    public HexString(double value)
    {
      this(Double.doubleToLongBits(value));
    }

    public HexString(float value)
    {
      this(Float.floatToIntBits(value));
    }

    public HexString(String value)
    {
      if(!check(value)) throw new NumberFormatException("illegal value" + value);
      this.value = value;
    }

    private boolean check(String value)
    {
      if(value == null || value.length() == 0) return false;
      boolean rc = true;
      for(int n = 0; n < value.length() && rc; n++) rc &= NUMBERS.contains(String.valueOf(value.charAt(n)));
      return rc;
    }

    public HexString expand(int times)
    {
      return expand(times, true);
    }

    public HexString expand(int times, boolean ignorenflag)
    {
      if(times < 1) throw new IllegalArgumentException("parameter 'times' has to be larger than 0");
      StringBuffer tmp = new StringBuffer();
      int flag = (!ignorenflag)? Integer.parseInt(String.valueOf(value.charAt(0)), RADIX) : 0;
      tmp.append(NUMBERS.charAt(((flag & RADIX) != 0)? 8 : 0));
      times--;
      for(; times > 0; times--) tmp.append(NUMBERS.charAt(0));
      if(!ignorenflag) {
        tmp.append(NUMBERS.charAt(flag | (RADIX - 1)));
        flag = 1;
      }
      tmp.append(value.substring(flag));
      return new HexString(tmp.toString());
    }

    public static HexString parseHex(String value)
    {
      return new HexString(value);
    }

    public static HexString parseHex(double value)
    {
      return new HexString(value);
    }

    public static HexString parseHex(float value)
    {
      return new HexString(value);
    }

    public static HexString parseHex(long value)
    {
      return new HexString(value);
    }

    public final double doubleValue()
    {
      return Double.longBitsToDouble(longValue());
    }

    public final float floatValue()
    {
      return Float.intBitsToFloat(intValue());
    }

    public final int intValue()
    {
      int start = (value.length() > 8)? value.length() - 8 : 0;
      return Integer.parseInt(value.substring(start), 16);
    }

    public final long longValue()
    {
      int start = (value.length() > 16)? value.length() - 16 : 0;
      return Long.parseLong(value.substring(start), 16);
    }

    public final String toString()
    {
      return value;
    }

    public final int length()
    {
      return value.length();
    }

    public final Object clone()
    {
      return new HexString(value);
    }

    public final boolean equals(Object obj)
    {
      if(this == obj) return true;
      try {
        HexString tmp = (HexString) obj;
        return tmp.value.equalsIgnoreCase(value);
      } catch(ClassCastException e) {
        return false;
      }
    }
  }

  private HexMath()
  {
  }

  public static HexString xor(HexString a, HexString b)
  {
    return eor(a, b);
  }

  public static HexString eor(HexString a, HexString b)
  {
    if(a == null || b == null) throw new NullPointerException();
    int length = Math.max(a.length(), b.length());
    if(a.length() < length) a = a.expand(length - a.length());
    if(b.length() < length) b = b.expand(length - b.length());
    StringBuffer rc = new StringBuffer();
    int tmp;
    for(int i = 0; i < a.length(); i++) {
      tmp = Integer.parseInt(String.valueOf(a.value.charAt(i)), RADIX)
          ^ Integer.parseInt(String.valueOf(b.value.charAt(i)), RADIX);
      rc.append(NUMBERS.charAt(tmp));
    }
    return new HexString(rc.toString());
  }

  public static HexString and(HexString a, HexString b)
  {
    if(a == null || b == null) throw new NullPointerException();
    int length = Math.max(a.length(), b.length());
    if(a.length() < length) a = a.expand(length - a.length());
    if(b.length() < length) b = b.expand(length - b.length());
    StringBuffer rc = new StringBuffer();
    int tmp;
    for(int i = 0; i < a.length(); i++) {
      tmp = Integer.parseInt(String.valueOf(a.value.charAt(i)), RADIX)
          & Integer.parseInt(String.valueOf(b.value.charAt(i)), RADIX);
      rc.append(NUMBERS.charAt(tmp));
    }
    return new HexString(rc.toString());
  }

  public static HexString or(HexString a, HexString b)
  {
    if(a == null || b == null) throw new NullPointerException();
    int length = Math.max(a.length(), b.length());
    if(a.length() < length) a = a.expand(length - a.length());
    if(b.length() < length) b = b.expand(length - b.length());
    StringBuffer rc = new StringBuffer();
    int tmp;
    for(int i = 0; i < a.length(); i++) {
      tmp = Integer.parseInt(String.valueOf(a.value.charAt(i)), RADIX)
          | Integer.parseInt(String.valueOf(b.value.charAt(i)), RADIX);
      rc.append(NUMBERS.charAt(tmp));
    }
    return new HexString(rc.toString());
  }

  public static HexString eand(HexString a, HexString b)
  {
    return xand(a, b);
  }

  public static HexString xand(HexString a, HexString b)
  {
    a = eor(a, b);
    return not(a);
  }

  public static HexString nor(HexString a, HexString b)
  {
    a = or(a, b);
    return not(a);
  }

  public static HexString nand(HexString a, HexString b)
  {
    a = and(a, b);
    return not(a);
  }

  public static HexString not(HexString a)
  {
    if(a == null) throw new NullPointerException();
    StringBuffer tmp = new StringBuffer();
    int cnt = 0;
    while(cnt++ < a.length()) tmp.append("f");
    return eor(a, new HexString(tmp.toString()));
  }
}
```
Diese Implementation kann beliebig lange HexStrings 'or', 'and', 'nor', 'nand', 'xor' und 'xand' verknüpfen. Dazu dürfen die HexStrings auch verschiedene Längen haben. 'not' stellt eine 'xor'-Verknüpfung eines HexStrings mit einem mit "f"s gefüllten HexString gleicher Länge dar. 'eor' und 'eand' sind andere Bezeichnungen für 'xor' und 'xand'.

mfg Spacerat


----------



## nitschchedu (29. Dez 2008)

Ich möchte noch auf Bezug zu PHP klar stellen das ich das da richtig umrechne 


```
public function StrToHex($string)
		{
		    $hex="";
		    
		    for ($i=0;$i<strlen($string);$i++)
		    {
		        $hex.=(strlen(dechex(ord($string[$i])))<2)? "0".dechex(ord($string[$i])): dechex(ord($string[$i]));
		    }
		    
		    return $hex;
		}
```

Aber danke für die Klasse ich Probiere es aus


----------



## Spacerat (29. Dez 2008)

Upsi... Da ist mir doch glatt noch ein Druckfehler in der Klasse aufgefallen... (erst jetzt, wo ich den Quelltext noch mal sehe...)
Und zwar die funktion "ead" sollte "eand" heissen. Ich selbst verwende "xand", deswegen fiel es wohl noch nicht auf.
Was solls... Sooowichtig ist das nun auch nicht. Aber ich verbesser das mal...
Ansonsten verwende ich das ganze schon länger und hatte bisher noch keine Probleme.

mfg Spacerat

@Edit: Ok Ok Ok... Der Quelltext war im Allgemeinen etwas älter... Da fehlt z.B. noch ein Postinkrement bei "not" und die "expand"-Methode tickte auch noch nicht richtig. Hab' mal alles durchgetestet. Jetzt funzt alles wie es sollte.


----------



## nitschchedu (29. Dez 2008)

Wie sollen das gehen oO ? 


```
HexString hex = HexString.parseHex(hexString);
return hex.toString();
```

Wäre echt toll wenn du mir mal die jeweilige Richtung erläutern könntest !


----------



## Spacerat (29. Dez 2008)

Mit ein bissl Code...

```
Integer integer = Integer.parseInt(IntString);
return integer.toString();
```
Das ist genauso, bis auf die Gewähleistung, das die Strings wirklich Integer-Werte oder in unserem Fall HexStrings sind, wenig Sinnvoll. Sinn macht es erst, wenn man mit den HexStrings, wie auch mit den Integern, rechnet. In dieser beziehung denke ich gerade noch über weitere Methoden nach. Z.B. "add", "sub", "divide" und "multiply", weil ich trotz Verwendung der SuperKlasse "Number" die dafür definierten zeichen nicht verwenden kann.

mfg Spacerat


----------



## nitschchedu (30. Dez 2008)

Ach so verstehe. Dann sehe ich dafür bei meinen beispiel keine Verwendung. 

Was ich will ist:
(String)Test => (String)1D2C3464
und
(String)1D2C3464 => (String)Test


----------



## Spacerat (30. Dez 2008)

Huh... ach so... ist ne Idee das zu implementieren...

mfg Spacerat


----------



## 0x7F800000 (30. Dez 2008)

nitschchedu hat gesagt.:
			
		

> Was ich will ist:
> (String)Test => (String)1D2C3464
> und
> (String)1D2C3464 => (String)Test


Dann verstehe ich leider immer noch nicht, was du willst.
Wenn man buchstaben aus "Test" durch jeweils 2-Stellige Hexadezimalzahl darstellt, dann kommt da "54657374" raus, und nicht "1D2C3464", es sei denn, man verschiebt das irgendwie.... ???:L


----------



## Spacerat (30. Dez 2008)

Sooo... wie wär's damit?

```
public static HexString fromCharSequence(CharSequence value)
  {
    if(value == null || value.length() == 0) throw new IllegalArgumentException("'value' may not be empty or 'null'");
    StringBuffer tmp = new StringBuffer();
    for(int i = 0; i < value.length(); i++) {
      tmp.append(Integer.toHexString(value.charAt(i)));
    }
    return new HexString(tmp.toString());
  }

  public final String toCharSequence()
  {
    String tmp = value;
    char add;
    if(tmp.length() % 2 != 0) tmp = "0" + tmp;
    StringBuffer rc = new StringBuffer();
    for(int i = 0; i < tmp.length() - 1; i += 2) {
      add = (char) Integer.parseInt(tmp.substring(i, i + 2), RADIX);
      rc.append(add);
    }
    return rc.toString();
  }
```
Ach so... das sind Methoden der Klasse HexString (wer hätte das gedacht?  ) und müssen natürlich dort eingefügt werden (hätte man 'nu ooch nich' jewusst  ).

mfg Spacerat


----------



## 0x7F800000 (30. Dez 2008)

macht das irgendwas anderes, als der code den ich auf der ersten Seite gepostet hab?

```
public static boolean isTwoHexDigitsEncodable(String s){
		for(int i=0; i<s.length(); i++){
			if(s.charAt(i)>(char)0xFF){
				return false;
			}
		}
		return true;
	}
	public static String toHexString(String text){
		StringBuilder builder=new StringBuilder(text.length()*2);
		char c;
		for(int i=0; i<text.length(); i++){
			builder.append( ((c=text.charAt(i))<(char)0x10?"0":"")+Integer.toHexString(c));
		}
		return builder.toString();
	}
	public static String fromHexString(String hex){
		StringBuilder b=new StringBuilder(hex.length()/2);
		for(int i=0; i<hex.length(); i+=2){
			b.append((char)(Integer.parseInt(hex.substring(i,i+2),16)));
		}
		return b.toString();	
	}
```

*Korrigiert am 4.1.2009, besten Dank an OP*

so, das wäre mein vorschlag nochmal, auch mit der umkehrfunktion.[/b]


----------



## Spacerat (30. Dez 2008)

@Andrey: Nee, nicht wirklich, bis auf Speichermehrbedarf wegen Printer.printf(). Ging es eingangs nicht auch mehr um die Antivalenz (Exklusiv-Oder) zweier HexStrings? Deswegen hatte ich ja mal den Quelltext einer Klasse rausgekramt (wenn auch nicht den aktuellsten), die ich schon seit Monaten oder sogar Jahren verwende. Gut... die beiden Methoden die "nietschedu" noch haben wollte gab's bei mir noch nicht, und deine schien mir aus den ogG verbesserungswürdig. Sorry.

mfg Spacerat


----------



## 0x7F800000 (30. Dez 2008)

> Speichermehrbedarf wegen Printer.printf()


ja, bei solchen banalen sachen sollte man in der tat lieber manuell die 0 drankleben, den PrintWriter nehm ich mal wieder aus dem code raus, da hast du schon recht :toll:


> Ging es eingangs nicht auch mehr um die Antivalenz (Exklusiv-Oder) zweier HexStrings? Deswegen hatte ich ja mal den Quelltext einer Klasse rausgekramt (wenn auch nicht den aktuellsten), die ich schon seit Monaten oder sogar Jahren verwende.


ich weiß es nicht mehr, weil der OP das anscheinend selbst nicht mehr weiß


----------



## nitschchedu (4. Jan 2009)

Andrey hat gesagt.:
			
		

> nitschchedu hat gesagt.:
> 
> 
> 
> ...



Das war nur Beispiel Hex ... keine Ahnung was das ergibt ..... sollte nur Demonstrieren wie ich es gerne umwandeln würde. 


Dann bedanke ich mich an dieser stelle mal und Probiere wieder alles aus 


@Test

Zu 



			
				Andrey hat gesagt.:
			
		

> macht das irgendwas anderes, als der code den ich auf der ersten Seite gepostet hab?
> 
> ```
> public static boolean isTwoHexDigitsEncodable(String s){
> ...



kommt folgendes raus  ???:L 



> cool mama
> 636f6f6c206d616d61
> c___ _a_a





@Patch

Hehe hab was gepatch das geht   


```
public static String fromHexString(String hex)
   {
      StringBuilder b=new StringBuilder(hex.length()/2);

      for(int i=0; i<hex.length(); i+=2)
      {
         b.append((char)Integer.parseInt(hex.substring(i, i+2) , 16));
      }

      return b.toString();
   }
```


----------



## 0x7F800000 (5. Jan 2009)

ooh man :shock:
Da hast du mich erwischt. Mein code liefert manchmal tatsächlich den totalen shice, hab "Test" unglücklich gewählt, da kam irgendwas richtiges raus, sorry


----------



## nitschchedu (6. Jan 2009)

So um wieder zum Xor zukommen woran kann es liegen das trotzdem bei jeder 4 stelle ein Falsches zeichen steht oO ? Und im PHP nicht. 


```
public String Crypt(String buff)
    {
        StringBuffer str = new StringBuffer();

        for(int i = 0; i < buff.length(); i++)
        {
           char a = 0x00;
           String mbyte = this.CryptXorTable[this.currentPosition];
           String mchar = buff.substring(i, i + 1);
           a = mchar.charAt(0);

           a ^= HexString.fromHexString(mbyte).charAt(0);

           str.append(a);

           this.currentPosition++;

           if(this.currentPosition == 0x1F3)
           {
               this.currentPosition = 0;
           }
        }


        return str.toString();
    }
```


CryptXorTable ist ein 500 grpßes Array mit HexZeichen wie "D1" usw. [/code]


----------



## nitschchedu (6. Jan 2009)

So um wieder zum Xor zukommen woran kann es liegen das trotzdem bei jeder 4 stelle ein Falsches zeichen steht oO ? Und im PHP nicht. 


```
public String Crypt(String buff)
    {
        StringBuffer str = new StringBuffer();

        for(int i = 0; i < buff.length(); i++)
        {
           char a = 0x00;
           String mbyte = this.CryptXorTable[this.currentPosition];
           String mchar = buff.substring(i, i + 1);
           a = mchar.charAt(0);

           a ^= HexString.fromHexString(mbyte).charAt(0);

           str.append(a);

           this.currentPosition++;

           if(this.currentPosition == 0x1F3)
           {
               this.currentPosition = 0;
           }
        }


        return str.toString();
    }
```


CryptXorTable ist ein 500 grpßes Array mit HexZeichen wie "D1" usw.


----------



## Murray (6. Jan 2009)

Was kommt denn, und was erwartest Du?


----------



## nitschchedu (6. Jan 2009)

Wieso erreicht beim Debugen mein Byte die 255 nicht <.< ?


----------



## Murray (6. Jan 2009)

Ohne Glaskugel schwer zu sagen. Was sind die Eingangsdaten, wie sieht das Crypt-Array aus, welche Implementierung steckt hinter HexString.fromHexString(mbyte)? Und welches Byte meinst Du? char a?


----------



## nitschchedu (6. Jan 2009)

Oki wir sind wieder beim Hex ..... laut Wireshark ist das angekommen am Socket 





> 2400c7c6d00a9cbd21892676726380f43dc29ad486a3f15763f4d665bd3fdbe4e10f50f6ec207e9611140e6653e7112aacd9133da5cee63f149fb50d3cb90e41e4679b87c30f


Stringlänge ist 70.

Am socket kommen genau 70 an, doch umgewandelt mit der Funktion von oben kommt.


```
public static String toHexString(String text)
   {
      StringBuilder builder=new StringBuilder(text.length()*2);
      char c;

      for(int i=0; i<text.length(); i++)
      {
         builder.append( ((c=text.charAt(i))<(char)0x10 ? "0" : "")+Integer.toHexString(c));
      }

      return builder.toString();
   }
```



> 2400c7c6d00a153bd2120302676726320acf43dc2161d42020a3f15763f4d665bd3fdbe4e10f50f6ec207e201311140e6653e7112aacd9133da5cee63f14178b50d3cb90e41e467203a2021c30f



1. Bissel viel und dann stimmen immer mal zwischen drin Zeichen nicht 



> 2400c7c6d00a9cbd2189...





> 2400c7c6d00a153bd21203...





@Nehme ich oben den String vom Wireshark so kommt alles richtig raus.
Kann dies auch an meiner Socket lese Funktion liegen ?:

```
private Socket client;
private PrintWriter out;
private BufferedReader in;

.....

this.in = new BufferedReader(new InputStreamReader(this.client.getInputStream()));

.....

 private String ReadPacket()
    {
        String buff = "";
        char[] buffer = new char[65536];

        try
        {
            int anz = this.in.read(buffer, 0, 65536);
            buff = new String(buffer, 0, anz);
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }

        System.out.println(HexString.toHexString(buff)); // <--- Fehler bei der Umwandlung
        return buff;
    }
```


----------



## Murray (6. Jan 2009)

Da hier offenbar Binärdaten über den Stream gehen, solltest Du diese Daten nicht als textuelle Daten behandeln - nimm also keinen Reader, sondern lies vom InputStream die Bytes ein (und eben keine chars). Irgendwelche Byte-Manipulationen sollten dann auch auf der Byte-Ebene erfolgen (und eben nicht in irgendeiner String-Repräsentation dieser Daten).


----------



## Spacerat (8. Jan 2009)

Huh... Hab' ich mir die Mühe mit meiner Implementation umsonst gemacht (HINT: NÖÖÖÖÖ)? Fakt ist, das diese 70 Bytes bei dieser korrekterweise einen String von genau 140 Zeichen ergibt. Ich versuche mal dir zu folgen...
Du möchtest also den Stream verschlüsseln (Crypt). Etwa so?

```
... je nachdem was ankommt (Text oder Hexstrings)...
public String CryptHex(String in, boolean asCharSequence)
{
    HexString a = HexString.parse(in);
    HexString b = HexString.parse(cryptstring);
    a = HexMath.xor(a, b);
    return (asCharSequence)? a.toCharSequence() : a.toString();
}

public String CryptText(String in, boolean asCharSequence)
{
    HexString a = HexString.fromCharSequence(in);
    HexString b = HexString.parse(cryptstring);
    a = HexMath.xor(a, b);
    return (asCharSequence)? a.toCharSequence() : a.toString();
}
```

den "cryptstring" solltest du als Klassen-Konstante (private static final HexSting) deklarieren. Wie man unschwer erkennen kann steuert "asCharSequence" die Ausgabe. Möglicherweise muß der "cryptstring" aber vorher noch in der Länge angepasst werden, da die HexMath-Methoden den jeweils kürzeren String mit vorangestellten "0"en auffüllt.
Im übrigen hat Murray mit seinem Vorschlag, das Ganze mit Byte-Arrays durchzuführen, natürlich vollkommen recht. Ich denke derweil noch über die jeweiligen "parse" und Ausgabemethoden dafur nach (hat natürlich nicht mit Murrays Vorschlag zu tun, obwohl mich gerade dieser dazu inspiriert hat).

mfg Spacerat


----------

