Diverse kleinere Verständnisprobleme

[Ishildur]

Hallo zusammen, ich habe ein paar kleinere Frage zu Java:

1. Wenn ich folgendes schreibe:
byte a = 0xf3;
Dann bekomme ich eine Fehlermeldung vom Compiler ich muss dann folgendes schreiben:
byte a = (byte)0xf3;
Kann man dies nicht irgendwie umgehen? für Long gibts ja 0x89l oder für float ein 0.01f gibts sowas nicht auch für bytes und shorts?

2. Ich schreibe folgendes:

byte va2 = (byte)0x83;
short tmp = va2;
System.out.format("%x\n",tmp);

Nun steht auf dem Bildschirm 0xff83.

Auch diese schreibweise bringt nichts:

short tmp = 0x0000;
byte va2 = (byte)0x83;
tmp = va2;
System.out.format("%x\n",tmp);

Java füllt also einfach die ersten 16-Bits mit 1sen, was soll denn dass? :x

 

[dieta]

Das könnte vllt. daran liegen, dass du mit deiner ersten Anweisung einen Buffer-Überlauf erzeugst, der Wertbereich eines Bytes geht nur bis 127 und du versuchst ihm da eine 131 zuzuweisen.

 

[SlaterB]

das ist dann im zweiten Beispiel - 125

und -125 in short ist nun mal in der Darstellung 0xff83
(das erste Bit ist 1 für das Negationszeichen oder ähnlich)

 

[Ishildur]

Ach so OK, alles klar, gibts denn auch ein unsigned byte oder unsigned char?

 

[SlaterB]

ja, short
bzw. int falls char so groß wie short ist,

 

[Ishildur (PassLost)]

Hallo es geht um den Verschlüsselungsalgorithmus Rijndael und ich muss bspw. eine Polynommultiplikation in einm GF(2^8) vornehmen und dies arbeitet eben nun mal auf Byteebene:

Kurzer Ausschnitt:

// ------------------- method polynomial addition in F(2^8) -------------------
 public static byte gf256_add(byte va1,byte va2){
  // return the result of a xor - operation between va1 and va2
  return (byte)(va1 ^ va2);
 }
 // ----------------------------------------------------------------------------
 
 // ---------------- method polynomial multiplication in F(2^8) ----------------
 public static byte gf256_mul(int va1,int va2){
  // declare and init local variables
  int rst = 0x00000000; // the result value
 
  // loop for walking each bit beginning a the less significant bit
  for(int i=0;i<8;++i){
   // check if the current bit of the factor was set
   if((va1 & (0x01 << i)) != 0x00)
    // shift the second factor by the current line and xor it by the result
    rst ^= (va2 << i);
  }
 
  // loop for walking each bit beginning at the most significant bit
  for(int i=0;i<16;++i){
   // check if the result is greater or equal the dividor and if the current
   // bit of the subresult was set was set
   if(rst >= 0x11b && (rst & (0x8000 >> i)) != 0x00)
    // shift the dividor as needed and xor it by the result
    rst ^= (0x11b << 0x07 - i);
  }
  
  // return the result
  return (byte)rst;
 }
}
// -----------------------------------------------------------------------------

Und nun habe ich folgendes Problem:

Wenn ich nun ein Inputbyte 0xF8 und diese in einen Integer kopiere, dann steht da einfach nicht wie erwartet 0x000000F8 drinn, sondern 0xFFFFFFF8, wieso wurde zwar weiter oben erklährt, nur leider wurde dabei keine Lösung angegeben: Wenn ich den Code folgendermassen ändere:

Wenn ich im obigen Code nur folgendes verändere:

// ---------------- method polynomial multiplication in F(2^8) ----------------
 public static byte gf256_mul(byte va1,byte va2){

Dann stimmt das Resultat natürlich nicht mehr! Also ich bin ziemlich neu in java, aber in jeder anderen mir bekannten Programmiersprache kann man definieren, ob eine variable signed oder unsigned ist.

@SlaterB
Das funktioniert leider nicht, da ich die zu verschlüsselten Daten in einem Bytestrom erhalten werde und so immer nur ein Byte habe, welche in einen grösseren Behälter (Integer) kopieren muss, um ein Bitshifting ohne Overflow zu ermöglichen.

Es muss doch eine Möglichkeit geben, variablen unabhängig vom Vorzeichen zu kopieren?

Lg Ishildur

 

[Guest]

Ich könnte natürlich so was machen, aber hohler gehts ja wohl nicht mehr:
int vai1 = va1 & 0x000000ff;

 

[Guest]

Hab das Problem gelöst. Ein gutes Gefühl habe ich dabei allerdings nicht: Da soll noch einer behaupten, Java sei typensicher:

// ---------------- method polynomial multiplication in F(2^8) ----------------
 public static byte gf256_mul(byte va1,byte va2){
  // declare and init local variables
  int rst = 0x00000000; // the result value
  
  // loop for walking each bit beginning a the less significant bit
  for(int i=0;i<8;++i){
   // check if the current bit of the factor was set
   if((va1 & (0x01 << i)) != 0x00){
    // shift the second factor by the current line and xor it by the result
    int tmp = va2 & 0x000000ff;
    rst ^= (tmp << i);
   }
  }
 
  // loop for walking each bit beginning at the most significant bit
  for(int i=0;i<16;++i){
   // check if the result is greater or equal the dividor and if the current
   // bit of the subresult was set was set
   if(rst >= 0x11b && (rst & (0x8000 >> i)) != 0x00)
    // shift the dividor as needed and xor it by the result
    rst ^= (0x11b << 0x07 - i);
  }
  
  // return the result
  return (byte)rst;
 }
}
// -----------------------------------------------------------------------------

 

[SlaterB]

wenn Java das für dich machen würde, dann wäre das intern doch auch nix anderes,
also was stört dich daran?

ich stimme dir zu, dass es ziemlich blöde ist, das Java mit dieser Art bytes (auf den ersten Blick) nicht kompatibel ist,
habe gerade selber ein kleines Bildbearbeitungsprogramm gebastelt und dort eine bmp-Datei als byte-Array eingelesen..,

aber ist ja nun kein Aufwand, ein paar 5 Zeilen-Operationen und evtl. ein paar spezielle Wrapper-Klassen zur Konvertierung,
dann läuft dein restliches Programm einwandfrei,

wenn dir Java nicht mehr gefällt, was an dieser Stelle verständlich ist,
dann musst du die Sprache wechseln,
ansonsten bleiben und die anderen Vorzüge nutzten,
schimpfen hilft leider nicht