BitEbene

[teddy]

hallo

wie programmiert man bei java am besten auf bitebene..geht das überhaupt?


ich würde...gerne...mit strings arbeiten..aber...auf bitebene...



eventuell auch ascii....


gibt es da ne bestimmte klassen..etc?

 

[8ull23y3]

Was meinst du mit Bitebene?
Probier mal char(charakter) aus!
char c = 0x08; <- Sollte aber nur in der Konsole funktionieren.
Meinst du sowas?

 

[kopfsalat]

Um Bits beliebig zu manipulieren kannst du die Bitoperationen nutzen: ~(NOT) ^ (XOR) | (OR) & (AND)
z.B. 8. Bit in a setzen:

a |= 0x80 // 0x80 = Bits: 10000000

Bei Strings und char musst Du vorsichtig sein, da Java Unicode unterstützt und somit weit mehr als den ASCII-Satz darstellen kann. Einen String kannst Du aber alternativ (anstelle von einem Char-Array) auch in ein Byte-Array aufbrechen, dabei wird dann sicherlich nach ASCII gewandelt.

 

[teddy]

ich meine..

string nehmen.....etc..

und daraus..dann die bits auslesen...

aber wie mach ich das am besten...?


z.B

String = "hallo welt";

und dann daraus..

die bits...


01010101010000101010101010101010

etc...kennt das ja^^

 

[Roar]

guck dir an String#getBytes() und Integer.toBinaryString()

 

[teddy]

thx...werd es mir mal anschauen ;D

 

[Gast]

kann mir jemand sagen wie die Sache gelöst wurde? ich brauch das nämlich auch und komm nicht weiter :/

 

[PoiSoN]

Wo genau kommst du nicht weiter?
Hast du dir die Methoden von Roar angesehen?

 

[Guest]

ja angenommen ich soll einen Text in 4 Bit-Blöcke umwandeln:

String s = "Hallo wie geht es dir";
byte arr[] = new byte[s.length()]; 
arr = s.getBytes();

for (int i=0; i<arr.length; i++) 
{
	//Hier weiß ich nicht mehr weiter
}

:?:

 

[SnooP]

Nunja - 4Bit Blöcke - also Nibbles musst du auch gezielter aussortieren. Durch getBytes bekommst du ein komplettes Byte. Wenn du 4-Bit Blöcke haben willst, musst du ja jedes Byte in zwei Nibbles aufteilen... ein oberes und ein unteres, dazu brauchst du ein nibbles-array - mit doppelt soviel Elementen, wie das Originale, oder?

//wie oben +
byte nibbles[] = new byte[arr.length*2];
   for (int i = 0;i< arr.length;i++) {
     nibbles[2*i] = (byte)(arr[i] >> 4);   //höherwertiges Nibble
     nibbles[2*i+1] = (byte)(arr[i] & 0x0F);  //niederwertiges Nibble
   }

Wozu auch immer du sowas haben möchtest

 

[Gast]

ok und wenn ich jetz z.b. 16 Bit-Blöcke will?

ich sag mal wofür ich das brauch:
ich will den RSA-Algorithmus einsetzen, und dafür muss ich laut meinem Kryptographiebuch den Klartext in Bitblöcke der Länge N-1 einteilen und den verschlüsselten Text zum Entschlüsseln in Bitblöcke der Länge N.

Ich weiß aber nicht genau wie das geht und wie ich mit den Bitblöcken dann weiterrechne, ich denk mal ich wandel die Bitzahl in eine Dezimalzahl um, rechne damit und wandel sie zum schluss wieder in ne Bitzahl um oder so

 

[Bleiglanz]

welches Lehrbuch ist das?

willst du die Java JCA/JCE verwenden - dann brauchst du nichts zu machen?

Hinweis: BigInteger kann man ohne Probleme in ein byte[] verwandeln (und zwar in beide Richtungen)

 

[SnooP]

1. Alsooo... die Bitblockgröße variabel zu halten geht durchaus... - wird aber immer schwierig sein die ursprünglichen Daten aufzutrennen - das geht am besten, wenn man entsprechende Methoden hat und die Daten serialisieren kann und dann seriell - also Zeichen für Zeichen oder Bit für Bit einlesen kann... dann kann man nach und nach ein Array mit den gewünschten Blockgrößen füllen.

RSA liegt schon länger zurück, aber kommt das N-1 nicht automatisch zu stande, wenn du das Eingangswort %N nimmst, falls N das Produkt von p*q ist? Das heißt die Blöcke die du kodierst müssen im Zahlenbereich des Moduls liegen. Dadurch kannst du mehrere Zeichen in einen Block bekommen...
Wir haben das damals so gemacht, dass wir den Text so kodiert haben (3-Zeichen pro Block):
a*26^2+b*26^1+c*26^0 - das war dann der zu kodierende Block.
Beim dekodieren kannst du durch das am höchsten passende Produkt von 26^n teilen und bekommst das erste Zeichen, dann davon den Rest nehmen und durch den nächsthöchsten teilen etc.:

d = decrypt(code);
z1 = d/26*26;
d %= 26*26;
z2 = d/26;
d %= 26;
z3 = d;

Das kann man natürlich für größere Blöcke auch generalisieren...

2. Du musst glaub ich davon ab zu glauben, da wird in Bits umgerechnet. Das binäre Zahlensystem ist wie jedes andere Zahlensystem nur eine andere Sichtweise auf die Zahl schlechthin. Die Zahl bleibt ansonsten immer die gleiche, egal in welchem System man sie sich anschaut. D.h. du musst in keine Bitzahl umwandeln oder in eine Dezimalzahl zurückwandeln, sie ist beides gleichzeitig ... 255 ist intern nix anderes als 11111111 oder 0xFF oder auch 16^2-1

3. BigInteger solltest du dir angucken - das brauchst du zum Berechnen definitiv!

 

[Gast]

na gut, angenommen ich hab einen Text "hallo wie gehts dir"

wie teil ich den in 16 Bit Blöcke auf und rechne damit weiter?

 

[SnooP]

wenn getBytes dir 8-Bit Blöcke liefert, also jedes Zeichen in ein byte-Element schreibt, dann sind 16-Bit Blöcke zwei Zeichen... Sprich du brauchst ein short-Array und musst in ein Element zwei Bytes reinknallen:

//arr ist das Byte-Array
short[] blocks = new short[arr.length/2];
for (int i =0; i<arr.length;i+=2) {
  blocks[i/2]=(short)(arr[i] << 8 | arr[i+1]);
}

Bei mehr als 64-Bit Blöcken brauchst du dann natürlich für die Blöcke auch BigInteger.