Final touch

README.md

@@ -0,0 +1,16 @@
+# CSS2021 SecLab WriteUp
+
+Persönliche Lösungen für das diesjährige
+[CSS SecLab](https://securitylab.sit.tu-darmstadt.de/index.php/course/tasks/63)
+
+## Links
+1. [AES - Schlüsselaustausch II](aes-schluesselaustausch-ii.md)
+1. [OneTimePad Hack](onetimepad-hack.md)
+1. [Weak Hybrid Encryption](weak-hybrid-encryption)
+1. [RSA - Schlüsselgenerierung](rsa-schluesselgenerierung.md)
+1. [CBC Blockchiffre](cbc-blockchiffre.md)
+1. [RSA - Signatur](rsa-signatur.md)
+1. [Diffie-Hellman II](diffie-hellman-ii.md)
+1. [Euklidischer Algorithmus](euklidischer-algorithmus.md)
+1. [Path Traversal](path-traversal)
+1. [SQL Injection](sql-injection)

aes-schluesselaustausch-ii.md

@@ -8,7 +8,7 @@ Wir sollen wissen, wie viele Schlüssel wir brauchen.
 
 ### Anzahl aller Schlüssel 
 
-Sei `n>1` die Anhalt der Personen.
+Sei `n > 1` die Anzahl der Personen.
 Es gibt also die folgenden Personen:
 ```
 X := { p1, ..., pn }
@@ -21,7 +21,7 @@ Es gibt `2^n` Elemente in der Potenzmenge von `X`,
 von denen wir noch die zu kleine Mengen abziehen müssen.
 Das sind `Ø`, sowie `{ pk }` für `1 ≤ k ≤ n`.
 Die Formel für die Anzahl der Schlüssel lautet damit `2^n - 1 - n`.
-Für `n=141` erhalten wir also
+Für `n = 141` erhalten wir also
 ```
 2^141 ? 141 ? 1 = 2787593149816327892691964784081045188247410
 ```
@@ -38,7 +38,7 @@ Das sind genau die folgenden Teilmengen:
 Power(X \ { p1 }) \ { Ø }
 ```
 Was uns `2^(n-1) - 1` Teilmengen bzw. Schlüssel gibt.
-Für `n=141` erhalten wir
+Für `n = 141` erhalten wir
 ```
 2^(141 - 1) - 1 = 1393796574908163946345982392040522594123775
 ```

diffie-hellman-ii.md

@@ -1,39 +1,40 @@
 # Diffie-Hellman II
 
 Gegegen sind die Parameter für den Diffie-Hellman-Algorithmus:
-
+```python
-    In [1]: a = 6
+In [1]: a = 6
-       ...: b = 4
+   ...: b = 4
-       ...: g = 16
+   ...: g = 16
-       ...: P = 19
+   ...: P = 19
-
+```
-Dabei kennt Alice die Zahlen a, g und P.
+Dabei kennt Alice die Zahlen `a`, `g` und `P`.
-Bob kennt analog b, g, und P.
+Bob kennt analog `b`, `g`, und `P`.
 
 # Lösung
 
-Alice und Bob gerechnen jeweils ihren
+Alice und Bob Berechnen jeweils ihren
-Zwichenexponenten und übertragen ihn.
+Zwischenexponenten und übertragen ihn.
-
+```
-    A = g^a mod P
+A = g^a mod P
-    B = g^b mod P
+B = g^b mod P
-
+```
 Damit können beide den Schlüssel berechnen:
+```
+K = A^b mod P
+  = (g^a)^b mod P 
+  = g^(a*b) mod P 
+  = g^(b*a) mod P 
+  = (g^b)^a mod P 
+  = B^a mod P 
+```
+Das gibt uns (siehe [Weak Hybrid Encryption](weak-hybrid-encryption) für Code):
+```python
+In [3]: A = modpow(g, a, P)
 
-    K = A^b mod P
+In [4]: B = modpow(g, b, P)
-      = (g^a)^b mod P 
-      = g^(a*b) mod P 
-      = g^(b*a) mod P 
-      = (g^b)^a mod P 
-      = B^a mod P 
 
-Das gibt uns (siehe [modpow](modmath.py)):
+In [5]: K = modpow(B, a, P)
 
-    In [3]: A = modpow(g, a, P)
+In [6]: A, B, K
-
+Out[6]: (7, 5, 7)
-    In [4]: B = modpow(g, b, P)
+```
-
-    In [5]: K = modpow(B, a, P)
-
-    In [6]: A, B, K
-    Out[6]: (7, 5, 7)

euklidischer-algorithmus.md

@@ -7,9 +7,11 @@ Gegeben ist lediglich eine Diophantische Gleichung:
 
 ## Lösung
 
-Herleitung und Code steht in [Weak Hybrid Encryption](weak-hybrid-encryption).
+Herleitung und Code stehen in [Weak Hybrid Encryption](weak-hybrid-encryption).
 Wir müssen nur noch einsetzen:
 ```python
-In [1]: euclid(53, 737)
+In [1]: _, x, y = euclid(53, 737)
-Out[1]: (1, -292, 21)
+
+In [2]: x, y
+Out[2]: (-292, 21)
 ```

onetimepad-hack.md

@@ -19,7 +19,7 @@ können wir daraus den Schlüssel berechnen:
 k = c ^ m
 ```
 Das machen wir dann mit `c1` und `c2` da wird dort Teile der Nachricht kennen
-```
+```python
 In [1]: c1 = [0x3e, 0x44, 0x33, 0x26, 0x2d, 0x4d, 0x0d, 0x57, 0x64, 0x37, 0x03, 0x5f, 0x65, 0x02, 0x77, 0x1a]
 
 In [2]: c2 = [0x7e, 0x78, 0x00, 0x28, 0x31, 0x6c, 0x20, 0x75, 0x25, 0x16, 0x04, 0x53, 0x42, 0x2f, 0x27, 0x3c]
@@ -39,7 +39,7 @@ Out[7]: 'J1ZBY8d3Qcm76ZNX'
 ### Entschlüsseln der Nachrichten
 
 Damit können wir dann alle drei Cyphertexte entschlüsseln
-```
+```python
 In [8]: c3 = [0x18, 0x07, 0x6a, 0x2a, 0x0d, 0x0f, 0x11, 0x6b, 0x01, 0x15, 0x1d, 0x79, 0x74, 0x0a, 0x0a, 0x10]
 
 In [9]: def decrypt(ci):

rsa-schluesselgenerierung.md

@@ -1,25 +1,26 @@
 # RSA - Schlüsselgenerierung
 
 Gegeben sind Zwei Primzahlen p und q:
-```
+```python
 In [1]: p, q = 115547, 278753
 ```
-Wir sollen das zugehörige RSA-Schlüsselpaar berechnen.
+Wir sollen das zugehörige RSA-Schlüsselpaar generieren.
 
 ## Lösung
 
-`n` und `φ(n)` können wir direkt berechnen
+`n` und `φ(n)` können wir direkt berechnen:
-```
+```python
 In [2]: n = p * q
 In [3]: phi = (p-1) * (q-1)
 ```
-Wir wählen e als den kleinsten möglichen Wert und berechnen d mit Euklids Algorithmus (siehe [Weak Hybrid Encryption](weak-hybrid-encryption)):
+Wir wählen e als den kleinsten möglichen Wert
-```
+und ermitteln d mit Euklids Algorithmus (siehe [Weak Hybrid Encryption](weak-hybrid-encryption)):
+```python
 In [4]: e = 3
 In [5]: d = modinv(e, phi)
 ```
-Das sind schon alle Werte
+Das sind schon alle Werte:
-```
+```python
 In [6]: n, phi, e, d
 Out[6]: (32209072891, 32208678592, 3, 21472452395)
 ```

rsa-signatur.md

@@ -0,0 +1,22 @@
+# RSA - Signatur
+
+Geben ist eine peinliche Cringe-Nachricht und ein RSA-Schlüsselpaar.
+Wir sollen die Nachricht signieren.
+
+## Lösung
+
+Die Gleichung zum Signieren mittels RSA lautet
+```
+sign(m) = h(m)^d mod n
+```
+Die Zahlen `h(m)`, `d` und `n` sind vorgegeben.
+Für Code, siehe [Weak Hybrid Encryption](weak-hybrid-encryption).
+Wir können direkt die Signatur berechnen:
+```python
+In [1]: h = 4294967295
+
+In [2]: d, n = 136645298869, 205531456619
+
+In [3]: modpow(h, d, n)
+Out[3]: 142800933058
+```

weak-hybrid-encryption/README.md

@@ -6,18 +6,18 @@ Wir sollen die Nachricht trotzdem entschlüsseln.
 
 ## Lösung
 
-### Brechen des privaten Schlüssels
+### Brechen des öffentlichen Schlüssels
 
 Geben ist der öffentliche Schlüssel
-```
+```python
-e = 313949
+In [1]: e = 313949
-n = 965225095240772501
+   ...: n = 965225095240772501
 ```
 Der Modulo `n` wurde schon von auf [FactorDB](http://factordb.com/index.php?query=965225095240772501) faktorisiert.
 Das gibt uns die Primzahlen
-```
+```python
-p = 982458689
+In [2]: p = 982458689
-q = 982458709
+   ...: q = 982458709
 ```
 Wir können `φ(n)` und damit den geheimen Teil des privaten Schlüsseln d berechnen,
 mit dem die RSA-Eigenschaft gilt:
@@ -28,13 +28,13 @@ Dafür nehmen wir den erweiterten euklidischen Algorithmus und lösen
 ```
 e*d + φ(n)*y = 1
 ```
-wobei `(1, d, y) = euclid(e, φ(n))` gilt.
+wobei
-Wir erhalten `d` mittels [`modmath.py`](modmath.py):
 ```
-In [1]: e = 313949 ...: n = 965225095240772501
+(1, d, y) = euclid(e, φ(n))
-
+```
-In [2]: p = 982458689 ...: q = 982458709
+gilt.
-
+Wir erhalten `d` mittels [`modmath.py`](modmath.py):
+```python
 In [3]: phi = (p-1) * (q-1)
 
 In [4]: d = modinv(e, phi)
@@ -50,14 +50,14 @@ Hier brachen wir nur die RSA-Gleichung zum entschlüsseln anwenden:
 m = c^d mod n
 ```
 Im Code müssen wir das nur für je 8 Byte des RSA-Teils machen:
-```
+```python
 In [1]: c = [0x0215305e729ca8d3, 0x0cf8673b18795e9d, 0x02d9612fd611b485, 0x0b0c776db41af05f]
 
 In [2]: [hex(pow(x, d, n)) for x in c]
 Out[2]: ['0x6b644b4f', '0x3245664b', '0x3068306e', '0x7a6f7563']
 ```
 Damit haben wir den AES-Schlüssel:
-```
+```python
 In [1]: k = 0x6b644b4f3245664b3068306e7a6f7563
 ```
 
@@ -65,7 +65,7 @@ In [1]: k = 0x6b644b4f3245664b3068306e7a6f7563
 
 Hier wird nur noch entsprechend des gegebenen Formats entschlüsselt
 
-```
+```python
 In [1]: with open('data.bin', 'rb') as f:
    ...: _, content = f.read().split(b'|')
    ...:
@@ -84,7 +84,7 @@ In [7]: with open("decrypt.bin", "wb") as f:
    ...:     f.write(dec)
 ```
 Mit dem Programm [`file`](https://manpage.me/?q=file) können wir dann herausfinden,
-was man für eine Nachricht das ist:
+was für eine Nachricht das ist:
 ```bash
 $ file decrypt.bin
 decrypt.bin: ASCII text, with very long lines (5552), with no line terminators