vault backup: 2023-05-31 14:33:23
This commit is contained in:
33
.obsidian/workspace.json
vendored
33
.obsidian/workspace.json
vendored
@@ -36,9 +36,11 @@
|
||||
"id": "ac30fcb197f4fd3d",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "release-notes",
|
||||
"type": "markdown",
|
||||
"state": {
|
||||
"currentVersion": "1.3.4"
|
||||
"file": "Informationssicherheit/Ueb6/Ueb 6.md",
|
||||
"mode": "preview",
|
||||
"source": false
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -69,8 +71,19 @@
|
||||
"file": "English/Matters Technik - IT Matters 3rd EditionB1B2 - Englisch Für IT-Berufe Schülerbuch (Isobel E. Williams) (Z-Library).pdf"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "9a3ca912f94ab62b",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "pdf",
|
||||
"state": {
|
||||
"file": "Informationssicherheit/Ueb6/06-ueb_uebungsblatt.pdf"
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
],
|
||||
"currentTab": 2
|
||||
}
|
||||
],
|
||||
"direction": "vertical"
|
||||
@@ -144,7 +157,7 @@
|
||||
"state": {
|
||||
"type": "backlink",
|
||||
"state": {
|
||||
"file": "Informationssicherheit/Ueb5/Ueb5.md",
|
||||
"file": "Informationssicherheit/Ueb6/Ueb 6.md",
|
||||
"collapseAll": false,
|
||||
"extraContext": false,
|
||||
"sortOrder": "alphabetical",
|
||||
@@ -161,7 +174,7 @@
|
||||
"state": {
|
||||
"type": "outgoing-link",
|
||||
"state": {
|
||||
"file": "Informationssicherheit/Ueb5/Ueb5.md",
|
||||
"file": "Informationssicherheit/Ueb6/Ueb 6.md",
|
||||
"linksCollapsed": false,
|
||||
"unlinkedCollapsed": true
|
||||
}
|
||||
@@ -184,7 +197,7 @@
|
||||
"state": {
|
||||
"type": "outline",
|
||||
"state": {
|
||||
"file": "Informationssicherheit/Ueb5/Ueb5.md"
|
||||
"file": "Informationssicherheit/Ueb6/Ueb 6.md"
|
||||
}
|
||||
}
|
||||
},
|
||||
@@ -247,6 +260,10 @@
|
||||
},
|
||||
"active": "ac30fcb197f4fd3d",
|
||||
"lastOpenFiles": [
|
||||
"Informationssicherheit/Ueb6/06-ueb_uebungsblatt.pdf",
|
||||
"Informationssicherheit/Ueb6/Ueb 6.md",
|
||||
"Informationssicherheit/Ueb5/new UEB5.md",
|
||||
"Informationssicherheit/Ueb6",
|
||||
"Informationssicherheit/Ueb5/05-ueb_uebungsblatt.pdf",
|
||||
"Informationssicherheit/Ueb4/04-ueb_uebungsblatt.pdf",
|
||||
"Informationssicherheit/Ueb5/Ueb5.md",
|
||||
@@ -260,8 +277,6 @@
|
||||
"Algorithmen und Datenstrukturen/VL/VL06/VL07.md",
|
||||
"Informationssicherheit/Ueb5",
|
||||
"Mathe/KW20",
|
||||
"Algorithmen und Datenstrukturen/VL/VL06/Untitled",
|
||||
"Algorithmen und Datenstrukturen/VL/VL06",
|
||||
"English/KW18.md",
|
||||
"Mathe/KW17/KW17.md",
|
||||
"Algorithmen und Datenstrukturen/UEB04/UEB4.md",
|
||||
@@ -284,8 +299,6 @@
|
||||
"Untitled 1.md",
|
||||
"Untitled.md",
|
||||
"Excalidraw/Drawing 2023-04-17 08.21.36.excalidraw.md",
|
||||
"Excalidraw/Drawing 2023-04-17 08.21.00.excalidraw.md",
|
||||
"FH/Informationssicherheit/Ueb2/Ueb2.md",
|
||||
"Informationssicherheit/Ueb1/20230330_19h30m31s_grim.png",
|
||||
"Informationssicherheit/Ueb1/20230330_19h34m13s_grim.png",
|
||||
"Informationssicherheit/Ueb1/20230331_07h21m13s_grim.png",
|
||||
|
||||
@@ -5,4 +5,4 @@ in
|
||||
adfgjkmortz
|
||||
|
||||
post
|
||||
afdjkgoztrm
|
||||
a
|
||||
82
Informationssicherheit/Ueb5/new UEB5.md
Normal file
82
Informationssicherheit/Ueb5/new UEB5.md
Normal file
@@ -0,0 +1,82 @@
|
||||
Um den Wert des ersten Bytes (erste Zeile, erste Spalte) der Ausgabe des AES-Algorithmus vor AddRoundKey am Ende der ersten Runde zu berechnen, müssen wir die folgenden Schritte des AES-Algorithmus durchlaufen:
|
||||
|
||||
1. SubBytes
|
||||
2. ShiftRows
|
||||
3. MixColumns
|
||||
|
||||
Bevor wir beginnen, hier sind die S-Box und die MixColumns-Matrix, die in FIPS-197 definiert sind:
|
||||
|
||||
S-Box:
|
||||
```
|
||||
63 7C 77 7B F2 6B 6F C5 30 01 67 2B FE D7 AB 76
|
||||
CA 82 C9 7D FA 59 47 F0 AD D4 A2 AF 9C A4 72 C0
|
||||
B7 FD 93 26 36 3F F7 CC 34 A5 E5 F1 71 D8 31 15
|
||||
04 C7 23 C3 18 96 05 9A 07 12 80 E2 EB 27 B2 75
|
||||
09 83 2C 1A 1B 6E 5A A0 52 3B D6 B3 29 E3 2F 84
|
||||
53 D1 00 ED 20 FC B1 5B 6A CB BE 39 4A 4C 58 CF
|
||||
D0 EF AA FB 43 4D 33 85 45 F9 02 7F 50 3C 9F A8
|
||||
51 A3 40 8F 92 9D 38 F5 BC B6 DA 21 10 FF F3 D2
|
||||
CD 0C 13 EC 5F 97 44 17 C4 A7 7E 3D 64 5D 19 73
|
||||
60 81 4F DC 22 2A 90 88 46 EE B8 14 DE 5E 0B DB
|
||||
E0 32 3A 0A 49 06 24 5C C2 D3 AC 62 91 95 E4 79
|
||||
E7 C8 37 6D 8D D5 4E A9 6C 56 F4 EA 65 7A AE 08
|
||||
BA 78 25 2E 1C A6 B4 C6 E8 DD 74 1F 4B BD 8B 8A
|
||||
70 3E B5 66 48 03 F6 0E 61 35 57 B9 86 C1 1D 9E
|
||||
E1 F8 98 11 69 D9 8E 94 9B 1E 87 E9 CE 55 28 DF
|
||||
8C A1 89 0D BF E6 42 68 41 99 2D 0F B0 54 BB 16
|
||||
```
|
||||
|
||||
MixColumns-Matrix:
|
||||
```
|
||||
02 03 01 01
|
||||
01 02 03 01
|
||||
01 01 02 03
|
||||
03 01 01 02
|
||||
```
|
||||
|
||||
|
||||
Die SubBytes-Phase ist der erste Schritt in der AES-Runde. In dieser Phase wird jedes Byte des Zustands durch ein anderes Byte ersetzt. Dies geschieht durch die Verwendung einer speziellen Tabelle, die als S-Box bekannt ist. Die S-Box ist eine 16x16-Tabelle, die alle möglichen Werte eines Bytes (0x00 bis 0xFF) enthält. Jedes Byte des Zustands wird durch das Byte ersetzt, das sich an der Stelle in der S-Box befindet, die durch die ersten vier Bits (die Zeile) und die letzten vier Bits (die Spalte) des Bytes bestimmt wird.
|
||||
|
||||
Da wir nur das erste Byte (erste Zeile, erste Spalte) der Ausgabe berechnen, müssen wir nur das erste Byte des Zustands durch die S-Box ersetzen. Das erste Byte des Zustands ist 0x1A. Die ersten vier Bits von 0x1A sind 0001 (1 in dezimal), und die letzten vier Bits sind 1010 (A in hexadezimal). Daher befindet sich das ersetzende Byte an der Stelle (1, A) in der S-Box, was 0x63 ist.
|
||||
|
||||
Daher ist das erste Byte nach der SubBytes-Phase 0x63.
|
||||
|
||||
Der nächste Schritt ist die ShiftRows-Phase. In dieser Phase wird jede Zeile des Zustands um eine bestimmte Anzahl von Bytes nach links verschoben. Die erste Zeile bleibt unverändert, die zweite Zeile wird um ein Byte, die dritte Zeile um zwei Bytes und die vierte Zeile um drei Bytes verschoben. Da das erste Byte in der ersten Zeile liegt, bleibt es unverändert.
|
||||
|
||||
Daher ist das erste Byte nach der ShiftRows-Phase immer noch 0x63.
|
||||
|
||||
Der letzte Schritt ist die MixColumns-Phase. In dieser Phase wird jede Spalte des Zustands als vier Begriffe eines Polynoms betrachtet und dann mit einem festen Polynom multipliziert. Das Ergebnis der Multiplikation wird dann modulo einem irreduziblen Polynom genommen, um sicherzustellen, dass das Ergebnis immer ein Byte ist. Da das erste Byte in der ersten Spalte liegt, wird es durch die MixColumns-Phase beeinflusst.
|
||||
|
||||
Um das erste Byte nach der MixColumns-Phase zu berechnen, müssen wir das erste Byte jeder Zeile der Spalte nehmen und es mit dem entsprechenden Element der ersten Zeile der MixColumns-Matrix multiplizieren. Dann addieren wir die Ergebnisse zusammen und nehmen das Ergebnis modulo 0x1B (das irreduzible Polynom).
|
||||
|
||||
Das bedeutet, wir müssen die folgende Berechnung durchführen:
|
||||
|
||||
0x02 * 0x63 (erstes Byte nach ShiftRows)
|
||||
0x01 * 0xB2 (zweites Byte der ersten Spalte)
|
||||
0x01 * 0x32 (drittes Byte der ersten Spalte)
|
||||
0x03 * 0x70 (viertes Byte der ersten Spalte)
|
||||
|
||||
Dann addieren wir die Ergebnisse zusammen und nehmen das Ergebnis modulo 0x1B.
|
||||
|
||||
Lassen Sie uns diese Berechnung durchführen.
|
||||
|
||||
Entschuldigung, es scheint, dass es ein Problem mit der Ausführung des Polynommodul-Befehls gibt. Lassen Sie uns stattdessen die MixColumns-Berechnung manuell durchführen.
|
||||
|
||||
Die Multiplikation in der MixColumns-Phase wird in GF(2^8) durchgeführt, was bedeutet, dass sie eine spezielle Art der Multiplikation ist, die als "Polynommultiplikation modulo ein irreduzibles Polynom" bekannt ist. In diesem Fall ist das irreduzible Polynom x^8 + x^4 + x^3 + x + 1, das in hexadezimaler Form als 0x1B dargestellt wird.
|
||||
|
||||
Die Multiplikation mit 0x02, 0x01 und 0x03 in GF(2^8) kann durch eine Kombination von Bitverschiebungen und bedingten XOR-Operationen durchgeführt werden. Die Multiplikation mit 0x02 entspricht einer Bitverschiebung nach links und einer bedingten XOR-Operation mit 0x1B, wenn das höchste Bit vor der Verschiebung 1 ist. Die Multiplikation mit 0x01 lässt das Byte unverändert. Die Multiplikation mit 0x03 entspricht der Addition (die in GF(2^8) einer XOR-Operation entspricht) des ursprünglichen Bytes und des mit 0x02 multiplizierten Bytes.
|
||||
|
||||
Lassen Sie uns diese Berechnungen durchführen:
|
||||
|
||||
0x02 * 0x63 = 0xC6
|
||||
0x01 * 0xB2 = 0xB2
|
||||
0x01 * 0x32 = 0x32
|
||||
0x03 * 0x70 = 0x70 XOR 0xE0 = 0x90
|
||||
|
||||
Dann addieren wir die Ergebnisse zusammen und nehmen das Ergebnis modulo 0x1B:
|
||||
|
||||
0xC6 XOR 0xB2 XOR 0x32 XOR 0x90 = 0x54
|
||||
|
||||
Daher ist das erste Byte nach der MixColumns-Phase 0x54.
|
||||
|
||||
Zusammenfassend ist das erste Byte (erste Zeile, erste Spalte) der Ausgabe des AES-Algorithmus vor AddRoundKey am Ende der ersten Runde 0x54.
|
||||
BIN
Informationssicherheit/Ueb6/06-ueb_uebungsblatt.pdf
Normal file
BIN
Informationssicherheit/Ueb6/06-ueb_uebungsblatt.pdf
Normal file
Binary file not shown.
133
Informationssicherheit/Ueb6/Ueb 6.md
Normal file
133
Informationssicherheit/Ueb6/Ueb 6.md
Normal file
@@ -0,0 +1,133 @@
|
||||
# 1
|
||||
## a
|
||||
Kryptographische Hashfunktionen sind spezielle Funktionen mit verschiedenen Eigenschaften, die sie nützlich für Kryptographie machen. Diese sollten folgende Eigenschaften haben:
|
||||
|
||||
1. **Deterministisch**: Für jede Eingabe liefert die Hashfunktion immer den gleichen Hashwert. Wenn Sie die gleiche Nachricht erneut durch die Funktion senden, erhalten Sie immer den gleichen Ausgang.
|
||||
|
||||
2. **Schnelle Berechnung**: Für jede gegebene Eingabe sollte die Berechnung des Hashwerts effizient und schnell sein.
|
||||
|
||||
3. **Preimage-Resistenz**: Es sollte rechnerisch unpraktisch sein, die ursprüngliche Eingabe anhand ihres Hashwerts zu ermitteln. Diese Eigenschaft ist manchmal auch als "Einwegfunktion" bekannt.
|
||||
|
||||
4. **Kleine Änderungen in der Eingabe erzeugen große Änderungen in der Ausgabe**: Eine Änderung, selbst eine sehr kleine, in der Eingabe sollte eine völlig andere Ausgabe erzeugen.
|
||||
|
||||
5. **Kollisionsresistenz**: Es sollte extrem schwierig sein, zwei verschiedene Eingaben zu finden, die den gleichen Hashwert erzeugen. Dies ist wichtig, um die Integrität von Daten in vielen Anwendungen zu gewährleisten.
|
||||
|
||||
6. **Feste Ausgabegröße**: Unabhängig von der Größe der Eingabe sollte die Ausgabe immer eine konstante Länge haben.
|
||||
|
||||
## b
|
||||
|
||||
1. **Digitale Signaturen**: Digitale Signaturen verwenden Hashfunktionen, um die Integrität von Daten in einer Nachricht oder einem Dokument zu gewährleisten. Die Daten werden gehasht und der resultierende Hashwert wird mit einem privaten Schlüssel signiert. Der Empfänger kann dann den gesendeten Hash mit dem öffentlichen Schlüssel des Absenders überprüfen. Wenn die Hashes übereinstimmen, kann sichergestellt werden, dass die Daten seit ihrer Signatur nicht geändert wurden.
|
||||
2. **Passwort-Speicherung**: Eine der häufigsten Anwendungen für Hashfunktionen ist die Speicherung von Passwörtern. Anstatt ein Passwort direkt in einer Datenbank zu speichern, wird das Passwort durch eine Hashfunktion geleitet und der resultierende Hashwert wird gespeichert. Wenn ein Benutzer sein Passwort eingibt, wird es erneut durch die Hashfunktion geleitet und mit dem gespeicherten Hashwert verglichen. Wenn die Werte übereinstimmen, ist das Passwort korrekt. Dies bietet einen zusätzlichen Sicherheitsschutz, da selbst wenn ein Angreifer Zugriff auf die gespeicherten Hashwerte erhält, es extrem schwierig ist, das ursprüngliche Passwort aus dem Hashwert abzuleiten.
|
||||
|
||||
# 2
|
||||
a) **Beweisskizze für das Geburtstagsparadoxon**:
|
||||
|
||||
Das Geburtstagsparadoxon ist weniger intuitiv, weil es nicht um die Wahrscheinlichkeit geht, dass eine bestimmte Person mit einer anderen am selben Tag Geburtstag hat, sondern darum, dass irgendein Paar von Personen am selben Tag Geburtstag hat.
|
||||
|
||||
Angenommen, wir ignorieren Schaltjahre, es gibt also 365 mögliche Geburtstage. Die Wahrscheinlichkeit, dass zwei Personen an unterschiedlichen Tagen Geburtstag haben, beträgt 364/365.
|
||||
|
||||
Wenn eine dritte Person hinzukommt, gibt es 363 Tage übrig, an denen sie Geburtstag haben kann, ohne dass es zu einer Übereinstimmung kommt, also ist die Wahrscheinlichkeit 363/365.
|
||||
|
||||
Dies wird fortgesetzt, bis die 23. Person hinzukommt, bei der die Wahrscheinlichkeit 343/365 beträgt. Die Gesamtwahrscheinlichkeit, dass niemand in einer Gruppe von 23 Personen am selben Tag Geburtstag hat, ist das Produkt dieser Wahrscheinlichkeiten. Wenn man dies berechnet, findet man heraus, dass es knapp unter 0,5 liegt. Daher ist die Wahrscheinlichkeit, dass mindestens zwei Personen am selben Tag Geburtstag haben, knapp über 0,5, d.h. über 50%.
|
||||
|
||||
| Person | Einzigartiger Geburtstag | Kumulative Wahrscheinlichkeit |
|
||||
| --- | --- | --- |
|
||||
| 1 | 365/365 = 1.000 | 1.000 |
|
||||
| 2 | 364/365 = 0.997 | 0.997 |
|
||||
| 3 | 363/365 = 0.994 | 0.992 |
|
||||
| 4 | 362/365 = 0.992 | 0.983 |
|
||||
| 5 | 361/365 = 0.989 | 0.973 |
|
||||
| 6 | 360/365 = 0.986 | 0.960 |
|
||||
| 7 | 359/365 = 0.984 | 0.945 |
|
||||
| 8 | 358/365 = 0.981 | 0.927 |
|
||||
| 9 | 357/365 = 0.978 | 0.907 |
|
||||
| 10 | 356/365 = 0.975 | 0.884 |
|
||||
| 11 | 355/365 = 0.973 | 0.860 |
|
||||
| 12 | 354/365 = 0.970 | 0.834 |
|
||||
| 13 | 353/365 = 0.967 | 0.807 |
|
||||
| 14 | 352/365 = 0.964 | 0.778 |
|
||||
| 15 | 351/365 = 0.962 | 0.748 |
|
||||
| 16 | 350/365 = 0.959 | 0.717 |
|
||||
| 17 | 349/365 = 0.956 | 0.685 |
|
||||
| 18 | 348/365 = 0.953 | 0.652 |
|
||||
| 19 | 347/365 = 0.951 | 0.618 |
|
||||
| 20 | 346/365 = 0.948 | 0.586 |
|
||||
| 21 | 345/365 = 0.945 | 0.552 |
|
||||
| 22 | 344/365 = 0.943 | 0.520 |
|
||||
| 23 | 343/365 = 0.940 | 0.489 |
|
||||
|
||||
b) **Berechnung der Kollision von 96-Bit-Hashwerten**:
|
||||
|
||||
Das Geburtstagsparadoxon lässt sich auch auf das Problem der Kollision von Hashwerten anwenden, das als Geburtstagsproblem bekannt ist. In diesem Kontext ist eine Kollision der Punkt, an dem zwei unterschiedliche Eingaben den gleichen Hashwert erzeugen.
|
||||
|
||||
Die Anzahl der verschiedenen 96-Bit-Hashwerte beträgt 2^96. Um die durchschnittliche Anzahl der Hashwerte zu berechnen, die erzeugt werden müssen, bevor eine Kollision auftritt, verwenden wir die Quadratwurzel aus dieser Anzahl (dies ist eine Anwendung der Geburtstagsattacke), also etwa 2^(96/2) = 2^48.
|
||||
|
||||
Es ist jedoch wichtig zu beachten, dass dies eine durchschnittliche Zahl ist. In der Praxis könnte eine Kollision viel früher oder viel später auftreten. Aber dies gibt uns eine Vorstellung davon, warum größere Hashlängen sicherer sind: Sie machen Kollisionen wesentlich unwahrscheinlicher.
|
||||
|
||||
# 3
|
||||
|
||||
## a
|
||||
SHA-2 (Secure Hash Algorithm 2) ist eine Gruppe von kryptographischen Hashfunktionen, die vom National Institute of Standards and Technology (NIST) entwickelt wurden. Die SHA-2-Familie umfasst SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 und SHA-512/256. Die Zahlen beziehen sich auf die Länge des Hashwerts, der produziert wird.
|
||||
|
||||
Das Padding spielt eine wichtige Rolle im SHA-2-Algorithmus. Der Eingabetext muss eine Länge haben, die einem Vielfachen des Blockgrößenlimits entspricht (512 Bit für SHA-256, 1024 Bit für SHA-512, usw.). Wenn der Eingabetext nicht diese Bedingung erfüllt, wird er durch Hinzufügen von zusätzlichen Bits - dem sogenannten Padding - aufgefüllt.
|
||||
|
||||
Das Padding für die SHA-2 Familie erfolgt in folgenden Schritten:
|
||||
|
||||
1. **Anhängen eines 1-Bits**: Der erste Schritt besteht darin, ein Bit mit dem Wert "1" an die Eingabe anzuhängen.
|
||||
|
||||
2. **Anhängen von k-Bits mit dem Wert "0"**: Anschließend werden Null-Bits angehängt, bis die Länge der Nachricht modulo die Blockgröße 448 (für SHA-256) oder 896 (für SHA-512) ist. Das heißt, es werden so viele Nullen angehängt, dass nur noch genug Platz für die Länge der ursprünglichen Nachricht ist.
|
||||
|
||||
3. **Anhängen der Länge der Originalnachricht**: Die letzten 64 (für SHA-256) oder 128 (für SHA-512) Bits des Blocks werden verwendet, um die Länge der ursprünglichen Nachricht (vor dem Padding) in Binärform anzuhängen. Wenn die Länge der Nachricht weniger Bits benötigt, wird sie mit Null-Bits auf die benötigte Länge aufgefüllt.
|
||||
|
||||
Dieses Verfahren stellt sicher, dass die gepaddete Nachricht eine Länge hat, die ein Vielfaches der Blockgröße ist, und es ermöglicht es dem Algorithmus, den Hashwert zu berechnen, selbst wenn die ursprüngliche Nachricht nicht die richtige Länge hat. Darüber hinaus sorgt das Padding dafür, dass jede Nachricht (einschließlich verschiedener Nachrichten mit der gleichen Länge) zu einem eindeutigen Hashwert führt, da die Länge der Nachricht im Padding enthalten ist.
|
||||
|
||||
## b
|
||||
|
||||
Um das Padding für SHA-256 für den Text "hello, world" durchzuführen, folgen wir den Schritten, die ich zuvor beschrieben habe.
|
||||
|
||||
1. **Text in Binär konvertieren**: Jedes ASCII-Zeichen wird in seine 8-Bit-Binärdarstellung umgewandelt. Für "hello, world" ergibt das:
|
||||
|
||||
"hello, world" in ASCII ist 68 65 6c 6c 6f 2c 20 77 6f 72 6c 64, was in Binär umgewandelt:
|
||||
|
||||
h: 01101000
|
||||
|
||||
e: 01100101
|
||||
|
||||
l: 01101100
|
||||
|
||||
l: 01101100
|
||||
|
||||
o: 01101111
|
||||
|
||||
,: 00101100
|
||||
|
||||
(Leerzeichen): 00100000
|
||||
|
||||
w: 01110111
|
||||
|
||||
o: 01101111
|
||||
|
||||
r: 01110010
|
||||
|
||||
l: 01101100
|
||||
|
||||
d: 01100100
|
||||
|
||||
Die kombinierte Binärnachricht wird:
|
||||
011010000110010101101100011011000110111100101100001000000111011101101111011100100110110001100100
|
||||
|
||||
2. **ein 1-Bit am Ende hinzufügen**:
|
||||
0110100001100101011011000110110001101111001011000010000001110111011011110111001001101100011001001
|
||||
|
||||
3. **Nullen hinzufügen**: Wir fügen Nullen hinzu, bis die Länge der Nachricht modulo 512 gleich 448 ist. Da unsere Nachricht derzeit 97 Bit lang ist, fügen wir 447-97=350 Nullen hinzu:
|
||||
0110100001100101011011000110110001101111001011000010000001110111011011110111001001101100011001001 + 350 Nullen
|
||||
|
||||
4. **Länge der Originalnachricht hinzufügen**: Schließlich fügen wir die Länge der ursprünglichen Nachricht als 64-Bit-Binärzahl hinzu. Die Originalnachricht war 96 Bit lang, was in Binär 1100000 ist. Wir fügen Nullen vorne hinzu, um 64 Bit zu erhalten:
|
||||
|
||||
00000000000000000000000000000000000000000000000000000001100000
|
||||
|
||||
Unsere endgültige, gepaddete Nachricht wird dann:
|
||||
|
||||
0110100001100101011011000110110001101111001011000010000001110111011011110111001001101100011001001 + 350 Nullen + 00000000000000000000000000000000000000000000000000000001100000
|
||||
|
||||
|
||||
Reference in New Issue
Block a user