# Länge einer Hexadezimalzahl in Bits



## andreas2505 (8. Jul 2011)

Hallo,

ich benötige eine Funktion/Methode, um die Länge eines Strings in bits zu berechnen, also z.B.

String s1 = "50" --> int l1 (Länge) = 6
String s2 = "CEE88040" --> int l2 = 27

Gibt es da schon was vorgefertigtes oder eine einfach Methode?


----------



## diggaa1984 (8. Jul 2011)

wie kommste denn auf die bsp-werte für die length!?
ein string in bitlänge wäre eigentlich simpel: "foo".getBytes().length * 8


----------



## SlaterB (8. Jul 2011)

die Strings sollen wohl Hex-Werte sein? ne Zahl draus machen, Integer.toBinaryString()

edit: ok, '8' passt nicht so gut und Integer.toBinaryString(50) liefert zufällig 6 Stellen, 
aber das wäre dann ja 50 direkt, nicht 50 Hex..

edit: irgendwie denke ich immer dass bei es bei Hex keine 8 und 9 gibt, stimmt natürlich nicht, das ist Octal


----------



## bone2 (8. Jul 2011)

ich komme nicht auf 27. was soll das für eine zählweise sein?


----------



## andreas2505 (8. Jul 2011)

also ja es geht hier um hexadezimale strings.

Ich weiß ja auch nicht wie die darauf kommen. Ich weiß nur, dass es so ist und brauche dringend eine Methode, die das berechnen kann.


----------



## SlaterB (8. Jul 2011)

> Ich weiß ja auch nicht wie die darauf kommen.

50 Hex hat nachweislich eine Länge von 7, 
unbekannte ungeklärte Dinge hier zu diskutieren macht keinen Sinn,

ansonsten habe ich es ja schon beantwortet, 
falls du den Schritt String -> Zahl nicht kennst, da gibt es parse-Methoden,
vielleicht besser aus der Long-Klasse statt Integer

-------

noch eine anschauliche Umrechung: jeder Hex-Wert braucht 4 Bits, 
ein Byte von 8 Bit läßt sich immer als 2 Hex darstellen (00 bis FF), das kennst du vielleicht,

"CEE88040" hat 7 volle Stellen, die alleine benötigen 7*4 = 28 Bits, das erste C auch noch 4, macht 32


----------



## Gast2 (8. Jul 2011)

diggaa1984 hat gesagt.:


> wie kommste denn auf die bsp-werte für die length!?
> ein string in bitlänge wäre eigentlich simpel: "foo".getBytes().length * 8



<-- Das wäre eigentlich die Antwort auf deine ursprügnliche Frage gewesen. 

Was du meintest war jedoch: "Anzahl der Stellen einer Hexadezimalzahl, gespeichert in einem String, in Bit, ausrechnen." 

Achte bitte darauf deine Fragen deutlicher zu stellen, da es sonst schwierig ist zu erraten was du wohl meintest. Mir viel es echt schwer.


----------



## andreas2505 (8. Jul 2011)

ok, ja das stimmt. 

Was ich meine sind wohl die Anzahl der Stellen einer Hexadezimalzahl, gespeichert in einem String, in Bit

Wie kann man die denn berechnen?


----------



## faetzminator (8. Jul 2011)

andreas2505 hat gesagt.:


> Was ich meine sind wohl die Anzahl der Stellen einer Hexadezimalzahl, gespeichert in einem String, in Bit
> Wie kann man die denn berechnen?



Das meinst du wohl nicht. Denn ein Byte (String#getBytes()) hat immer 8 Bits. Und weder 6 noch 27 ist restlos durch 8 teilbar.


----------



## diggaa1984 (8. Jul 2011)

im prinzip wissen wir doch was er sucht, nur uns fällt keine lösung ein  ... im zweifelsfall sollte der TO mal seine ihm präsentierte Aufgabenstellung 1:1 widergeben.


----------



## andreas2505 (8. Jul 2011)

das problem ist, dass ich ja wirklich nicht zu hundert Prozent sagen kann, was ich suche.
Ich weiß nur, dass ich ein String habe in hexadzimaler Form und dazu irgendeine Länge, welche ich ja für die obigen Beispiele mal angegeben habe (ich kann auch noch mehr angeben).
Und ich suche halt irgendeinen Weg, wie man auf diese Werte kommt.


----------



## Dekker (8. Jul 2011)

Dann tu das mal.

Ich bin nicht mit Diggas Post einverstanden, ich bin mir nicht sicher was der TE wirklich machen muss und was er sucht. So wie ich das verstehe möchte er im Grunde wissen, wieviel Bit man zur Darstellung der Zahl in Binärdarstellung minimal benötigt. Für 0x50 = 0101 0000 in binär wären das 7 Bit. Für 0xCEE88040 =11001110111010001000000001000000 kommt man aber auf 32 Stellen und nicht auf 27. Entweder stimmt die Aufgabe nicht, oder der TE hat sich verlesen / vertippt. So macht das keinen Sinn zu raten.
Ergo wäre es sinnvoll mehr Beispiele zu haben. Im übrigen würde die Aufgabe dann auch nicht mit getBytes.length funktionieren. Da könnte er getBytes machen und müsste dann mittels ner Maske durch verunden die Vorderste eins im MSB suchen und daraus dann die Länge bestimmen.


----------



## andreas2505 (8. Jul 2011)

ok, hier mal etwas ausführlicher, so wie es da steht wo ich es her habe:

message der Länge 29

input message (last byte alligned on MSB):
53 58 7B C8

input message in bits
01010011010110000111101111001

hier von mir aus auch noch ein paar beispiele (nur mir wort und länge)

Länge      Wort
4            80
16          41FB
36          0127A1D340
58          42DA39AC5951FEC0

vielleicht kann jetzt jemand verstehen, was ich brauche und mir vielleicht auch sagen, wie ich darauf komme...


----------



## bERt0r (8. Jul 2011)

Also meiner Meinung nach stimmt da was nicht, bzw. musst du uns erst erklären was "(last byte alligned on MSB)" hier bedeutet. Last byte von was, MSB=most significant byte???.
Was mir allerdings aufgefallen ist:
Hex: 53 58 7B C8
01010011010110000111101111001000   in Binär
01010011010110000111101111001        in deiner Angabe

Da is doch was faul.


----------



## andreas2505 (8. Jul 2011)

tja ich weiß selber nicht so genau was das bedueten soll...

vielleicht ist das ja die Lösung, das die Nullen weggelassen werden...

habs grad nochmal an den 4 Beispielen nachgeprüft. Das haut hin, wenn man die Nullen am Ende weglässt. Was auch immer das für einen Sinn ergibt...

Weiß denn jemand, wie man nun die Anzahl von Nullen dort ermittelt, bzw. die Länge ohne die Nullen...


----------



## Ebenius (8. Jul 2011)

Das wäre ja klasse. Wir erzählen das dem Herrn Papandreou und der macht dann aus 273.400.000.000 € grad 2.734 € … 

Ebenius

PS: Most Significant Byte ist lustisch.


----------



## Dekker (9. Jul 2011)

Hm, ich glaube gemeint ist, das das letzte Byte, wenn man von rechts nach links ließt, das MSB ist. Aber irgendwie macht das für mich nicht so Sinn die Nullen hintendran wegzulassen... Aber nun gut wir wollen ja hier nicht über Sinn und Unsinn von schwachsinnigen Aufgaben reden.

Kurzer Tipp (schnell hingehackt...) was du als Grundlage verwenden kannst um dein Problem zu lösen:


```
public static void main(String[] args) {
		byte a = (byte)0x10;
		byte mask = (byte)0x01;
		int counter = 0;
		boolean found = false;
		
		while(counter < 8 && !found){
			if((a & mask) != (byte)0x00)
			{
				System.out.println("Anzahl der Nullen: " + counter);
				found = true;
			}
			mask <<= 1;
			counter ++;
		}
	}
```


----------



## bERt0r (9. Jul 2011)

Das Problem ist nur, dass das Most significant byte das erste  byte und nicht das letzte ist. Im fall von 
01010011010110000111101111001000
wäre 0101
oder zumindest  1010
das most significant byte, weil es ja den grösten unterschied in der Zahl, die am Ende rauskommt ausmacht. Ich habe noch nie von algorithmen gehört, die das Most significant byte verändern. Ich weis, dass bei Steganographie das Least Significant byte verändert wird, also das byte das am wenigsten unterschied macht.
Mein Rat an den Topic Starter: poste die Angabe für deine Hausübung 1:1, sonst wird dir hier niemand helfen können.


----------



## TimoH. (9. Jul 2011)

wie ich das sehe hast du doch nen String welcher ein Hex-Wert repräsentiert, und sollst ermitteln wie lang
die zahl in Binärdarstellung ist.

Warum machst du dann nicht einfach string.length()*4;
So berücksichtigst du auch die 0 am ende, was in den Beispielen nicht der Fall ist.

Das geht so schön einfach, weil Hex (16) eine Potenz von 2 (Binär) ist.

Du kannst auch den Hex wert dann auch ganz einfach umwandeln:

Bsp:   A      7      0
       1010 0111 0000

Vlt. hilft es 

mfg Timo


----------



## andreas2505 (9. Jul 2011)

> Warum machst du dann nicht einfach string.length()*4;



das kann nicht funktionieren, weil z.B. bei Länge 58 --> 42DA39AC5951FEC0
erst die 4 Nullen von 0000 wegfallen und dann noch zwei Nullen von dem C (1100), deshalb 64-6=58 



> Mein Rat an den Topic Starter: poste die Angabe für deine Hausübung 1:1, sonst wird dir hier niemand helfen können.



ist nur schwer möglich. Meine Aufgabe ist es die KECCAK Hashfunktion zu implementieren. Es ist auch alles soweit fertig. Bloß muss ich diesen Wert von der Länge eine hexadezimalen Strings berechnen können.

Wie es funktioniert soll, wissen wir ja mittlerweile. Wie nehmen die Anzahl an Stellen (also die Länge string.length()*4 und ziehen dann von hinten alle Nullen ab, bis die nächste 1 kommt. Dann haben wir die Länge. Bloß wie kann man das implementieren?


----------



## Dekker (9. Jul 2011)

bERt0r hat gesagt.:


> Das Problem ist nur, dass das Most significant byte das erste  byte und nicht das letzte ist. Im fall von
> 01010011010110000111101111001000
> wäre 0101
> oder zumindest  1010
> ...



Schonmal was von Big und Little Endian gehört? Beim Little Endian steht das MSB an der niedrigsten Adresse im Speicher, beim Big Endian an der höchsten Adresse.


----------



## Spacerat (9. Jul 2011)

da's definitiv was faul...
1. dezimal 50 ist hexadezimal 32 -> 6 Bits (0-5)
2. CEE88040 umgedreht ist (0) 4088EEC -> 27 Bits (0-26)
3. Big Endian: 40808ECE -> 31 Bits (0-31)

Daraus folgt, dass es sich nicht mal mit Little- bzw. Big Endian lösen lässt.
Die Beispielergebnisse sehen wirklich sehr nach "hingezaubert" aus. Denke nicht, dass da ein vernünftiger Algo hintersteckt.


----------



## andreas2505 (9. Jul 2011)

> 1. dezimal 50 ist hexadezimal 32 -> 6 Bits (0-5)



das waren alles bereits hexadezimale Werte die ich vorgegeben hab, also 50 hexadezimal!

Ich hab ja gesagt, wie der Algorithmus abläuft.
Den Wert in Bits aufschreiben, also z.B.

50 -->  01010000 

und dann von hinten alle Nullen wegmachen, bis die erste 1 kommt!, also

Länge (50) --> 0101, also 4

die Frage ist nur, wie man das als bits darstellen kann und dann alle Nullen abzieht


----------



## Spacerat (9. Jul 2011)

Vllt. in dieser Art?

```
import java.math.BigInteger;

public class HEX_TO_BIN_STRING
{
	public static void main(String[] args)
	{
		// Test mit CEE88040;
		long test = 0xCEE88040L; // long, sonst wird's negativ
		BigInteger bi = BigInteger.valueOf(test);
		System.out.println(bi.toString(16).toUpperCase());
		String bin = bi.toString(2);
		while(bin.length() % 2 != 0) {
			bin = "0" + bin;
		}
		System.out.println(bin);
		int index = bin.length() - 1;
		while(bin.charAt(index) == '0') {
			index--;
		}
		bin = bin.substring(0, index + 1);
		System.out.println(bin + " (" + bin.length() + ")");
		System.out.println();

		// Test mit 50;
		test = 0x50L; // long, sonst wird's negativ
		bi = BigInteger.valueOf(test);
		System.out.println(bi.toString(16).toUpperCase());
		bin = bi.toString(2);
		while(bin.length() % 2 != 0) {
			bin = "0" + bin;
		}
		System.out.println(bin);
		index = bin.length() - 1;
		while(bin.charAt(index) == '0') {
			index--;
		}
		bin = bin.substring(0, index + 1);
		System.out.println(bin + " (" + bin.length() + ")");
	}
}
```


----------



## andreas2505 (9. Jul 2011)

das funktioniert aber leider auch nicht, zumindest nicht bei allen.

Bsp. 0127A1D340 kommt statt 36  28 raus

ich habe gelesen es gibt eine klasse bitset in java, mit welcher man das vielleicht machen könnte, aber wie kriegt man den string überhaupt in die bitset rein (in bits)


----------



## Spacerat (9. Jul 2011)

andreas2505 hat gesagt.:


> das funktioniert aber leider auch nicht, zumindest nicht bei allen.
> 
> Bsp. 0127A1D340 kommt statt 36  28 raus


Dann erklär' dem lieben Forum doch mal, wie du auf deine Ergebnisse kommst. Sind die etwa vorgegeben? Weil egal, was man nun noch wie dreht, deine Ergebnisse lassen sich iwie nicht berechnen. Auch mit BitSet nicht.
Also ich komme zumindest noch auf 30, wenn ich in meinem Code "% 4" statt "% 2" (Zeilen 12 und 29) schreibe.


----------



## andreas2505 (9. Jul 2011)

ja die Ergebnisse sind vorgegeben!

Hab ich doch schon gesagt. Hier nochmal ein paar Werte:


```
Len = 1
Msg = 00

Len = 2
Msg = C0

Len = 3
Msg = C0

Len = 4
Msg = 80

Len = 5
Msg = 48

Len = 6
Msg = 50

Len = 7
Msg = 98

Len = 8
Msg = CC

Len = 9
Msg = 9800

Len = 10
Msg = 9D40

Len = 11
Msg = AA80

Len = 12
Msg = 9830

Len = 13
Msg = 5030

Len = 14
Msg = 4D24

Len = 15
Msg = CBDE

Len = 16
Msg = 41FB

Len = 17
Msg = 4FF400

Len = 18
Msg = FD0440

Len = 19
Msg = 424D00

Len = 20
Msg = 3FDEE0

Len = 21
Msg = 335768

Len = 22
Msg = 051E7C

Len = 23
Msg = 717F8C

Len = 24
Msg = 1F877C

Len = 25
Msg = EB35CF80
```

so das reicht hoffentlich, damit mir keiner mehr unterstellt, ich denk mir die Werte aus.

Wie die (per Handrechnung für mich) darauf kommen, hab ich ja erklärt. Hier das habe ich noch in einem der Ihrer Paper gefunden, was evtl. helfen könnte.



> The bits of the
> input message M are numbered from i = 0 to i = |M| - 1. When the bits are gathered in
> bytes, it implies the equivalent numbering i = ibit + 8ibyte with 0 <= ibit < 8.
> In our internal convention, ibit = 0 indicates the least signicant bit (LSB) of a byte while
> ...


----------



## faetzminator (10. Jul 2011)

[c]C0[/c] ist also sowohl 2 als auch 3  ?


----------



## andreas2505 (10. Jul 2011)

genauso steht es da drin. Keine Ahnung warum...

Ich glaube auch anhand dieser Werte nicht mehr, dass es stimmt, dass man immer nur die Nullen wegnehmen muss, weil das stimmt bei Länge 6 oder 9 ja z.B. auch nicht.


----------



## diggaa1984 (10. Jul 2011)

also selbst mit der beschreibung da .. ich kann probieren was ich will für manche klappt mein verständnis des algos für manche wieder nicht, änder ich bissel was ab, weil ich glaube es falsch verstanden zu haben, klappts wieder für andere, aber für vorherige nicht mehr .. irgendwie is da echt der wurm drin ^^

mal als bsp:

98 = länge 7 ... 1001 1000 .. so fangen wir an .. da kann ich kreativ sein wie ich will und drehen und machen und shiften, damit es annähernd dem algorithmus ähnelt .. ohne willkür komm ich da nicht auf ne anreihung, die 7 bits füllt. und wenn ich davon ausgehe das mit length vielleicht sogar die position des letzten relevanten bits genannt sei .. dann frag ich mich wie die bei 00 = 0000 0000 auf 1 kommen wollen?!

wie gesagt, man kann es für manche passend hinbekommen aber nicht für alle, so wie ich das hier versucht hab.


----------



## Dekker (10. Jul 2011)

andreas2505 hat gesagt.:


> genauso steht es da drin. Keine Ahnung warum...
> 
> Ich glaube auch anhand dieser Werte nicht mehr, dass es stimmt, dass man immer nur die Nullen wegnehmen muss, weil das stimmt bei Länge 6 oder 9 ja z.B. auch nicht.



Ist das ein veröffentlichtes Paper? Falls ja, geb mal ne Quelle an. So langsam möchte ich mir das Paper mal ansehen. Das kann doch nicht sein das da so ein Murks bei rumkommt.

Zumindest bei C0 = 2 & C0 = 3 ist den sicherlich ein Fehler unterlaufen.


----------



## diggaa1984 (10. Jul 2011)

ja bei C0 = 2 oder 3 denk ich is eher n fehler beim aufgabensteller .. das kann so definitiv nicht hinhauen, aber an dem paar sollte man sich nich aufhängen .. gibt ja genug andere wertepaare die es zu knacken gilt


----------



## andreas2505 (10. Jul 2011)

> Ist das ein veröffentlichtes Paper? Falls ja, geb mal ne Quelle an. So langsam möchte ich mir das Paper mal ansehen. Das kann doch nicht sein das da so ein Murks bei rumkommt.



Ich denke auch, dass genau bei dem einen Beispiel von 2 und 3 ein Fehler vorliegt...
Das ist eine offizielle Datei: The Keccak sponge function family und dort runterladen : Known-answer and Monte Carlo test results version 3.0
und nach dem runterladen auf ShortMsgKAT_egal gehen und da stehen die Werte!

auf der seite sind auch die ganzen anderen paper... 
den ausschnitt aus dem einen, wo etwas dazu stand hab ich ja schon gepostet...


----------



## Ariol (10. Jul 2011)

Siehe auch hier

Ich weiß nicht was an der Formel nicht so ist, wie du das gerne hättest?


```
int my_string_length = M.length()*4;
        int pos=M.length()-1;
        for(; pos > 0; pos--)
        {
            if(M.charAt(pos)!='0')
                break;
            my_string_length-=4;
        }
        String hexValue = ""+M.charAt(pos);
        int value = Integer.parseInt(hexValue, 16);
        String binValue = Integer.toString(value, 2);
        my_string_length-=(binValue.length()-binValue.lastIndexOf('1')-1);
```

Ergibt folgende Werte:

```
C0=2
EB35CF80=25
50=4
5030=12
```

Edit: Ich glaube deine Beispielliste ist falsch:
0x50 = 10010000 => Länge 4
Woher da 6 gesetzte Bit kommen sollen ist mir absolut schleierhaft.


----------



## andreas2505 (10. Jul 2011)

Ich denke mir ja die Werte nicht aus!!!

Ich weiß ja dass es eigentlich das macht, aber in der Übersicht (die ihr euch ja auch alle mal angucken könnt) sind noch mehr solche Wertepaare wo es nicht hinhaut!!!

Bsp.   17    -->   4FF400
ist ja eigentlich 010011111111010000000000
damit müsste Länge 14 rauskommen


oder   19   -->   424D00
010000100100110100000000
müsste ja eigentlich 16 rauskommen.

Die haben sich ja nicht bei jedem Beispiel verschrieben!!!

Also muss da irgendein anderer "Trick" dahinter stecken, aber ich weiß ihn leider auch nicht.


----------



## Unregistrierter (10. Jul 2011)

Unglaublich eh!
Anstatt hier die Zeit von so vielen Leuten (+ die, die bisher hier nur gelesenhaben wie ich) zu vergeuden die hier 2 Seiten lang versucht haben aus deinen unvollständigen, falschen und zusammengeratenen Informationen eine sinnvolle Fragestellung und Lösung zu erkennen, hättest du vielleicht erstmal selber ein bisschen recherchieren können was das überhaupt für Daten sind die du hier angibst. Die Datei ShortMsgKAT.txt ist eine _Test_-Definitionsdatei. Die Daten die dort drin stehen unter "Len" und "Msg" sind die Parameter mit dem der Algorithmus _gefüttert_ wird und nicht irgendwelche Ergebnisse.
Mit "Hexadezimal in Binär umwandeln", oder "Nullen am Ende abschneiden" oder "Bits zählen bis zur letzten 1" hat das ganze auch überhaupt nichts zu tun, der Algorithmus ist schon ein _bisschen_ komplexer...


----------



## andreas2505 (10. Jul 2011)

ach ja mister superschlau, dann erklär mir doch mal was die werte für einen sinn ergeben sollen, wenn sie sich denn nicht berechnen lassen.

Natürlich sind das eingabewerte für die Methode, aber die müssen ja auch irgendwie ableitbar und berechenbar sein.

Aber du ja so intelligent bist, kannst du mir und dem forum ja bestimmt auch sagen, was die werte für einen sinn ergeben und wie man sie ermittelt oder einsetzt!!!


----------



## Gast2 (11. Jul 2011)

andreas2505 hat gesagt.:


> ach ja mister superschlau, dann erklär mir doch mal was die werte für einen sinn ergeben sollen, wenn sie sich denn nicht berechnen lassen.
> 
> Natürlich sind das eingabewerte für die Methode, aber die müssen ja auch irgendwie ableitbar und berechenbar sein.
> 
> Aber du ja so intelligent bist, kannst du mir und dem forum ja bestimmt auch sagen, was die werte für einen sinn ergeben und wie man sie ermittelt oder einsetzt!!!



Also jetzt werd mal nicht so unfreundlich. Ich meinem Anonymen Vorposter Recht geben. Du hast eine wirre Aufgabenstellung gepostet und mit der Hilfe sehr vieler wurde so langsam ein Schug draus. Du vorderst hier sehr viel, dafür dass du sehr wenig selbst lieferst. 

Deswegen habe ich auch seit dem Anfang nicht mehr gepostet. Das fing schon an mit dem Wirren Thema Titel: Länge eines Strings berechnen. Jetzt sieht man ja, dass das rein gar nichts mit deiner Aufgabe zu tun hatte ...


----------



## andreas2505 (11. Jul 2011)

wenn er sich mal alles richtig angeguckt hätte, dann hätte er auch gesehen, dass in den teilweisen Implementierungen auf der Seite bei den Eingabewerten immer steht, dass der String und SEINE Länge übergeben wird (in bits) und damit hat es was miteinander zu tun. 

Ich weiß dass ich teilweise sehr verwirrend beschrieben hab was ich gerne hätte, aber das lag daran, dass ich es selber ja nicht genau weiß.
Ich habe auch nur die Werte und weiß, dass ich sie brauche. Und das ich selber nicht viel poste liegt daran, dass ich den ganzen Tag für meine Masterarbeit schreibe und leider dann auch keine Idee habe wie man das lösen kann.

Ich hoffe trotzdem, dass sich vielleicht noch der ein oder andere findet, der mir versucht zu helfen und vielleicht finden wir ja auch irgendeinen Weg wie man darauf nun kommt....


----------



## Unregistrierter (11. Jul 2011)

Ich weiß nicht wie du auf die Idee kommst dass es einen Zusammenhang zwischen der Länge und der Nachricht geben muss (außer dass Len <= bitAnzahl(Msg) sein muss). Nochmal: Das sind Test Eingabedaten um die Korrektheit eines Algorithmus zu überprüfen, da gibt es nichts zu berechnen oder ermitteln oder einen tieferen Sinn dahinter. Die Testdaten wurden offenbar von der NIST ausgewählt und vorgegeben.


----------



## Ariol (11. Jul 2011)

Unregistrierter hat gesagt.:


> Ich weiß nicht wie du auf die Idee kommst dass es einen Zusammenhang zwischen der Länge und der Nachricht geben muss (außer dass Len <= bitAnzahl(Msg) sein muss). Nochmal: Das sind Test Eingabedaten um die Korrektheit eines Algorithmus zu überprüfen, da gibt es nichts zu berechnen oder ermitteln oder einen tieferen Sinn dahinter. Die Testdaten wurden offenbar von der NIST ausgewählt und vorgegeben.



Die Idee kommt von hier bzw. hier.

Auszug aus dem Python-Code:

```
"""Pad M with reverse-padding to reach a length multiple of n

        M: message pair (length in bits, string of hex characters ('9AFC...')
        n: length in bits (must be a multiple of 8)
        Example: pad([60, 'BA594E0FB9EBBD30'],8) returns 'BA594E0FB9EBBD13'
        """
```

Gesucht wird der erste Teil des Nachrichtenpaares, ergo die "Länge in Bit".
So wie ich das sehe ist das die Länge des Eingabewortes ohne das Padding durch Bytealignment.
D.h.: 
	
	
	
	





```
(Position der letzten 1 in Binär) <= m <= (Länge des Strings*4)
```

Beispiele:

```
10110000 -> 10110000 -> B0 (m=8)
1011000  -> 10110000 -> B0 (m=7)
1011     -> 10110000 -> B0 (m=4)
11       -> 11000000 -> C0 (m=2)
110      -> 11000000 -> C0 (m=3)
```

Das Thema wird irgendwie doppelt diskutiert. Vielleicht sollte man mal einen der beiden Threads dich machen.

Übersetzen Python --> Java


----------

