Notizen, Beispiele und Tafelbilder 12.5.2022

20220512/ad-20220512.txt

+Buch zu Steganographie:
+https://link.springer.com/content/pdf/10.1007/978-981-15-0751-9.pdf
+Steganographie-Software:
+https://github.com/DominicBreuker/stego-toolkit
+
+Diffie-Hellman-Schlüsselaustausch:
+https://de.wikipedia.org/wiki/Diffie-Hellman-Schl%C3%BCsselaustausch
+
+Prior art für Anwendung in der Steganographie:
+https://www.researchgate.net/publication/325206752_Diffie-Hellman_Key_Exchange_through_Steganographied_Images
+
+Diffie-Hellman-Schlüsselaustausch, 12.05.2022, 12:48:11
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Situation: Kommunikation ist nur öffentlich möglich.
+Ziel: Sich auf einen gemeinsamen geheimen Schlüssel einigen.
+Lösungsidee: asymmetrische Verschlüsselung, öffentliche Schlüssel
+
+Grundprinzip: Irgendetwas ist mathematisch schwieriger als etwas anderes.
+Hier: Der Logarithmus ist schwieriger zu berechnen als die Potenz.
+Beispiel: 7^5 = 16807 kann ich mit Papier und Bleistift berechnen.
+          Für den Logarithmus von 16807 zur Basis 7 hätte ich lieber
+          einen Computer.
+Im Computer: 100stellige Zahlen; wir rechnen modulo einer Primzahl p.
+
+Alice denkt sich eine Zahl a aus --> ihr geheimer Schlüssel.
+Bob denkt sich eine Zahl b aus --> sein geheimer Schlüssel.
+Beide einigen sich auf eine - öffentliche - gemeinsame Zahl g
+(und auf dieselbe Primzahl p).
+(Achtung: g ist nicht zufällig, sondern < p und idealerweise
+ein Erzeuger (Generator) der zyklischen Gruppe Z_p.)
+
+  Alice schickt g^a (mod p) an Bob.
+  Bob schickt g^b (mod p) an Alice.
+
+  Beide berechnen g^(a · b) = (g^a)^b = (g^b)^a --> gemeinsamer geheimer Schlüssel
+
+Praktische Umsetzung in der Steganographie:
+Alice schickt an Bob ein Katzenbild, das die unverschlüsselten Zahlen g, p und g^a (mod p) enthält.
+Dies sind einfach nur drei zufällig wirkende Zahlen.
+Ein Geheimdienst kann daraus nicht erkennen, daß ein Schlüsselaustausch stattfindet.
+
+Hauptproblem: Die Gesprächspartner müssen sich vorher auf die Software einigen.
+Dabei kann im Prinzip auch bereits der Schlüsselaustausch stattfinden.
+
+OT: https://www.proforhobo.com/
+    https://phdcomics.com/comics/archive.php?comicid=1446
+
+Lösungsideen für Hauptproblem:
+ - Ein Flüchtling nimmt eine Brieftaube mit.
+   Falls die Brieftaube abgefangen wird, ist weder Sender noch Empfänger bekannt.
+   OT: https://de.wikipedia.org/wiki/Internet_Protocol_over_Avian_Carriers
+       https://de.wikipedia.org/wiki/Brieftaube
+       https://en.wikipedia.org/wiki/War_pigeon
+ - Gemeinsame Erinnerungen
+ - Einfach versuchen, Kontakt aufzunehmen. Die Software merkt, ob eine Antwort kommt.
+
+Verbergen der Steganographie-Software:
+ - Easter-Egg in bekannter Software, z.B. Schachprogramm, Wetter-App, Terminkalender
+   wird vom Benutzer selbst konfiguriert, z.B. spezielle Schachzüge,
+     spezielle Stadt eingeben oder auf Wolken klicken, speziellen Namen eingeben
+ - Dies hilft gegen einen flüchtigen Blick, aber nicht gegen eine gezielte Suche
+   OT: https://embeddedsw.net/OpenPuff_Steganography_Home.html
+       https://xkcd.com/538/
+
+Man-in-the-middle-Angriff:
+
+  Alice schickt g^a (mod p) an Bob. Mallory fängt die Nachricht ab.
+  Mallory überlegt sich ein eigenes a --> a' und schickt g^a' an Bob.
+
+  Bob schickt g^b (mod p) an Alice. Mallory fängt die Nachricht ab.
+  Mallory überlegt sich ein eigenes b --> b' und schickt g^b' an Alice.
+
+  Alle berechnen g^(a · b) = (g^a)^b = (g^b)^a --> gemeinsamer geheimer Schlüssel
+
+  Bob schickt eine Nachricht - vermeintlich - an Alice; diese landet aber in
+  Wirklichkeit bei Mallory. Mallory entschlüsselt die Nachricht, verschlüsselt
+  sie neu für Alice und schickt sie danach erst weiter.
+
+  Die muß zum Zeitpunkt des (ersten) Schlüsselaustausches passieren.
+
+  Unwirksame Maßnahme gegen Man-in-the-middle-Angriff:
+  Im Inhalt der Nachricht persönliche Fragen stellen.
+  Damit kann man leider weder das Mitlesen noch das Manipulieren aufdecken.
+  --> unwirksam
+
+  Wirksame Maßnahme gegen Man-in-the-middle-Angriff:
+  Superöffentlicher Schlüsselaustausch:
+  Den öffentlichen Schlüssel (hier: g^a) so weit wie möglich verbreiten.
+  Beispiel: Der Heise-Verlag veröffentlicht in jeder gedruckten c't
+            seinen öffentlichen Schlüssel.
+
+Problem: Der Schlüsselaustausch wird abgefangen.
+         Wie kann man verbergen, daß überhaupt ein Schlüsselaustausch stattfindet?
+
+Idee: Wir schicken eine Zufallsfolge von Zahlen.
+      Wieviele Bits müssen wir versenden?
+      z.B. Schlüssel mit 2048 Bits, 3 Zahlen --> 3 Zahlen à 2048 Bit
+      1. Versuch:
+       - Sende 12 Bit (Zahl von 0 bis 4095): Länge der Zahl.
+       - Sende die Zahl selbst.
+       - Nächste Zahl.
+      Problem: Das fällt auf.
+      2. Versuch:
+       - Wie oben, aber wir senden zusätzlich "zu kurze" Zufallszahlen,
+         z.B. 13 Bit, 700 Bit, 2039 Bit, 3 Bit, 3048 Bit, 3770 Bit, 12 Bit
+         Der Algorithmus extrahiert diejenigen, die passende Größen haben.
+      Problem: Die 12-Bit-Zahlen könnten auffallen (viele 0-Bits).
+      3. Versuch:
+       - Die 12-Bit-Zahlen komprimieren, z.B.:
+         zuerst 4 Bit mit der Länge der Längen-Zahl (z.B. 3 für 8-Bit-Länge),
+         danach erst die eigentliche Länge.
+         Beispiel: Ich möchte eine 15-Bit-Zufallszahl versenden.
+         Die Zahl 15 selbst hat 4 Bit.
+         Kodierung:
+          0 1 0 0  1 1 1 1  x x x x x x x x x x x x x x x
+          `--v--'  `--v--'  `-------------v-------------'
+          4 (fest)   15              Zufallszahl
+      Problem: 3 etwa gleich lange Zahlen könnten auffallen,
+               insbesondere dann, wenn die ersten zwei Primzahlen sind
+               und die dritte nicht.
+
+      Problem: Wenn unser Zufall "zu gut" ist, fällt er auf,
+               da die LSBs in Bildern nicht 100% zufällig sind.
+      5. Versuch: ...
+
+https://en.wikipedia.org/wiki/Steganalysis

20220512/break-01.c

+    for (int i = 0; i < m; i++)
+      {
+        if (x[i] == 42)
+          {
+            do_something_with (i);
+            break;
+          }
+      }
+    do_whatever ();

20220512/break-02.c

+    int i;
+    for (i = 0; i < m; i++)
+      {
+        if (x[i] == 42)
+          break;
+      }
+    if (x[i] == 42)
+      do_something_with (i);
+    do_whatever ();

20220512/break-03.c

+    int i = 0;
+    while (i < m)
+      {
+        if (x[i] == 42)
+          break;
+        i++;
+      }
+    if (x[i] == 42)
+      do_something_with (i);
+    do_whatever ();

20220512/break-04.c

+    int i = 0;
+    while (i < m && x[i] != 42)
+      i++;
+    if (i < m)
+      do_something_with (i);
+    do_whatever ();

20220512/break-05.c

+    int i = 0;
+    int found = 0;
+    while (i < m && !(found = x[i] == 42))
+      i++;
+    if (found)
+      do_something_with (i);
+    do_whatever ();

20220512/break-06.c

+    int i = 0;
+    int found = i < m && x[i] == 42;
+    while (i < m && !found)
+      {
+        i++;
+        found = x[i] == 42;
+      }
+    if (found)
+      do_something_with (i);
+    do_whatever ();

20220512/break-07.c

+    int i = 0;
+    int found = 0;
+    while (i < m && !found)
+      {
+        found = x[i] == 42;
+        if (!found)
+          i++;
+      }
+    if (found)
+      do_something_with (i);
+    do_whatever ();

20220512/break-08.c

+    int i = 0;
+    int found = -1;
+    while (i < m && found < 0)
+      {
+        if (x[i] == 42)
+          found = i;
+        i++;
+      }
+    if (found >= 0)
+      do_something_with (found);
+    do_whatever ();

20220512/break-09.c

+    int i = 0;
+    foo *found = NULL;
+    while (i < m && !found)
+      {
+        if (x[i] == 42)
+          found = y[i];
+        i++;
+      }
+    if (found)
+      do_something_with (found);
+    do_whatever ();

20220512/good-code-01.c

+	while (1) {
+		c = -1;
+		next = 0;
+		i = NR_TASKS;
+		p = &task[NR_TASKS];
+		while (--i) {
+			if (!*--p)
+				continue;
+			if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
+				c = (*p)->counter, next = i;
+		}
+		if (c) break;
+		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
+			if (*p)
+				(*p)->counter = ((*p)->counter >> 1) +
+						(*p)->priority;
+	}
+	switch_to(next);

20220512/good-code-02.c

+	while (1) {
+		c = -1;
+		next = 0;
+		i = NR_TASKS;
+		p = &task[NR_TASKS];
+		while (--i) {
+			if (*--p) {
+                                if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
+                                        c = (*p)->counter, next = i;
+                        }
+		}
+		if (c) break;
+		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
+			if (*p)
+				(*p)->counter = ((*p)->counter >> 1) +
+						(*p)->priority;
+	}
+	switch_to(next);

20220512/good-code-03.c

+	while (1) {
+		c = -1;
+		next = 0;
+		i = NR_TASKS;
+		p = &task[NR_TASKS];
+		while (--i) {
+			if (*--p && (*p)->state == TASK_RUNNING && (*p)->counter > c)
+                                c = (*p)->counter, next = i;
+		}
+		if (c) break;
+		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
+			if (*p)
+				(*p)->counter = ((*p)->counter >> 1) +
+						(*p)->priority;
+	}
+	switch_to(next);

20220512/good-code-04.c

+	while (1) {
+		c = -1;
+		next = 0;
+		i = NR_TASKS;
+		p = &task[NR_TASKS];
+		while (--i) {
+			if (*--p
+                            && (*p)->state == TASK_RUNNING && (*p)->counter > c)
+                                c = (*p)->counter, next = i;
+		}
+		if (c) break;
+		for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
+			if (*p)
+				(*p)->counter = ((*p)->counter >> 1) +
+						(*p)->priority;
+	}
+	switch_to(next);

20220512/good-code-05.c

+	while (1) {
+		c = -1;
+		next = 0;
+		i = NR_TASKS;
+		p = &task[NR_TASKS];
+		while (--i) {
+			if (*--p
+                            && (*p)->state == TASK_RUNNING && (*p)->counter > c)
+                                c = (*p)->counter, next = i;
+		}
+		if (c)
+                        break;
+                else {
+                        for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
+                                if (*p)
+                                        (*p)->counter = ((*p)->counter >> 1) +
+                                                        (*p)->priority;
+                }
+	}
+	switch_to(next);