Eine RSA-Test -App

    • VB.NET

    Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von loosm.

      Eine RSA-Test -App

      Ich will an dieser Stelle die neue Version meines Programms vorstellen, an dem ich ab und zu etwas verändere, weil mir gelegentlich Ideen für Veränderungen einfach so einfallen.

      Hier ist zunächst die Programmbeschreibung :

      Mein Programm hat den Zweck , für das RSA-Verschlüsselungsverfahren die Entstehung der Schlüsselpaare, welche man zur Ver- und Entschlüsselung braucht, vorzuführen. Mein Programm funktioniert so, dass man 2 kleine Primzahlen in den ersten beiden TextBoxen eingibt und dann auf den Button 1 drückt. Dann wird einem eine Liste von 30 Zahlen vorgeschlagen, die sich dafür eignen, als Verschlüsselungsexponent e verwendet zu werden. Warum nur 30 ? Ich habe diese Grenze eingebaut, weil je größer die verwendeten Primzahlen werden, desto mehr mögliche e gibt es. Ich weiß das, weil die Anzahl der möglichen e in meinem Programm mitgezählt und ausgegeben wird . Ich wollte nicht, dass mein Programm nach dem Drücken von Button 1 zu viel Zeit braucht, um die Ausgabe der Liste von möglichen e zu erstellen. Wenn man sich für ein e entschieden hat, gibt man dieses e in die 3 te Textbox ein und denkt sich dann eine Zahl aus, die man verschlüsseln will und gibt diese in die 4 te Textbox ein. Danach drückt man auf den Button 3 damit man sehen kann wie schnell die Funktion getPrivateKey den Entschlüsselungs Exponenten d berechnen kann. Wenn man dann auf den Button 2 drückt wird einem der Entschlüsselungs Exponent d noch mal auf eine andere Art berechnet. Außerdem wird der Geheimtext berechnet. Wenn durch diese andere Art der Berechnung ein anderes d errechnet, wird als die Funktion getPrivateKey es getan hat, wird vorgeführt was für ein Klartext sich mit dem falschen d und dem richtigen d aus dem Geheimtext errechnen lässt. Wobei das Unterprogramm für Mod Berechnungen mit dem falschen d nur dann richtig rechnet, wenn der Exponent positiv ist. Leider funktioniert das Programm nur mit sehr kleinen Primzahlen, die nicht größer als 100 sein sollten, wenn die Berechnung nicht zu lange dauern soll. Der Vorteil an meinem Programm ist aber, dass man im Formular bevor man Button 2 drückt, nur einen Haken setzen muss um beide Lösungen der Gleichung e mal d + k mal Phi(N) = 1 sehen zu können. Allerdings dauert dann die Berechnung noch länger als wenn man nur eine Lösung sehen will.

      Hier ist ein Beispiel bei denen beide Programme ein unterschiedliches d berechnen:

      Wenn man mit den Primzahlen 127 und 131 ein Phi(N)= 16380 und ein e = 43
      eingibt berechnet das Programm, was ich selbst geschrieben habe, für
      d den Wert 11047 aus. Die Berechnung hat auf meinem PC 3 Minuten und
      51 Sekunden gedauert, ohne dass ein Haken gesetzt wurde. Wenn der
      Haken gesetzt wurde, dauert die Berechnung auf meinem PC 16 Minuten
      und 33 Sekunden. die Funktion : getPrivateKey rechnet für d den Wert -5333 aus, kann
      dieses Ergebnis aber sofort liefern.

      Um das Programm ausführen zu können muss man sich zunächst das Programm Visual Studio 2022 herunterladen.
      Das geht von der Seite: visualstudio.microsoft.com/de/

      Danach muss man innerhalb des Programms Visual Studio als Projekt Typ: Windows Form App (.Net Framework)Visual Basic oder Windows Forms App Visual basic auswählen , genau weiß ich das nicht mehr so genau, ich vermute aber auch, dass es egal ist.

      Hier ist der Formularentwurf, damit man sehen kann, wie ich die Buttons, Textboxen , Labels und die eine CheckBox gesetzt habe.



      Wenn man auf dem Formularentwurf die Labels Buttons und Textboxen setzt, entstehen im Arbeitsbereich immer kleine Unterprogramme die mit Code aufgefüllt werden müssen. Der Code für die entstandenen Unterprogramme sowie der Rest meines Programmes kann einfach nur durch kopieren über die Zwischenablage nutzbar gemacht werden. Falls man den Code kopiert hat und das Projekt gestartet hat, kann man zum Beispiel die folgende Ausgabe sehen :



      Hier ist nun der komplette Programmcode :

      Spoiler anzeigen

      VB.NET-Quellcode

      1. Public Class Form1
      2. Public a, b, R, c, m, pot, W, Q As Integer
      3. Public P As ULong
      4. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
      5. Dim P, N, Z, x As Integer
      6. Dim moeg As String
      7. x = 0
      8. Q = 0
      9. moeg = " "
      10. P = (a - 1) * (b - 1)
      11. N = a * b
      12. For W = 1 To P
      13. If EUCLID_RECURSIVE(P, W) = 1 Then
      14. Q = Q + 1
      15. End If
      16. Next
      17. For Z = 1 To P
      18. If EUCLID_RECURSIVE(P, Z) = 1 And x < 30 Then
      19. x = x + 1
      20. moeg = moeg & " Der ggT von Phi( N) : " & P & " und e : " & Z & " = " & EUCLID_RECURSIVE(P, Z) & Chr(13)
      21. End If
      22. Next
      23. Label1.Text = "RSA Modul: N = p mal q = " & a & " mal " & b & " = " & N & Chr(13) _
      24. & " Phi (n) = (P-1) mal (q-1) = " & "(" & a & "-1) * (" & b & "-1) = " & P & Chr(13) _
      25. & " Wähle eine zu Phi (N) teilerfremde Zahl e , für die gilt 1 < e < Phi(N)" & Chr(13) _
      26. & " Ausserdem gilt das der ggt von e und Phi(N) = 1 " & Chr(13) _
      27. & " Es werden hier maximal die ersten 30 möglichen e aufgelistet " & Chr(13) _
      28. & "tatsächlich gibt es " & Q & " mögliche e " & Chr(13) & moeg & Chr(13) _
      29. & " wählen sie nun ein e aus der Liste aus" & Chr(13) _
      30. & "und geben es in das 3te Eingabefeld ein" & Chr(13) _
      31. & "dazu denken sie sich bitte eine Zahl aus," & Chr(13) _
      32. & " die sie verschlüsseln wollen und geben diese in das" & Chr(13) _
      33. & "4 te Eingabefeld ein und drücken dann auf den Button 3 " & Chr(13) _
      34. & " damit sie nach kurzer Zeit ein D ausgerechnet bekommen " & Chr(13) _
      35. & "und danach auf den Button 2 damit sie " & Chr(13) _
      36. & "eventuell ein anderes D ausgerechnet bekommen " & Chr(13)
      37. End Sub
      38. Private Sub TextBox1_TextChanged(sender As Object, e As EventArgs) Handles TextBox1.TextChanged
      39. If IsNumeric(TextBox1.Text) = True Then
      40. a = CInt(TextBox1.Text)
      41. End If
      42. End Sub
      43. Private Sub TextBox2_TextChanged(sender As Object, e As EventArgs) Handles TextBox2.TextChanged
      44. If IsNumeric(TextBox2.Text) = True Then
      45. b = CInt(TextBox2.Text)
      46. End If
      47. End Sub
      48. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
      49. Dim i, x, Y, k, d, N, KL1, KL2, C1, C2, DN, GA, GB, kla, klb, kln, DP, DQ, RP, RQ, ST, Unterschied, Min, Sek As Integer
      50. Dim Ausg, Zeit As String
      51. Dim Erg, P As Long
      52. Dim Zeit1, Zeit2 As Date
      53. ' Label1.Text = "" Falls man beim Setzen der Buttons und Labels mehr Platz braucht, würde dieser Befehl einen Sinn machen.
      54. Zeit1 = DateAndTime.Now
      55. N = a * b
      56. P = (a - 1) * (b - 1)
      57. If P > R Then
      58. Y = P
      59. Else
      60. Y = R
      61. End If
      62. Ausg = ""
      63. If CheckBox1.Checked = True Then
      64. ST = -Y
      65. Else
      66. ST = 1
      67. End If
      68. For i = ST To Y
      69. For x = ST To Y
      70. Erg = (i * R) - x * P
      71. If Erg = EUCLID_RECURSIVE(P, R) Then
      72. d = i
      73. k = -1 * x
      74. If d > 0 Then
      75. Ausg = Ausg & CStr(i) & " mal " & CStr(R) & " minus " & CStr(x) & " mal " & CStr(P) & " = " _
      76. & CStr(EUCLID_RECURSIVE(P, R)) & Chr(13)
      77. Else
      78. Ausg = Ausg & CStr(i) & " mal " & CStr(R) & " plus " & CStr(-x) & " mal " & CStr(P) & " = " _
      79. & CStr(EUCLID_RECURSIVE(P, R)) & Chr(13)
      80. End If
      81. Exit For
      82. Exit For
      83. End If
      84. Next
      85. Next
      86. RP = R Mod (a - 1)
      87. RQ = R Mod (b - 1)
      88. KL1 = m Mod a
      89. KL2 = m Mod b
      90. C1 = ModbermitPotenz(KL1, RP, a)
      91. C2 = ModbermitPotenz(KL2, RQ, b)
      92. c = China(C1, a, C2, b) Mod N
      93. 'oc = ModbermitPotenz(m, R, N) Kontrolle ob ohne chinesischen Restsatz die Rechnung das gleiche ergibt.
      94. Zeit2 = DateAndTime.Now
      95. Unterschied = DateAndTime.DateDiff(DateInterval.Second, Zeit1, Zeit2)
      96. If Unterschied > 60 Then
      97. Min = DateAndTime.DateDiff(DateInterval.Minute, Zeit1, Zeit2)
      98. Sek = Unterschied Mod 60
      99. Zeit = " Die Rechenzeit hat : " & Min & " Minuten und " & Sek & " Sekunden betragen" & Chr(13)
      100. Else
      101. Zeit = " Die Rechenzeit hat : " & Unterschied & " Sekunden betragen" & Chr(13)
      102. End If
      103. Label5.Text =
      104. " Es beginnt die Berechnung der Inversen zu e modulo Phi(N), es gilt :" & Chr(13) _
      105. & " d mal e + k mal Phi(N) = 1 " & Chr(13) _
      106. & Ausg & Chr(13) & "daraus folgt das d = " & d & " und k = " & k & Chr(13) _
      107. & " Um eine Nachricht m zu verschlüsseln, verwendet der Absender die Formel : " & Chr(13) _
      108. & "C= m hoch e Mod N und erhält so aus der Nachricht m den Geheimtext c , " _
      109. & Chr(13) & m & " Hoch " & R & " Mod " & N & "=" & c & Chr(13) _
      110. & " Das Chiffrat ist also " & c & Chr(13) _
      111. & " Der Geheimtext c kann durch modulare Exponentiation" & Chr(13) _
      112. & "wieder zum Klartext m entschlüsselt werden." & Chr(13) _
      113. & " Der Empfänger benutzt die Formel :" & Chr(13) _
      114. & " m = c hoch d Mod N mit dem nur ihm bekannten Wert d sowie N. " & Chr(13) _
      115. & c & " hoch " & d & " Mod " & N & "= " & m & " Der Klartext ist also " & m & Chr(13) _
      116. & Zeit
      117. DN = GetPrivateKey(R, P)
      118. If DN <> d Then
      119. DP = DN Mod (a - 1)
      120. DQ = DN Mod (b - 1)
      121. GA = c Mod a
      122. GB = c Mod b
      123. kla = ModbermitPotenz(GA, DP, a)
      124. klb = ModbermitPotenz(GB, DQ, b)
      125. kln = China(kla, a, klb, b) Mod N
      126. ' kont = ModbermitPotenz(c, DN, N) Kontrolle ob ohne chinesischen Restsatz die Rechnung das gleiche ergibt.
      127. Label6.Text = Label6.Text & Chr(13) & " Wenn man dieses andere D in die Formel : " & Chr(13) _
      128. & " m = c hoch d Mod N eingibt und das Chiffrat benutzt,
      129. was durch die Methode unter Button 2 berechnet wurde, " & Chr(13) _
      130. & "ergibt sich die folgende Rechnung : " & c & " hoch " & DN & " Mod " & N & Chr(13) _
      131. & " und es kommt der folgende Klartext heraus : " & CStr(kln) & Chr(13)
      132. ' & "Nur zur Kontrolle : Klartext ohne chinesischen Restsatz = " & kont
      133. End If
      134. End Sub
      135. Private Sub TextBox4_TextChanged(sender As Object, e As EventArgs) Handles TextBox4.TextChanged
      136. If IsNumeric(TextBox4.Text) = True Then
      137. m = CInt(TextBox4.Text)
      138. End If
      139. End Sub
      140. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
      141. Label2.Text = " Ein Rechner für das Testen von 2 Primzahlen siehe :https://de.wikipedia.org/wiki/RSA-Kryptosystem
      142. Geben sie nun die beiden Primzahlen ein und drücken auf den Button 1
      143. Primzahl1 Primzahl2 "
      144. Label3.Text = " hier das e eingeben"
      145. Label4.Text = " hier kommt eine Zahl hin,
      146. die verschlüsselt werden soll"
      147. CheckBox1.Text = " Hier einen Haken setzen, wenn man 2 Lösungen
      148. der Gleichung: e mal d + k mal Phi (N) = 1 sehen will "
      149. Label1.Text = " Hier ist die Liste der ersten 32 Primzahlen
      150. Wenn sie sich die größeren Zahlen aus der Liste aussuchen,
      151. werden sie verstehen, weshalb ich bei Button 2 eine Zeitmessung
      152. in das Programm eingebaut habe :
      153. 2 , 3 ,5, 7
      154. 11, 13 , 17 , 19
      155. 23, 29, 31, 37,
      156. 41, 43, 47, 53,
      157. 59, 61, 67, 71,
      158. 73, 79, 83, 89,
      159. 97, 101, 103, 107
      160. 109, 113, 127, 131,"
      161. End Sub
      162. Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
      163. Dim P = (a - 1) * (b - 1)
      164. Label6.Text = "Durch die Funktion : getPrivateKey berechnetes D : " & GetPrivateKey(R, P) & Chr(13)
      165. End Sub
      166. Private Sub TextBox3_TextChanged(sender As Object, e As EventArgs) Handles TextBox3.TextChanged
      167. If IsNumeric(TextBox3.Text) = True Then
      168. R = CInt(TextBox3.Text)
      169. End If
      170. End Sub
      171. Function EUCLID_RECURSIVE(P, R) 'Unterprogramm zur Anwendung des euklidische Algorithmus
      172. ' von daher zur Berechnung des größten gemeinsamen Teilers zweier natürlicher Zahlen
      173. Dim Ergebnis As Integer
      174. If R = 0 Then
      175. Ergebnis = P
      176. Else
      177. Ergebnis = EUCLID_RECURSIVE(R, P Mod R)
      178. End If
      179. EUCLID_RECURSIVE = Ergebnis
      180. End Function
      181. Function China(a1, m1, a2, m2) 'Unterprogramm zur Anwendung des chinesischen Restsatz mit 2 Kongruenzen
      182. Static INV1, INV2, x, y, w, z, Erg
      183. Do
      184. INV1 = INV1 + 1
      185. x = m2 * INV1
      186. y = x Mod m1
      187. Loop Until (y = 1)
      188. Do
      189. INV2 = INV2 + 1
      190. w = m1 * INV2
      191. z = w Mod m2
      192. Loop Until (z = 1)
      193. Erg = (a1 * m2 * INV1) + (a2 * m1 * INV2)
      194. China = Erg
      195. End Function
      196. Private Function GetPrivateKey(R As Integer, P As Integer) As Integer
      197. Dim b As Integer = P 'Unterprogramm zur schnellen Ermittlung eines D
      198. Dim d As Integer = 1
      199. Dim u As Integer = 0
      200. While b <> 0
      201. Dim q As Integer = R / b
      202. Dim b1 As Integer = b
      203. b = R - q * b
      204. R = b1
      205. Dim u1 As Integer = u
      206. u = d - q * u
      207. d = u1
      208. End While
      209. Return d
      210. End Function
      211. Public Function ModbermitPotenz(a As Integer, b As Integer, n As Integer) 'Unterprogramm für Mod Berechnungen von Potenz- Zahlen
      212. Dim result As Integer = 1
      213. For i As Integer = 0 To b - 1
      214. result *= a
      215. result = result Mod n
      216. Next
      217. Return result
      218. End Function
      219. End Class

      *Topic verschoben, Spoiler-Tag eingefügt*

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Marcus Gräfe“ ()

      loosm schrieb:

      weil mir gelegentlich Ideen für Veränderungen einfach so einfallen


      Dann wäre der Rauswurf des VisualBasic Namespace meine erste Wahl gewesen.
      Rechtschreibfehler betonen den künstlerischen Charakter des Autors.
      Bevor Du weitermachst, bitte die empfohlenen VS-Einstellungen verwenden.
      Denn neben dem von @Akanel leider noch vorhandenen VB6-Namespace ist z.B. Zeile#219 Option Strict Off
      Die Benennung von Codeteilen ist grausig. Eine Function sollte so benannt werden, dass klar ist, was sie zurückgibt. China erfüllt diese Bedingung definitiv nicht. Auch die ganzen eher kryptisch anmutenden Variablennamen sind nicht für das Verständnis förderlich. Das mag vor 30 Jahren, als man nur wenig Zeichen an einen Namen vergeben durfte, legitim. Heutzutage ist es einfach nur eine Verständnisbremse.
      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

      Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
      Hier ein paar Anmerkungen.

      Du hast zum Teil die Variablen die in Funktionen übergeben werden zum Teil nicht eindeutig deklariert.
      Bei den Ausgaben Deiner großen Texten in die Labels ist der linke Einzug der Text zum Teil grausam.
      Ich würde bei den Funktionen zuerst die Funktionsdefinition angeben und dann mit die mit den Werten gefüllte Funktion ausgeben.
      Nimm doch statt Phi den richtigen griechischen Buchstaben φ in den Funktionen.
      NB. Es ist doch schön, wenn man lesbare Namen vergibt. Siehe auch [VB.NET] Beispiele für guten und schlechten Code (Stil).
      Omg, die GUI ist die grausamste, die ich jeh gesehen habe ! 8| <X X/ :D
      Control Benahmung WTF !
      Viel zu viel Whitespace !
      Die Anordnung der Controls ist auch eher suboptimal.
      Die Primzahlen, würde ich in einer ComboBox anbieten, das ist Komfortabler.

      Beim Code siehts auch nicht viel besser aus:
      Alles sollte so benannt werden, daß auf einen Blick erkennbar ist, worum es sich handelt !
      Die Verkettung der Strings, ist extrem unübersichtlich, besser wäre es String.Format,
      oder String interpolation, oder einen StringBuilder zu nutzen.
      Die vielen (willkürlichen ?) Leerzeilen machen den Code insgesammt sehr unübersichtlich.

      Edit: Hinweis auf StringBuilder hinzugefühgt.

      Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „FormFollowsFunction“ ()

      Eine Antwort auf das zahlreiche Feedback.

      Ich habe versucht, im Projektmappen Explorer unter References /Allgemein / unter der Überschrift Import Namespaces den Haken für
      Microsoft. VisualBasic zu entfernen. Ich vermute, dass dies nur dann möglich ist, wenn man ein Projekt ganz frisch angelegt hat und noch
      nichts daran verändert hat. Ich würde diesen Haken beim nächsten neuen Projekt entfernen.

      Ich will kurz begründen, weshalb ich das Formular so gestaltet hatte, wie ich es nun eben getan hatte.
      Ich habe eine Weile an der Länge der Strings und der Platzierung der Labels herumprobiert. Der Grund hierfür war der folgende : Ich wollte, dass die Texte sich nicht bei der Ausgabe überschneiden. Eine mögliche Überschneidung wäre zum Beispiel gewesen, dass der Text, der nach dem Drücken von Button 2 entsteht, in die Auflistung der möglichen e hineinreicht.
      Dies passiert weder dann, wenn nur 4 mögliche e angezeigt werden, noch dann, wenn 30 mögliche e angezeigt werden. Auch wenn ich die
      Formulargestaltung noch mal verändern würde, wäre für mich die Lesbarkeit der Texte das einzige Kriterium bei der Gestaltung des Formulars.
      Warum ?
      Es ist nur ein kleines Programm, welches den Zweck hat , für das RSA-Verschlüsselungsverfahren die Entstehung der Schlüsselpaare, welche man zur Ver- und Entschlüsselung braucht, vorzuführen. Menschen, die zum Beispiel als Hausaufgabe aufbekommen haben, die Entstehung der Schlüsselpaare mit kleinen Zahlen zu simulieren, könnten damit
      ihre Hausaufgabe kontrollieren. Wäre in diesem Fall etwas anderes als die Richtigkeit der Berechnungen und die Lesbarkeit der Texte von Bedeutung ? Ich glaube nicht.

      Ich habe im Visual Studio zunächst nur unter Extras / Optionen / VB-Standart die Option Strikt von Off auf On umgestellt. Danach hatte
      ich das Programm gestartet und es funktionierte noch ohne jegliche Veränderung. Erst als ich auch im Projektmappen Explorer unter
      Compile /Allgemein die Möglichkeit gefunden hatte die Option Strikt von Off auf On umzustellen,
      gab es beim Funktionstest 51 Fehlermeldungen. Die häufigste : Option Strict On erfordert, dass alle Funktions-, Eigenschafts- und Operator
      Deklarationen eine As-Klausel enthalten. Aber auch andere wie zum Beispiel : Option Strict On lässt keine implizite Konvertierungen
      von „Objekt“ in Integer zu oder Option Strict On lässt keine implizite Konvertierungen von „Objekt“ für den Mod Operator zu.
      Es ein paar Stunden gedauert , bis ich alle entfernen konnte. Das erstaunliche war, dass das Programm nach dem Entfernen der Fehler schneller rechnen konnte als
      vorher. Bezogen auf das Beispiel mit den Primzahlen 127 und 131, einem Phi(N)= 16380 , ein e = 43 und gesetzten Haken rechnet das Programm nicht mehr 16 Minuten und 33
      Sekunden, sondern nur noch 54 Sekunden. Deshalb bin ich wirklich dankbar für diesen Hinweis.

      In Bezug auf die Funktion China hatte ich geglaubt, dass, was ich als Kommentierung geschrieben hatte ausreichend wäre : 'Unterprogramm
      zur Anwendung des chinesischen Restsatzes mit 2 Kongruenzen. Warum ? Wenn man zum Beispiel bei Google den Suchbegriff chinesischer
      Restsatz mit 2 Kongruenzen eingibt, findet man doch zahlreiche Angebote für eine Erklärung. Ich könnte die Funktion China natürlich in Chinesischer-Restsatz umbenennen
      und die erhaltenen Variablen , die ich INV1 und INV2 genannt habe, umbenennen in Inverse1 und Inverse2. Ich frage mich aber ob das wirklich hilfreich wäre. Man wäre dann doch genauso gezwungen, nach einer Erklärung zu suchen.
      Ich würde die nun schnellere Version meines Programms gerne unter diesem Link erneut veröffentlichen, wenn ich das machen würde,
      könnte ich natürlich mehr machen als bei jeder der Unterfunktionen: : EUCLID_RECURSIVE, China , GetPrivateKey und ModbermitPotenz nur eine kurze Kommentierung im Code zu hinterlassen. Ich könnte in Bezug auf die Unterfunktionen auch ausführlich beschreiben, was sie annehmen, was sie ausgeben und warum ich sie in
      mein Programm integriert habe. Wenn ich die neue Version meines Programms veröffentliche, würde ich versuchen die Kommentierung
      nicht nur für die Unterfunktionen, sondern für den restlichen Code des Programms zu verbessern.

      PS.

      Danke für die vielen weitere Hinweise, wie zum Beispiel den mit dem φ, die vielen informativen Links und den mit der ComboBox.
      .

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „loosm“ ()

      Der Geschwindigkeitsunterschied dürfte wahrscheinlich daran liegen, dass der Compiler aufgrund von Option Strict On nicht mehr selber rausfinden muss, von welchem Typ etwas ist. Bei Off muss er immer selber entscheiden und das beste draus machen. Das kann dauern, vor allem bei extrem vielen Berechnungen. Nun, da Du explizit angibst, welcher Datentyp gebraucht wird, entfällt das. Aber es wird wohl nicht nur daran gelegen haben.
      Das mit dem neuen Code: Du könntest ihn hier in einem Folgepost neu hochladen und im ersten Post einen Verweis auf den neuen, späteren Code geben. Der erste Post muss aber ansonsten inhaltlich so bleiben, sonst kommt die Moderation vorbei und macht das rückgängig, weil es schon Reaktionen gab.

      loosm schrieb:

      Ich könnte die Funktion China natürlich in Chinesischer-Restsatz umbenennen
      und die erhaltenen Variablen , die ich INV1 und INV2 genannt habe, umbenennen in Inverse1 und Inverse2. Ich frage mich aber ob das wirklich hilfreich wäre.
      Nein, das genannte ergibt auch keinen Sinn. Auch eine Kommentierung ist nicht hilfreich. Überlege, was die Funktion macht, oder besser: Eine Function gibt etwas zurück. Was genau gibt sie zurück? China gibt sie definitiv nicht zurück. Sie gibt einen Wert zurück. Aber welchen Wert? Was bedeutet er?

      loosm schrieb:

      Ich habe versucht, im Projektmappen Explorer unter References /Allgemein / unter der Überschrift Import Namespaces den Haken für
      Microsoft. VisualBasic zu entfernen. Ich vermute, dass dies nur dann möglich ist, wenn man ein Projekt ganz frisch angelegt hat und noch
      nichts daran verändert hat. Ich würde diesen Haken beim nächsten neuen Projekt entfernen.
      Nein, das geht bei .NET-Projekten so nicht. Das hatte ich hier beschrieben, auch, wie Du es jetzt noch machen kannst.
      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

      Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

      Ich will hier nun die Version meines Programms vorstellen, bei der ich im Projektmappen Explorer unter Compile /Allgemein die Option Strikt von Off auf On umgestellt hatte.

      Weil mir zwischen durch wieder eine Idee für eine Veränderung an dem Programm eingefallen war, musste ich um diese Idee umzusetzen den Entwurf für
      das Formular nochmal verändern.

      Wenn man die folgende Anordnung der Buttons, Label, Textboxen ,Comboboxen und der Checkbox auf dem Formular übernimmt,


      kann die folgende Ausgabe entstehen :



      Außerdem will ich auch noch eine ausführlichere Beschreibung der Funktionsweise meines kleinen Programms mit veröffentlichen. Ich fange mit den Unterprogrammen an, die in meinem Programm enthalten sind.

      Zum Unterprogramm Private Sub Button1_Click

      Hier wird das Label1 beschriftet und es wird in diesem Unterprogramm mit Hilfe des Unterprogramms EUCLID_RECURSIVE die Liste der möglichen Verschlüsselungsexponenten e erstellt. Im Vergleich zur letzten Version meines Programms werden nicht mehr standardmäßig immer nur 30 mögliche e angezeigt, sondern in bestimmten Fällen mehr. Es war mir die Idee eingefallen, dass ich dann die Möglichkeit hätte mehr mögliche e anzuzeigen, wenn ich den Platz auf dem Bildschirm besser ausnutzen würde. Wenn ich nicht hinter jedem möglichen e einen Zeilenumbruch mache und dadurch die möglichen e nicht mehr immer nur untereinander schreibe, sondern auch ein paar nebeneinander und dann erst den Zeilenumbruch mache. Dabei musste ich folgende Regel im Programm einstellen : Es werden bei mehr als 32 und weniger als 1153 möglichen e maximal 192 der möglichen e angezeigt, bei weniger als 33 und mehr als 1152 möglichen e werden maximal 32 mögliche e angezeigt. Diese Regeln haben sich daraus ergeben das es bei dem Primzahl Pärchen 11 und 13 nur 32 mögliche e gibt und bei dem Primzahl Pärchen 71 und 73 es 1152 mögliche e gibt. Bei weniger als 32 möglichen e macht es keinen Sinn die e nebeneinander aufzulisten und bei mehr als 1152 auch nicht, deshalb weil die Berechnung nach dem drücken des Button 1 zu lange dauern würde.


      Nun zum Unterprogramm Private Sub Button2_Click

      In diesem Unterprogramm wird die Gleichung e mal d + k mal Phi(N) = 1 gelöst. Das Phi(N) und das e sind schon in der Gleichung enthalten , es wird das k und das d mit Hilfe einer Doppelschleifenkonstruktion berechnet. Wenn der Startbereich der Schleifen im negativen Bereich der Zahlen anfängt, wird auch die 2 te Lösung der Gleichung e mal d + k mal Phi(N) = 1 sichtbar gemacht. Außerdem wird der Geheimtext ermittelt und vorgeführt wie dieser Geheimtext mithilfe des d in den Klartext zurück verwandelt wird. In diesem Unterprogramm ist auch eine Zeitmessung eingebaut die misst, wie lange es braucht um die Gleichung e mal d + k mal Phi(N) = 1 mit Hilfe der Doppelschleifenkonstruktion zu lösen. Außerdem wird innerhalb des Unterprogramms geprüft ob die Funktion getPrivateKey ein anderes d berechnet und in diesem Fall wird ausgerechnet welcher Klartext entstehen würde, wenn man dieses andere D in die Formel :m = c hoch d mod N eingibt und das Chiffrat benutzt, was durch die Formel : c=m hoch e mod N berechnet wurde.

      Nun zum Unterprogramm Private Sub Button3_Click
      Dieses Unterprogramm hat als einzigen Zweck vorzuführen, wie schnell die Funktion getPrivateKey den Verschlüsselungsexponenten d berechnen kann.

      Zu der Funktion, welche ich China genannt habe. Wie funktioniert diese Funktion ?

      Der Funktion werden 4 Zahlen übergeben und sie gibt nur eine Zahl zurück. Die der Funktion übergebenen Zahlen bilden jeweils 2 Module , die Variable a1 gehört zur Variablen m1 und die Variable a2 gehört zur Variablen m 2 . In meinem Programm habe ich die Zahl welche die Funktion zurückgegeben soll, Erg genannt. ( Erg steht für Ergebnis ) a1 und a2 sind in Bezug auf Erg die Reste, die sich ergeben wenn Erg durch m1 und m 2 geteilt wird.

      Erg mod m1 = a1 und Erg mod m 2 = a2

      Hier ist eine kleines Beispiel um diese Bedingungen anhand von kleinen Zahlen praktisch zu veranschaulichen : Erg mod 7 = 3 und Erg mod 4 = 2

      in diesem Fall wäre a1 = 3 und m1 = 7 und a2 = 2 und m 2 = 4

      Erg wäre in diesem Fall = 66 weil 66 mod 7 = 3 weil ( 66 = (9 x 7) +3 ) und 66 mod 4 = 2 weil ( 66 = (16 x 4) +2 )

      Wie findet die Funktion dieses Ergebnis ?

      Zuerst werden die Inversen im jeweils anderen Modul gesucht, die Inversen werden in meinem Programm jeweils INV1 und INV2 genannt.

      M 2 mal INV1 = 1 Mod m 1 M1 mal INV2 = 1 Mod m 2

      Bezogen auf das Zahlenbeispiel wäre

      7 mal INV1= 1 Mod 4

      4 mal INV2 = 1 Mod 7

      Daraus würde sich ergeben

      INV1 =3 weil 3 mal 7 = 21 und ( 21 = (5 x 4) +1 )

      INV2 =2 weil 2 mal 4 = 8 und (8 = (1 x 7) +1)

      der Nächste Rechenschritt wäre :

      Erg = a1 mal m 2 mal INV1 + a2 mal m1 mal INV2

      Bezogen auf das Zahlenbeispiel wäre Erg = 2 mal 7 mal 3 + 3 mal 4 mal 2 = 42 +24 = 66

      Warum funktioniert die Funktion die ich China genannt habe ?

      Der linke Teil der Gleichung 2 mal 7 mal 3 ergibt wenn man ihn Mod 7 rechnet 0 weil die 7 enthalten ist
      Der rechte Teil der Gleichung 3 mal 4 mal 2 ergibt wenn man ihn Mod 7 rechnet 3

      weil in dem Teil: ( 4 mal 2 ) die 2 deshalb ausgesucht wurde, damit der Teil: ( 4 mal 2 ) wenn man ihn Mod 7 rechnet 1 ergibt (8 = (1 x 7) +1) und somit von der Gleichung 3 mal 4 mal 2 nur die 3 übrig bleibt, wenn man ihn Mod 7 rechnet 24 = (3 x 7) +3

      Der rechte Teil der Gleichung 3 mal 4 mal 2 ergibt wenn man ihn Mod 4 rechnet 0 weil die 4 enthalten ist

      Der linke Teil der Gleichung 2 mal 7 mal 3 ergibt wenn man ihn Mod 4 rechnet 2 weil in dem Teil: ( 7 mal 3 ) die 3 deshalb ausgesucht wurde, damit der Teil: ( 7 mal 3 ) wenn man ihn Mod 4 rechnet 1 ergibt( 21 = (5 x 4) +1) und somit von der Gleichung 2 mal 7 mal 3 nur die 2 übrig bleibt, wenn man ihn mod 4 rechnet 42 = (10 x 4) +2

      Weitere Lösungen der Kongruenzen Erg mod 7 = 3 und Erg mod 4 = 2 sind zum Beispiel : -18,10, 28,94 diese findet man, wenn man rechnet : 66 plus oder minus Z mal 28 wobei Z eine natürliche Zahl ist, und die 28 ist das kleinste gemeinsame Vielfache von m1 und m 2 also von 4 und 7. Eine Bedingung damit der chinesische Restsatz funktioniert ist das die Zahlen m1 und m 2 teilerfremd sein müssen , weil sonst keine Inverse gefunden werden können. Alle diese Informationen habe ich von dem Videoreihe zum chinesischen Restsatz von Christian Spannagel auf Youtoube. Aus diesem Videos habe ich mir Bildschirmfotos von den Tafelabschriften gemacht, um das Unterprogramm für den chinesischen Restsatz schreiben zu können.

      Warum habe ich in mein Programm das Unterprogramm für den chinesischen Restsatz eingefügt ?

      Damit das Unterprogramm für Mod Berechnungen von Zahlen mit Potenz mit weniger hohen Potenzen rechen muss. Die Information das dies
      möglich ist, habe ich unter dem Link : Facharbeit-Martin-Thoma-2.pdf gefunden.

      Nun zum Unterprogramm für Mod Berechnungen von Zahlen mit Potenz welches ich ModbermitPotenz genannt habe. Eigentlich habe ich in meinem Beitrag unter dem Link :
      Wie kann ich das Auftreten der Fehlermeldung System.IndexOutOfRangeException verhindern ?
      schon sehr viel über die Funktionsweise dieses Programms geschrieben. Ich möchte aber noch 2 Informationen nachreichen. Ich hatte die Funktion ModularPower debuggt, dessen Code ich von der Seite : de.wikipedia.org/wiki/RSA-Kryptosystem übernommen hatte. Bezogen auf das Beispiel 6 hoch 4 mod 150 hatte ich beim debugging Die folgenden Zahlen in der Variablen result im Ordner Lokal sehen können. 1,6, 36, 66,96,216 , 396 Die andere Information ist das Bildschirmfoto welches ich von einem Video im Internet gemacht hatte und mit dessen Hilfe ich meine eigene Version dieses Programms erstellt hatte, welche leider gelegentlich die Fehlermeldung System Index out of Range Exception produziert hatte.



      Zur Funktion: EUCLID_RECURSIVE dessen Code hatte ich von der Seite von der Seite : de.wikipedia.org/wiki/Euklidischer_Algorithmus
      von Speudocode in Visualbasic -sciptcode umgewandelt. Wie es auf dieser Seite schon beschrieben worden ist macht diese Funktion nichts anderes als von 2 natürlichen Zahlen, welche dieser
      Funktion übergeben werden den größten gemeinsamen Teiler zu berechnen und diesen dann zurück zu geben.

      Nun zur Funktion getPrivateKey dessen Code ich von der Seite :de.wikipedia.org/wiki/RSA-Kryptosystem übernommen hatte. Diese wendet den erweiterten euklidischen Algorithmus an.
      Von den 2 natürlichen Zahlen, welche dieser Funktion übergeben werden wird zunächst der größte gemeinsame Teiler berechnet und dieser dann als ganzzahlige Linearkombination der
      beiden Zahlen welche ihm übergeben wurden dargestellt. In Bezug auf die Gleichung Gleichung e mal d + k mal Phi(N) = 1 werden dem Programm das Phi(N) und das e übergeben, sie gibt dann aber nicht auch das k zurück, sondern nur das d.

      Weil ich wissen wollte wie dieses Programm: getPrivateKey funktioniert hatte ich mir zum debuggen ein Beispiel ausgedacht das sehr einfach wahr : Phi(N) = 8 resultierend aus den Primzahlen 3 und 5) , das gewählte e = 7 Auch bei diesem Beispiel rechnet die Funktion : getPrivateKey falsch.
      Von den beiden Lösungen der Gleichung e mal d + k mal Phi(N) = 1 : -1 mal 7 + 1 mal 8 = 1 und 7 mal 7 – 6 mal 8 = 1 findet die Funktion : getPrivateKey
      nur die erste Lösung und kommt so zu dem Schluss das d =1 und nicht d=7 .

      Der Vorteil an diesem Beispiel ist, das die Funktion getPrivateKey nur 2 Durchläufe braucht um zu einem Ergebnis zu kommen. Ich hatte beim debugging den Haltepunkt an der Stelle :

      VB.NET-Quellcode

      1. While b <> 0
      eingefügt und dann das Programm im Einzelschritt laufen lassen, dann habe ich die
      Werte der Variablen im Ordner Lokal bei jedem Befehl protokolliert und in eine Tabelle eingetragen. Hier ist das Ergebnis :



      Beim betrachten der Tabelle muss man beachten : Das die Variable R das e ist , ich musste den Verschlüsselungsexponenten r nennen weil das e innerhalb des Programms vom Visual Studio schon vor belegt worden ist. Die Variable die ich in der Tabelle SyS-math genannt habe wird im Programm als „ System.Math.Round zurückgegeben „ beschrieben. Interessant finde ich an diesem Ergebnis das innerhalb der Funktion der
      Befehl :

      VB.NET-Quellcode

      1. Dim q As Integer = R / b
      , dazu führt das die Variable q nicht das exakte Ergebnis der Division annimmt, sondern durch die Function : SyS math round auf die nächste ganze Zahl auf oder abgerundet wird. Auch wenn ich aus dem debugging der Funktion getPrivateKey nicht schlau geworden bin, in Bezug auf die Frage, wie dieses Programm den erweiterten euklidischen Algorithmus umsetzt, habe ich die starke Vermutung, das es nur soweit möglich ist dieses Programm zu reparieren als das es damit aufhört gelegentlich das Vorzeichen vom ermittelten d zu verdrehen. Wer verstehen will warum ich diese Vermutung habe, müsste sich meinen Beitrag unter dem Link :matheboard.de/thread.php?threadid=603668 durchlesen, er ist interessant in Bezug auf die Probleme, die bei der Schlüsselerstellung im RSA Verfahren entstehen können.

      Einen Hinweis bezüglich des auffüllen der Comboboxen mit Primzahlen wollte ich noch abgeben.

      Es empfiehlt sich im Formularentwurf mit dem Mauszeiger auf die Combobox zu gehen und dann die rechte Maustaste zu betätigen. Im dann erscheinenden Kontextmenü wählt man den Punkt : Elemente bearbeiten. Dann sieht man einen Zeichenfolgen Editor in diesen setzt man den Curser und kann dann über die Zwischenablage die ersten Primzahlen, welche nicht größer als 199 sein sollten zum Beispiel von der Seite :de.wikibooks.org/wiki/Primzahl…_Primzahlen_(2_-_100.000) einfügen. Dann brauch man nur noch die Kommas zu entfernen und kann dann die Zeilenumbrüche einfügen. Es macht keinen Sinn größere Primzahlen als 199 einzufügen, weil Bei Eingabe von zu großen Primzahlen im Programm an der Stelle :

      VB.NET-Quellcode

      1. Erg = (i * R) - x * P


      die Meldung : System.OverflowException: "Arithmetic operation resulted in an overflow." erscheint. Dieses Problem muss aber deshalb nicht behoben werden, weil es eh zu viel Rechenzeit verbrauchen würde mit zu großen Primzahlen zu rechnen.

      Sicherlich wird sich manch einer der sich den Code meiner neue Version der RSA Test App anguckt die Frage stellen, weshalb ich nicht versucht habe nach Anleitung unter dem Link : Visual Studio – Empfohlene Einstellungen Den Visual Basic Namespace aus dem Programm zu entfernen.

      1.Es ist mir schlicht unheimlich im Visual Studio die Projektdatei zu verändern, weil ich das Programm nicht tief genug verstehe. Ich verspüre in mir einen generellen Widerwillen dagegen
      in grundlegenden Einstellungen etwas zu verändern, wenn ich nicht genügend Ahnung von diesen Einstellungen habe. Das umschalten von der Option Strikt von Off auf On ist für mich etwas
      anderes, wahrscheinlich deshalb, weil das umschalten eines Schalters ist auch ein einfacher Vorgang ist , der leicht rückgängig gemacht werden kann. Wenn man den obigen Text unter
      dem Link : Visual Studio – Empfohlene Einstellungen. liest hat man außerdem den Eindruck das Microsoft die Entfernung des Visual Basic Namespace mit Absicht beschwerlich macht. Während es das umschalten von der Option Strikt von Off auf On auf einfache Art ermöglicht.

      2. Ich habe mich stattdessen entschieden in meinem Programm nach bösen Funktionen zu suchen die unter dem Link: Böses aus VB6/VB2003 – und die richtigen VB.NET-Alternativen
      gelistet werden und zu ersetzen. Ersetzt habe ich :

      1 Chr(13) durch vbCrLf

      2. IsNumeric() habe ich entfernt, ohne es zu ersetzten.

      3.cstr() habe ich belassen, zum einen weil ich damit in meinem Programm nicht von String konvertiere sondern diese Funktion nur benutze um zu String zu konvertieren und zum anderen steht auf dem obigen Link außerdem, dass diese Funktion sehr performant ist. Andere Funktionen von dem obigen Link, habe ich in meinem Programm nicht gefunden, falls ich welche übersehen habe sollte, bitte ich um Verzeihung.

      3.Ich habe gedacht, dass wenn das Ziel sein soll, dass man lernt objektorientierter zu programmieren das es sinnvoller ist ein neues Projekt vom Typ eine Windows Forms App (NET Framework) in C # anzufangen. Ich habe auch geglaubt, das es nicht so schwer sein wird, den Code zu übersetzen, weil für 2 der verwendeten Unterprogramme der Code in der Programmiersprache bereits C vorhanden ist. Ich hatte dann geplant, den Rest des Codes mit Hilfe der Seite : converter.telerik.com/umzuwandeln.Nach dem ich das Formular erstellt hatte, habe ich als nächstes die Funktion Private Sub Form1_Load kopiert und beim weiteren programmieren festgestellt, dass es zumindest für mich sehr schwer ist, mit dieser Programmiersprache zurechtzukommen. Weil ich mir nicht sicher bin ob ich es schaffen werde mein Programm VB in C# umzuschreiben, will ich jetzt diese Version veröffentlichen, sie ist in jedem Fall besser als meine letzte Version, weil sie schneller rechnen kann. Vielleicht werde ich irgendwann eine andere Version unter diesem Link präsentieren können, welche mehr dem Standard der objektorientierten Programmierung entspricht.

      Hier ist nun die nun die Version meines Programms , bei dem ich im Projektmappen Explorer unter Compile /Allgemein die Option Strikt von Off auf On umgestellt hatte.
      Spoiler anzeigen

      VB.NET-Quellcode

      1. Imports System.Threading
      2. Public Class Form1
      3. Public a, b, R, c, m, pot, W, Q, P As Integer
      4. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
      5. Dim P, N, Z, x As Integer
      6. Dim moeg As String
      7. x = 0
      8. Q = 0
      9. moeg = " "
      10. P = (a - 1) * (b - 1)
      11. N = a * b
      12. For W = 1 To P
      13. If EUCLID_RECURSIVE(P, W) = 1 Then
      14. Q = Q + 1
      15. End If
      16. Next
      17. If Q > 32 And Q < 1153 Then
      18. For Z = 1 To P
      19. If EUCLID_RECURSIVE(P, Z) = 1 And x Mod 5 = 0 And x < 192 Then
      20. x = x + 1
      21. moeg = moeg & " Der ggT von Phi( N) : " & P & " und e : " & Z & " = " & EUCLID_RECURSIVE(P, Z) & vbCrLf
      22. ElseIf EUCLID_RECURSIVE(P, Z) = 1 Then
      23. x = x + 1
      24. moeg = moeg & " Der ggT von Phi( N) : " & P & " und e : " & Z & " = " & EUCLID_RECURSIVE(P, Z) & " / "
      25. End If
      26. Next
      27. End If
      28. For Z = 1 To P
      29. If EUCLID_RECURSIVE(P, Z) = 1 And x < 32 Then
      30. x = x + 1
      31. moeg = moeg & " Der ggT von Phi( N) : " & P & " und e : " & Z & " = " & EUCLID_RECURSIVE(P, Z) & vbCrLf
      32. End If
      33. Next
      34. Label1.Text = "RSA Modul: N = p mal q = " & a & " mal " & b & " = " & N & vbCrLf _
      35. & " Phi (n) = (P-1) mal (q-1) = " & "(" & a & "-1) * (" & b & "-1) = " & P _
      36. & " Wähle eine zu Phi (N) teilerfremde Zahl e , für die gilt 1 < e < Phi(N)" _
      37. & " Ausserdem gilt das der ggt von e und Phi(N) = 1 " & vbCrLf _
      38. & "Es werden bei mehr als 32 und weniger als 1153 möglichen e maximal 192 der möglichen e " _
      39. & " angezeigt, bei weniger als 33 und mehr als 1152 möglichen e werden maximal 32 mögliche e angezeigt " & vbCrLf _
      40. & " tatsächlich gibt es " & Q & " mögliche e " _
      41. & "wählen sie nun ein e aus der Liste aus" _
      42. & " und geben es in das 3te Eingabefeld ein" _
      43. & " dazu denken sie sich bitte eine Zahl aus," _
      44. & " die sie verschlüsseln wollen und geben diese in das" & vbCrLf _
      45. & " 4 te Eingabefeld ein und drücken dann auf den Button 3 " _
      46. & " damit sie nach kurzer Zeit ein D ausgerechnet bekommen " _
      47. & "und danach auf den Button 2 damit sie " _
      48. & "eventuell ein anderes D ausgerechnet bekommen " & vbCrLf & moeg
      49. End Sub
      50. Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
      51. Dim i, x, Y, k, d, N, KL1, KL2, C1, C2, DN, GA, GB, kla, klb, kln, DP, DQ, RP, RQ, ST, Min, Sek, P, Erg As Integer
      52. Dim Ausg, Zeit As String
      53. Dim Unterschied As Long
      54. Dim Zeit1, Zeit2 As Date
      55. Label1.Text = ""
      56. Zeit1 = DateAndTime.Now
      57. N = a * b
      58. P = (a - 1) * (b - 1)
      59. If P > R Then
      60. Y = P
      61. Else
      62. Y = R
      63. End If
      64. Ausg = ""
      65. If CheckBox1.Checked = True Then
      66. ST = -Y
      67. Else
      68. ST = 1
      69. End If
      70. For i = ST To Y
      71. For x = ST To Y
      72. Erg = (i * R) - x * P
      73. If Erg = EUCLID_RECURSIVE(P, R) Then
      74. d = i
      75. k = -1 * x
      76. If d > 0 Then
      77. Ausg = Ausg & CStr(i) & " mal " & CStr(R) & " minus " & CStr(x) & " mal " & CStr(P) & " = " _
      78. & CStr(EUCLID_RECURSIVE(P, R)) & vbCrLf
      79. Else
      80. Ausg = Ausg & CStr(i) & " mal " & CStr(R) & " plus " & CStr(-x) & " mal " & CStr(P) & " = " _
      81. & CStr(EUCLID_RECURSIVE(P, R)) & vbCrLf
      82. End If
      83. Exit For
      84. Exit For
      85. End If
      86. Next
      87. Next
      88. RP = R Mod (a - 1)
      89. RQ = R Mod (b - 1)
      90. KL1 = m Mod a
      91. KL2 = m Mod b
      92. C1 = ModbermitPotenz(KL1, RP, a)
      93. C2 = ModbermitPotenz(KL2, RQ, b)
      94. c = China(C1, a, C2, b) Mod N
      95. 'oc = ModbermitPotenz(m, R, N) Kontrolle ob ohne chinesischen Restsatz die Rechnung das gleiche ergibt.
      96. Zeit2 = DateAndTime.Now
      97. Unterschied = CType(DateAndTime.DateDiff(DateInterval.Second, Zeit1, Zeit2), Long)
      98. If Unterschied > 60 Then
      99. Min = CType(DateAndTime.DateDiff(DateInterval.Minute, Zeit1, Zeit2), Integer)
      100. Sek = CType(Unterschied Mod 60, Integer)
      101. Zeit = " Die Rechenzeit hat : " & Min & " Minuten und " & Sek & " Sekunden betragen" & vbCrLf
      102. Else
      103. Zeit = " Die Rechenzeit hat : " & Unterschied & " Sekunden betragen" & vbCrLf
      104. End If
      105. Label5.Text =
      106. " Es beginnt die Berechnung der Inversen zu e modulo (N), es gilt :" & vbCrLf _
      107. & " d mal e + k mal (N) = 1 " & vbCrLf _
      108. & Ausg & vbCrLf & "daraus folgt das d = " & d & " und k = " & k & vbCrLf _
      109. & " Um eine Nachricht m zu verschlüsseln, verwendet der Absender die Formel : " & vbCrLf _
      110. & "C= m hoch e Mod N und erhält so aus der Nachricht m den Geheimtext c , " _
      111. & vbCrLf & m & " Hoch " & R & " Mod " & N & "=" & c & vbCrLf _
      112. & " Das Chiffrat ist also " & c & vbCrLf _
      113. & " Der Geheimtext c kann durch modulare Exponentiation" & vbCrLf _
      114. & "wieder zum Klartext m entschlüsselt werden." & vbCrLf _
      115. & " Der Empfänger benutzt die Formel :" & vbCrLf _
      116. & " m = c hoch d Mod N mit dem nur ihm bekannten Wert d sowie N. " & vbCrLf _
      117. & c & " hoch " & d & " Mod " & N & "= " & m & " Der Klartext ist also " & m & vbCrLf _
      118. & Zeit
      119. DN = GetPrivateKey(R, P)
      120. If DN <> d Then
      121. DP = DN Mod (a - 1)
      122. DQ = DN Mod (b - 1)
      123. GA = c Mod a
      124. GB = c Mod b
      125. kla = ModbermitPotenz(GA, DP, a)
      126. klb = ModbermitPotenz(GB, DQ, b)
      127. kln = China(kla, a, klb, b) Mod N
      128. ' kont = ModbermitPotenz(c, DN, N) Kontrolle ob ohne chinesischen Restsatz die Rechnung das gleiche ergibt.
      129. Label6.Text = Label6.Text & vbCrLf & " Wenn man dieses andere D in die Formel : " & vbCrLf _
      130. & " m = c hoch d Mod N eingibt und das Chiffrat benutzt,
      131. was durch die Methode unter Button 2 berechnet wurde, " & vbCrLf _
      132. & "ergibt sich die folgende Rechnung : " & c & " hoch " & DN & " Mod " & N & vbCrLf _
      133. & " und es kommt der folgende Klartext heraus : " & CStr(kln) & vbCrLf
      134. ' & "Nur zur Kontrolle : Klartext ohne chinesischen Restsatz = " & kont
      135. End If
      136. End Sub
      137. Private Sub ComboBox2_SelectedIndexChanged(sender As Object, e As EventArgs) Handles ComboBox2.SelectedIndexChanged
      138. b = CInt(ComboBox2.SelectedItem)
      139. End Sub
      140. Private Sub ComboBox1_SelectedIndexChanged(sender As Object, e As EventArgs) Handles ComboBox1.SelectedIndexChanged
      141. a = CInt(ComboBox1.SelectedItem)
      142. End Sub
      143. Private Sub TextBox4_TextChanged(sender As Object, e As EventArgs) Handles TextBox4.TextChanged
      144. m = CInt(TextBox4.Text)
      145. End Sub
      146. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
      147. Label2.Text = " Ein Rechner für das Testen von 2 Primzahlen siehe :https://de.wikipedia.org/wiki/RSA-Kryptosystem
      148. Geben sie nun die beiden Primzahlen ein und drücken auf den Button 1
      149. Primzahl1 Primzahl2 "
      150. Label3.Text = " hier das e eingeben"
      151. Label4.Text = " hier kommt eine Zahl hin,
      152. die verschlüsselt werden soll"
      153. CheckBox1.Text = " Hier einen Haken setzen,
      154. wenn man 2 Lösungen
      155. der Gleichung:
      156. e mal d + k mal Phi (N) = 1
      157. sehen will "
      158. Label1.Text = " In den beiden Comboboxen unter der Überschrift Primzahl1 und Primzahl2
      159. befindet sich jeweils eine Liste der ersten Primzahlen bis 199
      160. Wenn sie sich die größeren Zahlen aus der Liste aussuchen, werden sie verstehen, weshalb ich bei Button 2 eine Zeitmessung
      161. in das Programm eingebaut habe, nach Eingabe der beiden Primzahlen drücken sie auf Button 1 damit sie eine Liste der möglichen
      162. Verschlüsselungsexponenten e angezeigt bekommen. "
      163. Label6.Text = ""
      164. Label5.Text = ""
      165. End Sub
      166. Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
      167. Dim P = (a - 1) * (b - 1)
      168. Label6.Text = "Durch die Funktion : " & vbCrLf _
      169. & "getPrivateKey berechnetes D : " & vbCrLf _
      170. & GetPrivateKey(R, P)
      171. End Sub
      172. Private Sub TextBox3_TextChanged(sender As Object, e As EventArgs) Handles TextBox3.TextChanged
      173. R = CInt(TextBox3.Text)
      174. End Sub
      175. Function EUCLID_RECURSIVE(P As Integer, R As Integer) As Integer 'Unterprogramm zur Anwendung des euklidische Algorithmus
      176. ' von daher zur Berechnung des größten gemeinsamen Teilers zweier natürlicher Zahlen
      177. Dim Ergebnis As Integer
      178. If R = 0 Then
      179. Ergebnis = P
      180. Else
      181. Ergebnis = EUCLID_RECURSIVE(R, P Mod R)
      182. End If
      183. EUCLID_RECURSIVE = Ergebnis
      184. End Function
      185. Function China(a1 As Integer, m1 As Integer, a2 As Integer, m2 As Integer) As Integer 'Unterprogramm zur Anwendung des chinesischen Restsatz mit 2 Kongruenzen
      186. Static INV1, INV2, x, y, w, z, Erg As Integer
      187. Do
      188. INV1 = INV1 + 1
      189. x = m2 * INV1
      190. y = x Mod m1
      191. Loop Until (y = 1)
      192. Do
      193. INV2 = INV2 + 1
      194. w = m1 * INV2
      195. z = w Mod m2
      196. Loop Until (z = 1)
      197. Erg = (a1 * m2 * INV1) + (a2 * m1 * INV2)
      198. China = Erg
      199. End Function
      200. Private Function GetPrivateKey(R As Integer, P As Integer) As Integer
      201. Dim b As Integer = P 'Unterprogramm zur schnellen Ermittlung eines D
      202. Dim d As Integer = 1
      203. Dim u As Integer = 0
      204. While b <> 0
      205. Dim q As Integer = CType(R / b, Integer)
      206. Dim b1 As Integer = b
      207. b = R - q * b
      208. R = b1
      209. Dim u1 As Integer = u
      210. u = d - q * u
      211. d = u1
      212. End While
      213. Return d
      214. End Function
      215. Public Function ModbermitPotenz(a As Integer, b As Integer, n As Integer) As Integer 'Unterprogramm für Mod Berechnungen von Potenz- Zahlen
      216. Dim result As Integer = 1
      217. For i As Integer = 0 To b - 1
      218. result *= a
      219. result = result Mod n
      220. Next
      221. Return result
      222. End Function
      223. End Class


      aufgrund des Codeumfangs Spoiler hinzugefügt ~VaporiZed

      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“ ()