Hi,

wir waren mitten im Text, als es 12 und das Kabel mit wütendem Fauchen um sich schlug, sich, das Handy, das Licht und natürlich unseren Laptop mit sich reißend....

Daher nur kurz: Neue Dateien, neues Programm. Als PDF der ODt kopierten Version.

Thema streng geheim. Copyright megastreng (wir brauchen Geld für's Finanzamt)

Naja wir haben also eine niedliche Zerlegung von Potenzen (genau unser Blogsgesang endete bei "Potenzen in kleinen Scheibchen") von ba**z mit z von 1 bis Usedom vorgenommen, die keine Modulfunktion braucht, sondern die jeweils erforderlichen Vielfachen vorberechnet und subtrahiert von eben den (in diesem Fall) Zweierpotenzen. Die Potenzen nehmen nur das Anfangsmodul als Basis und werden dann als dessen (hier 2) Potenzen dargestellt. So lässt sich dann z.B 13**31 % 167 darstellen.

Womit man zeigen kann bzw. praktisch nutzen, dass sich allgemein (ungerade) Basen auf Zweierbasen reduzieren lassen und die Basis nicht von der gewählten Basis sondern von der Differenz zwischen dem Quadrat der Basis und der im Diffie-System gewählten Primzahl abhängt.  Diese Differenz ist im Programm (natürlich Python ) die eigentliche Basis.

Was das mit der Symmetrie von Diffie Hellman Schlüsseln, dem archaischen Fundament der zahlentheoretischen Kryptografie zu tun hat, gibt's erst morgen.

Bis dann!

CKC

Den Beweis für Diffie hatten wir hier auch halb fertig, jetzt ist er komplett und zeigt, dass die bei Logarithmen mögliche Vereinheitlichung der Basis ganz wesentlich ist für die Gleichheit des geheim erzeugten Schlüssels:

es gilt:

ba**a = v1p+ e und ba**b = v2p + f

später nehmen wir die Vielfachen von p, die beim modulo rechnen verschwinden, aus der Rechnung. Hier für die Klarheit.

f**a = v3x + g1 und e**b = v4y + g2

Wir wollen zeigen, dass g1= g2.

Wir streichen die Vielfachen (entspricht modulo p) und bringen die zweiten Operationen auf die gleiche Basis _ba:

Dafür wird aus f**a %= g1 <=> log_ba ( g1) / log_ba (f) = a <=> a* log_ba (f) = log_ba ( g1)

Ebenso wird aus e**b % = g2 <=> log_ba ( g2) / log_ba (e) = b <=> b* log_ba (e) = log_ba ( g2)

Nun ist aber log_ba (f) eben auch b (siehe oben ohne das Vielfache : ba**b = v2p + f) und log_ba (e) = a (ebendort und ebenso)

Mit Substitution folgt also:

a* b = log_ba ( g1) und a*b = log_ba ( g2)

Damit ist log_ba ( g1) = log_ba ( g2)

und damit aufgrund der gleichen Basis auch g1 = g2.

Der Schlüssel g ist also durch das Verfahren eindeutig bestimmt.

Unser Pythonprogramm zeigt und nutzt genau das: Jede neue Basis aus der ersten Operation lässt sich zu der ersten Basis umformen.