diff --git a/20230525/ad-20230525.txt b/20230525/ad-20230525.txt
new file mode 100644
index 0000000000000000000000000000000000000000..099c05acc504048d784c9e6f35746d04f4b04a31
--- /dev/null
+++ b/20230525/ad-20230525.txt
@@ -0,0 +1,57 @@
+RSA, 25.05.2023, 16:20:49
+~~~~~~~~~~~~~~~~~~~~~~~~~
+Schlüsselerzeugung:
+ - d durch Durchprobieren zu finden, hat O(n), ist also
+ genauso langsam wie das Knacken der Verschlüsselung.
+ - Der erweiterte euklidische Algorithmus hat O(log n).
+
+Verschlüsseln und Entschlüsseln:
+ - Modulo-Exponentiation: in Schleife fortwährend multiplizieren,
+ in jedem Durchlauf modulo N rechnen.
+ (Andernfalls gibt es einen Überlauf. m^e oder c^d sind
+ riesengroße Zahlen - erst recht, wenn m, e, c und d bereits
+ riesengroße Zahlen sind.)
+ (Beobachtung: Wenn m (oder c) durch 2 teilbar ist, kommt
+ bei der Potenz ab e = 64 (bzw. d = 64) zuverlässig 0 heraus.
+ Für Details siehe: rsa-04.txt)
+ - Diese Methode der Modulo-Exponentiation hat O(n), ist also
+ genauso langsam wie das Knacken der Verschlüsselung.
+ - Um RSA brauchbar zu machen, benötigen wir einen Algorithmus
+ für die Modulo-Exponentiation, der deutlich schneller ist
+ als O(n), am besten O(log n) oder schneller.
+
+Wie kann man Modulo-Exponentiation effizienter programmieren,
+als in einer Schleife fortwährend zu multiplizieren?
+
+Ansatz:
+Wie kann man Multiplikation effizienter programmieren,
+als in einer Schleife fortwährend zu addieren?
+--> schriftlich
+--> Schriftliche Multiplikation hat O(?).
+
+ 42 · 137
+ --------
+ 42 \
+ 126 3 · 42 = 126 } 1 Schleifendurchlauf pro Ziffer
+ 294 7 · 42 = 294 /
+ --------
+ 462
+
+--> Schriftliche Multiplikation hat O(log n).
+ (log n = Anzahl der Ziffern)
+
+Dasselbe binär:
+
+ 11 · 101
+ --------
+ 11 Multiplikation mit 0 oder 1 ist trivial.
+ 0
+ 11
+ --------
+ 1111
+
+Übertragung:
+Wie kann man Modulo-Exponentiation effizienter programmieren,
+als in einer Schleife fortwährend zu multiplizieren?
+--> Aus Plus wird Mal, aus Mal wird Hoch.
+--> "Binäre Exponentiation" --> Wikiepedia
diff --git a/20230525/overflow-01.c b/20230525/overflow-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..d7bb7b3a4da84fdba43953f77eb143ed18b69ea7
--- /dev/null
+++ b/20230525/overflow-01.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int main (void)
+{
+ uint8_t a = 1;
+ for (int i = 0; i < 42; i++)
+ {
+ a *= 2;
+ printf ("i = %d, a = %d\n", i, a);
+ }
+ return 0;
+}
diff --git a/20230525/overflow-02.c b/20230525/overflow-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..171b812c75cafc5caa444738b64003947077d0b8
--- /dev/null
+++ b/20230525/overflow-02.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int main (void)
+{
+ uint8_t a = 1;
+ while (a != 0)
+ {
+ printf ("a = %d\n", a);
+ a++;
+ }
+ return 0;
+}
diff --git a/20230525/rsa-01.c b/20230525/rsa-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..9f5f14c2a9d1bcf3904b9f8d933c921a489f1e90
--- /dev/null
+++ b/20230525/rsa-01.c
@@ -0,0 +1,55 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int n, int e)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: N = %d, e = %d\n", N, e);
+ int d = gen_key (n, e);
+ printf ("Geheimer Schlüssel: n = %d, d = %d\n", n, d);
+ return 0;
+}
diff --git a/20230525/rsa-02.c b/20230525/rsa-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..c5867e8ff1729c39684a020b10cb81a98582040a
--- /dev/null
+++ b/20230525/rsa-02.c
@@ -0,0 +1,78 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (int b, int e, int N)
+{
+ int result = 1;
+ for (int i = 0; i < e; i++)
+ result = result * b;
+ return result % N;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-03.c b/20230525/rsa-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..6fcfda757fc3351531aa5e3d7cca900758352f8c
--- /dev/null
+++ b/20230525/rsa-03.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (int b, int e, int N)
+{
+ int result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = result * b;
+ printf ("i = %d, result = %d\n", i, result);
+ }
+ return result % N;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-04.c b/20230525/rsa-04.c
new file mode 100644
index 0000000000000000000000000000000000000000..c5363f5e87e28d117a0405713bc9084523a1516e
--- /dev/null
+++ b/20230525/rsa-04.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (long long unsigned b, int e, int N)
+{
+ long long unsigned result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = result * b;
+ printf ("i = %d, result = %llu\n", i, result);
+ }
+ return result % N;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-04.txt b/20230525/rsa-04.txt
new file mode 100644
index 0000000000000000000000000000000000000000..984602c1dbf5eee9aca1187c123e0dc407ffffaf
--- /dev/null
+++ b/20230525/rsa-04.txt
@@ -0,0 +1,42 @@
+Öffentlicher Schlüssel: e = 137, N = 124188007
+Geheimer Schlüssel: d = 7250553, n = 124165720
+
+# Verschlüsseln.
+# Wir berechnen zuerst m^e und danach erst modulo N.
+# m = 42, e = 137. Wir berechnen also 42^137 =
+# 24274639250933907631303599910823220000137051730141529646342610861607\
+# 09604676551412432682195323873003260687326164627838796340701450516955\
+# 28408968085474571834916235983787857059497571233437654292374102849808\
+# 4922642641612439552
+
+i = 0, result = 42 # 42^1 = 2^1 * 3^1 * 7^1
+i = 1, result = 1764 # 42^2 = 2^2 * 3^2 * 7^2
+i = 2, result = 74088 # 42^3 = 2^3 * 3^3 * 7^3
+i = 3, result = 3111696 # 42^4 = 2^4 * 3^4 * 7^4
+i = 4, result = 130691232
+i = 5, result = 5489031744
+i = 6, result = 230539333248
+i = 7, result = 9682651996416
+i = 8, result = 406671383849472
+i = 9, result = 17080198121677824
+i = 10, result = 717368321110468608
+
+# Ungefähr ab hier ist die 64-Bit-Zahl voll. Ab jetzt rechnert der Rechner
+# alles modulo 2^64. Die Ergebnisse sind nicht verwertbar.
+
+i = 11, result = 11682725412930129920 # 42^12 = 2^12 * 3^12 * 7^12
+i = 12, result = 11059121426617114624 # 42^13 = 2^13 * 3^13 * 7^13
+i = 13, result = 3314498075180023808 # 42^14 = 2^14 * 3^14 * 7^14
+
+...
+
+i = 60, result = 11529215046068469760 # 42^61 = 2^61 * 3^61 * 7^61
+i = 61, result = 4611686018427387904 # 42^62 = 2^62 * 3^62 * 7^62
+i = 62, result = 9223372036854775808 # 42^63 = 2^63 * 3^63 * 7^63
+i = 63, result = 0 # 42^64 = 2^64 * 3^64 * 7^64
+ ~~~~
+ = 0 auf einem 64-Bit-Rechner
+
+--> Diese (fehlerhafte) Art von Modulo-Exponentiation liefert
+ für durch 2 teilbare Zahlen zuverlässig 0, sobald der Exponent
+ die 64 erreicht.
diff --git a/20230525/rsa-05.c b/20230525/rsa-05.c
new file mode 100644
index 0000000000000000000000000000000000000000..42323b5af92e6352a16b46f99532e745e59d35cd
--- /dev/null
+++ b/20230525/rsa-05.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (int b, int e, int N)
+{
+ int result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ printf ("i = %d, result = %d\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-06.c b/20230525/rsa-06.c
new file mode 100644
index 0000000000000000000000000000000000000000..285ccfd7232361432063b2562e2378aa7438505f
--- /dev/null
+++ b/20230525/rsa-06.c
@@ -0,0 +1,84 @@
+#include <stdio.h>
+
+#define DEBUG 1
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (long long unsigned b, int e, int N)
+{
+ long long unsigned result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG)
+ printf ("i = %d, result = %llu\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-07.c b/20230525/rsa-07.c
new file mode 100644
index 0000000000000000000000000000000000000000..fdc0a026159aae07d1f0d8080362c00bd39f1368
--- /dev/null
+++ b/20230525/rsa-07.c
@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#define DEBUG 0
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (uint64_t b, int e, uint32_t N)
+{
+ uint64_t result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG)
+ printf ("i = %d, result = %" PRIu64 "\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-08.c b/20230525/rsa-08.c
new file mode 100644
index 0000000000000000000000000000000000000000..0be9037572ea2bf39694cb65915201d109a5a63f
--- /dev/null
+++ b/20230525/rsa-08.c
@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#define DEBUG 1
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (uint64_t b, int e, uint32_t N)
+{
+ uint64_t result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG > 1)
+ printf ("i = %d, result = %" PRIu64 "\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d", d, n);
+ if (DEBUG > 0)
+ printf (", d · e mod n = %d", (d * e) % n);
+ printf ("\n");
+ if (DEBUG > 0)
+ printf ("2^24 = %d\n", mod_power (2, 24, 2000000000));
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-09.c b/20230525/rsa-09.c
new file mode 100644
index 0000000000000000000000000000000000000000..ffd0908a8177b2e9cefd18be80a907437c34a8e9
--- /dev/null
+++ b/20230525/rsa-09.c
@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#define DEBUG 1
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (uint64_t b, int e, uint64_t N)
+{
+ uint64_t result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG > 1)
+ printf ("i = %d, result = %" PRIu64 "\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d", d, n);
+ if (DEBUG > 0)
+ printf (", d · e mod n = %d", (d * e) % n);
+ printf ("\n");
+ if (DEBUG > 0)
+ printf ("2^24 = %d\n", mod_power (2, 24, 2000000000));
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-10.c b/20230525/rsa-10.c
new file mode 100644
index 0000000000000000000000000000000000000000..b0abd70ad09de2f841c17fc67ea76982b008634f
--- /dev/null
+++ b/20230525/rsa-10.c
@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#define DEBUG 2
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (uint64_t b, int e, uint64_t N)
+{
+ uint64_t result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG > 1)
+ printf ("i = %d, result = %" PRIu64 "\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11;
+ int q = 13;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 23;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d", d, n);
+ if (DEBUG > 0)
+ printf (", d · e mod n = %d", (d * e) % n);
+ printf ("\n");
+ if (DEBUG > 0)
+ printf ("2^24 = %d\n", mod_power (2, 24, 2000000000));
+ int m = 7;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-11.c b/20230525/rsa-11.c
new file mode 100644
index 0000000000000000000000000000000000000000..532ac64c98cce806183547198a44819e472d2629
--- /dev/null
+++ b/20230525/rsa-11.c
@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#define DEBUG 0
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (uint64_t b, int e, uint64_t N)
+{
+ uint64_t result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG > 1)
+ printf ("i = %d, result = %" PRIu64 "\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int N)
+{
+ return mod_power (c, d, N);
+}
+
+int main (void)
+{
+ int p = 11;
+ int q = 13;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 23;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d", d, n);
+ if (DEBUG > 0)
+ printf (", d · e mod n = %d", (d * e) % n);
+ printf ("\n");
+ if (DEBUG > 0)
+ printf ("2^24 = %d\n", mod_power (2, 24, 2000000000));
+ int m = 7;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, N);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-12.c b/20230525/rsa-12.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7e48f39d5145dd839a05d62b6816a4b9867116b
--- /dev/null
+++ b/20230525/rsa-12.c
@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#define DEBUG 0
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (uint64_t b, int e, uint64_t N)
+{
+ uint64_t result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG > 1)
+ printf ("i = %d, result = %" PRIu64 "\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int N)
+{
+ return mod_power (c, d, N);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d", d, n);
+ if (DEBUG > 0)
+ printf (", d · e mod n = %d", (d * e) % n);
+ printf ("\n");
+ if (DEBUG > 0)
+ printf ("2^24 = %d\n", mod_power (2, 24, 2000000000));
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, N);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-13.c b/20230525/rsa-13.c
new file mode 100644
index 0000000000000000000000000000000000000000..285ccfd7232361432063b2562e2378aa7438505f
--- /dev/null
+++ b/20230525/rsa-13.c
@@ -0,0 +1,84 @@
+#include <stdio.h>
+
+#define DEBUG 1
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (long long unsigned b, int e, int N)
+{
+ long long unsigned result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ if (DEBUG)
+ printf ("i = %d, result = %llu\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-14.c b/20230525/rsa-14.c
new file mode 100644
index 0000000000000000000000000000000000000000..42323b5af92e6352a16b46f99532e745e59d35cd
--- /dev/null
+++ b/20230525/rsa-14.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (int b, int e, int N)
+{
+ int result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = (result * b) % N;
+ printf ("i = %d, result = %d\n", i, result);
+ }
+ return result;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}
diff --git a/20230525/rsa-15.c b/20230525/rsa-15.c
new file mode 100644
index 0000000000000000000000000000000000000000..c5363f5e87e28d117a0405713bc9084523a1516e
--- /dev/null
+++ b/20230525/rsa-15.c
@@ -0,0 +1,81 @@
+#include <stdio.h>
+
+void ext_eucl (int a, int b, int *ss, int *tt, int *ggt)
+{
+ int r0 = a;
+ int r1 = b;
+ int s0 = 1;
+ int s1 = 0;
+ int t0 = 0;
+ int t1 = 1;
+ int r2 = r0 % r1;
+ while (r2)
+ {
+ int q = r0 / r1;
+ int s2 = s0 - q * s1;
+ int t2 = t0 - q * t1;
+ r0 = r1;
+ s0 = s1;
+ t0 = t1;
+ r1 = r2;
+ s1 = s2;
+ t1 = t2;
+ r2 = r0 % r1;
+ }
+ *ggt = r1;
+ *ss = s1;
+ *tt = t1;
+}
+
+int gen_key (int e, int n)
+{
+ int d;
+ int t;
+ int ggt;
+ ext_eucl (e, n, &d, &t, &ggt);
+ while (d < 0)
+ d += n;
+ if (ggt != 1)
+ return -1;
+ else
+ return d;
+}
+
+int mod_power (long long unsigned b, int e, int N)
+{
+ long long unsigned result = 1;
+ for (int i = 0; i < e; i++)
+ {
+ result = result * b;
+ printf ("i = %d, result = %llu\n", i, result);
+ }
+ return result % N;
+}
+
+int encrypt (int m, int e, int N)
+{
+ return mod_power (m, e, N);
+}
+
+int decrypt (int c, int d, int n)
+{
+ return mod_power (c, d, n);
+}
+
+int main (void)
+{
+ int p = 11117;
+ int q = 11171;
+ int N = p * q;
+ int n = (p - 1) * (q - 1);
+ int e = 137;
+ printf ("Öffentlicher Schlüssel: e = %d, N = %d\n", e, N);
+ int d = gen_key (e, n);
+ printf ("Geheimer Schlüssel: d = %d, n = %d\n", d, n);
+ int m = 42;
+ int c = encrypt (m, e, N);
+ printf ("Nachricht: %d\nVerschlüsselte Nachricht: %d\n", m, c);
+ int m2 = decrypt (c, d, n);
+ printf ("Entschlüsselte Nachricht: %d\n", m2);
+ return 0;
+}