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 :


*Topic verschoben, Spoiler-Tag eingefügt*

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

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 :
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 : , 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 :



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.


aufgrund des Codeumfangs Spoiler hinzugefügt ~VaporiZed

Eigentlich hatte ich vorgehabt an dieser Stelle nochmal eine Version in C# des Programms vorzustellen, welches ich in Visual Basic geschrieben hatte. In diesem Beitrag kann man auf einem Bildschirmfoto sehen, das die Visual Basic Version des Programms, bei der ich die Option Strikt von Off auf On umgestellt hatte und für die Berechnung des Entschlüsselungs Exponenten d mit Hilfe der der beiden Primzahlen 199 und 197 und einem gewählten Verschlüsselung Exponenten e = 41 und einem gewählten Klartext = 2 genau 5 Minuten und 59 Sekunden gebraucht hatte. Ich habe mit diesem Programm die Messung wiederholt und bin auf eine Zeit von 6 Minuten und 16 Sekunden gekommen. Dann habe ich mit dem C# Programm und den gleichen Zahlen die Messung auch 2 mal wiederholt. Die gemessenen Zeiten warten : 11 Minuten und 53 Sekunden und 11 Minuten und 29 Sekunden.
Ich vermute, dass es vielleicht daran liegt, dass bei der Visual Basic Version des Programms das Rechnen schneller geht, weil die Unterprogramme nicht in einer eigenen Klasse und nicht in einer eigenen Datei liegen.

Ich habe mich nun entschieden trotzdem einen kleinen Teil von dem Programm in C# zu veröffentlichen. In Bezug auf diesen Teil unterscheiden sich die Visual Basic Version und die C# Version deutlicher als in den anderen Teilen des Programms. In der Visual Basic Version hatte ich in dem Unterprogramm : Private Sub Button1_Click eine komplizierte Regel erdacht um möglichst viele der möglichen Verschlüsselung Exponenten e auf einem Label ausgeben zu können, ohne das man nach dem Drücken auf den Button1 zu lange auf die Erstellung der Liste von möglichen e zu lange warten muss. In der C # Version ist der Code zum erstellen der möglichen e viel kürzer ausgefallen. Ich habe einfach versucht die Auflistung der möglichen Verschlüsselung Exponenten e in eine Listbox zu packen.

Zuerst hatte ich versucht, den Code selber zu schreiben, welcher aber nicht funktionieren wollte. Dann habe ich unter der Webseite :chat.openai.com/auth/login die folgende Frage gestellt :
Ich habe den folgenden Code erstellt um eine Listbox aufzufüllen :



Die Fehlermeldung die ich erhalte, wenn ich den Code ausführe lautet „ System.ArgumentNullException: "Der Wert darf nicht NULL sein. Parametername: item „
Was muss ich an der Programmierung ändern, damit die Fehlermeldung verschwindet ? Die Antwort der Webseite war :



Dieser Code hat dann funktioniert. Das Packen der Auflistung der möglichen e in die Listbox geht so schnell, dass keine Wartezeit entsteht.
Auch bei der Erstellung des Programms dessen Code ich unter dem Link: Eine Frage in Bezug auf das ausgliedern einer Klasse in eine andere Datei veröffentlicht hatte war die Webseite : https://chat.openai.com/auth/login
hilfreich. Ich wollte erst die Bernoulli Formel direkt in den Code schreiben, ich bin aber dann daran gescheitert, weil in C# bei Potenzierungen die Verwendung von Zeigern verlangt wird und es trotz dieser Verwendung zu Fehlermeldungen gekommen ist. Erst durch die Webseite : chat.openai.com/auth/login habe ich die Information erhalten , dass es die Funktion Math.pow für Potenzierungen gibt.
Auch wenn die Webseite : chat.openai.com/auth/login nicht immer richtige Antworten oder nur teilweise richtige Antworten auf Fragen zur Programmierung gibt, habe ich sie doch als hilfreich empfunden, auch in Bezug auf die Übersetzung von Code aus Visual Basic in C # .

Pardon für die späte Antwort. Ich hatte die beiden Programme nur in der Form getestet das ich im Visual Studio im Ordner Source Repos die jeweilige Datei des Projektes mit der Endung „ Sin „ geöffnet und dann im jeweiligen Projekt auf das kleine grüne Dreieck gedrückt hatte, mit dem man die App dann startet. Mittlerweile habe ich von dem Programm in C# die Datei mit der Endung „ EXE „ getestet, die sich im Ordner : Source Repos Appname bin debug net6.0-windows befindet. Diese Datei mit der Endung “ EXE „ rechnet bezogen auf das Beispiel, welches ich genannt hatte, 6 minuten und 46 Sekunden. Was ja fast genauso schnell wie die Visual Basic Variante ist. Gerne hätte ich auch die Visual Basic Variante der EXE Datei getestet, aber im Gegensatz zur C# Variante startet diese Visual Basic Variante nur, wenn ich sie mit dem Visual Studio im Ordner Source Repos Appname bin debug net6.0-windows öffne. Ich vermute, dass dies daran liegt, dass ich in dem Visual Basic Projekt im Menü „ erstellen „ auf " RSA Test App erstellen „ geklickt hatte ( ich hatte fälschlicherweise geglaubt, das ich damit die Exe Datei erzeugen würde. ) und daraufhin im Ordner : Source Repos Appname eine Datei mit der Endung „ Vbproj „ aufgetaucht ist. Jetzt frage ich mich, wie ich die Visual Basic Variante der EXE Datei dazu bringen kann, dass ich diese wie die C# Variante unabhängig vom Visual Studio starten kann. Im Menü Erstellen auf „ Projektmappe neu erstellen „ zu klicken bringt nichts. Noch etwas kurzes in Bezug auf die Webseite : chat.openai.com/auth/login Zumindest in Bezug auf das übersetzen von Visual Basic in C# erschien es mir so, dass diese Seite weniger Fehler zu machen schien, als eine Seite die eigentlich den Zweck der Übersetzung hat.