Selbsterfundener Codier- oder Verschlüsselungdsalgorythmus mit Erklärung - VB.NET

Public Class Form1
    'Variablen für Klar- und CodeText und Schlüssel  
    Dim KText As String
    Dim CText As String
    Dim Key As String
    'Benutztes Alphabet; Zeichensatz  
    Dim Alphabet As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz.,-_!?()^'äöü0123456789"  

    'Coder definieren  
    Dim WithEvents Coder As New Coder(Alphabet)
    Private Sub Verschlüsseln_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Verschlüsseln.Click
        'Alles leeren  
        Schlüssel.Text = ""  
        Key = ""  
        CodeText.Text = ""  
        CText = ""  
        'Überprüfen ob KlarText leer ist, wenn ja, Fehler melden,  
        ' Fokus auf Klartext und Sub abbrechen  
        If KlarText.Text <> "" Then  
            KText = KlarText.Text
        Else
            MsgBox("Bitte Klartext eingeben.")  
            KlarText.Focus()
            Exit Sub
        End If
        'Text mit Coder(-Funktionen) verschlüsseln  
        CodeText.Text = Coder.Encrypt(KText)
        Schlüssel.Text = Coder.Key
        'Bei Fehler Ausgaben löschen  
        If Fehler Then
            Fehler = False
            CodeText.Text = "Fehler aufgetreten"  
            Schlüssel.Text = "Fehler aufgetreten"  
        End If
    End Sub

    Private Sub Entschlüsseln_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Entschlüsseln.Click
        'Alles leeren  
        KlarText.Text = ""  
        KText = ""  
        'Überprüfen ob CodeText leer ist, wenn ja, Fehler melden,  
        ' Fokus auf CodeText und Sub abbrechen  
        If CodeText.Text <> "" Then  
            CText = CodeText.Text
        Else
            MsgBox("Bitte Codetext eingeben.")  
            CodeText.Focus()
            Exit Sub
        End If
        'Überprüfen ob Schlüssel leer ist, wenn ja, Fehler melden,  
        ' Fokus auf Schlüssel und Sub abbrechen  
        If Schlüssel.Text <> "" Then  
            Key = Schlüssel.Text
        Else
            MsgBox("Bitte Schlüssel eingeben.")  
            Schlüssel.Focus()
            Exit Sub
        End If
        'Text mit Coder(-Funktionen) entschlüsseln  
        KlarText.Text = Coder.Decrypt(CText, Key)
        'Bei Fehler Ausgaben löschen  
        If Fehler Then
            Fehler = False
            KlarText.Text = "Fehler aufgetreten"  
        End If
    End Sub

    'Variable die Anzeigt, ob Fehler aufgetreten ist  
    Dim Fehler As Boolean
    Private Sub Coder_Fehler(ByVal ex As System.Exception, ByVal Location As String) Handles Coder.Fehler
        MsgBox("Fehler in Sub/Function " & Location & " :" & vbNewLine & "Fehler: " & vbNewLine & ex.Message)  
        Fehler = True
    End Sub
End Class

''' <summary>  
''' Stellt Funktionen zum Ver- und Entschlüsseln von Texten in Stringformat bereit  
''' </summary>  
''' <remarks></remarks>  
Public Class Coder
    Public Sub New()
    End Sub
    Public Sub New(ByVal Alphabet_ As String)
        _Alphabet = Alphabet_
    End Sub

    'Error Event  
    Public Event Fehler(ByVal ex As Exception, ByVal Location As String)

    'Variable für Schlüssel  
    Dim _Key As String
    Public ReadOnly Property Key() As String
        Get
            Return _Key
        End Get
    End Property

    'Benutztes Alphabet; Zeichensatz  
    Private _Alphabet As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz.,-_!?()^'äöü0123456789"  
    Public Property Alphabet() As String
        Get
            Return _Alphabet
        End Get
        Set(ByVal value As String)
            _Alphabet = value
        End Set
    End Property

    Private Function AlphabeteErzeugen(ByVal Paare(,) As Byte) As String()
        Try
            'Variable für die Alphabete  
            Dim Alphabete(Paare.Length / 2 - 1) As String

            'Schleife für alle Alphabete ablaufen  
            For i As Byte = 0 To Paare.Length / 2 - 1
                'Endscheiden ob das zum aktuellen Alphabet gehörende  
                'a kleiner oder grösser als das b ist, und entsprechende Begrenzungen festlegen  
                If Paare(i, 0) < Paare(i, 1) Then
                    Alphabete(i) = AKleinerB(Paare(i, 0), Paare(i, 1))
                Else
                    Alphabete(i) = AGrösserB(Paare(i, 0), Paare(i, 1))
                End If
            Next
            Return Alphabete
        Catch ex As Exception
            RaiseEvent Fehler(ex, "AlphabeteErzeugen")  
            Return Nothing
        End Try
    End Function

    'Begrenzungsfunkitonen, die die entsprechenden Begrenzungen in das Array Begrenzungen schreiben  
    'und die Alphabetgenerierung starten, und deren generierte Alphabete zurückgeben  
    'Was die Begrenzungen bedeuten, wird unten erklärt  
    Private Function AKleinerB(ByVal a As Byte, ByVal b As Byte)
        Try
            'Array für die Begrenzungen und Schritte der Code-Alphabete  
            Dim Begrenzungen(2, 2) As SByte
            Begrenzungen(0, 0) = b
            Begrenzungen(0, 1) = -1
            Begrenzungen(0, 2) = a + 1
            Begrenzungen(1, 0) = 1
            Begrenzungen(1, 1) = 1
            Begrenzungen(1, 2) = a
            Begrenzungen(2, 0) = _Alphabet.Length
            Begrenzungen(2, 1) = -1
            Begrenzungen(2, 2) = b + 1
            'Generiertes Alphabet zurückgeben  
            Return AlphabetReihenfolge(Begrenzungen)
        Catch ex As Exception
            RaiseEvent Fehler(ex, "AKleinerB")  
            Return Nothing
        End Try
    End Function
    Private Function AGrösserB(ByVal a As Byte, ByVal b As Byte)
        Try
            'Array für die Begrenzungen und Schritte der Code-Alphabete  
            Dim Begrenzungen(2, 2) As SByte
            Begrenzungen(0, 0) = a + 1
            Begrenzungen(0, 1) = 1
            Begrenzungen(0, 2) = _Alphabet.Length
            Begrenzungen(1, 0) = b
            Begrenzungen(1, 1) = -1
            Begrenzungen(1, 2) = 1
            Begrenzungen(2, 0) = b + 1
            Begrenzungen(2, 1) = 1
            Begrenzungen(2, 2) = a - 1
            'Generiertes Alphabet zurückgeben  
            Return AlphabetReihenfolge(Begrenzungen)
        Catch ex As Exception
            RaiseEvent Fehler(ex, "AGrösserB")  
            Return Nothing
        End Try
    End Function
    'Funktion, die die Zeichen aus Alphabet in der richtigen Reihenfolgen in das Code-Alphabet einfügt  
    Private Function AlphabetReihenfolge(ByVal Begrenzungen(,) As SByte) As String
        Try
            'Variable für das Alphabet  
            Dim Alphabet As String = ""  

            'Variable, die anzeigt in welchem der drei Abschnitte eines Alphabets man sich befindet  
            Dim Abschnitt As Byte = 0 'Startwert: Am Anfang ist man immer im ersten Abschnitt  

            'Variable, die anzeigt, das wievielte Zeichen gerade bearbeitet wird  
            Dim Zeichen As Byte = Begrenzungen(0, 0) 'Startwert: Das Zeichen, mit dem man beginnt  

            'Variable, die bestimmt ob die Zeichen aus Alphabet in auf- oder absteigender   
            'Reihenfolge behandelt werden  
            Dim Schritt As SByte = Begrenzungen(0, 1) 'Startwert: Wert aus Begrenzungen  

            'Die nachfolgenden Schritte werden soviel mal ausgeführt, wie Alphabet lang ist  
            For i As Byte = 0 To _Alphabet.Length - 1

                'Das Zeichen an der Stelle Zeichen-1 aus dem "alten" Alphabet wird an das zu   
                'bearbeitende Alphabet angefügt  
                Alphabet &= _Alphabet.ElementAt(Zeichen - 1)

                ' Prüfen, ob das gerade bearbeitete Zeichen das letzte eines Abschnitts ist  
                If Zeichen = Begrenzungen(Abschnitt, 2) Then

                    'Wenn der alte Abschnitt der letzte war, dann zu nächstem i springen  
                    'Gleichbedeutend mit Exit for (nur in diesem Fall!)  
                    If Abschnitt = 2 Then Continue For

                    '(Sonst) Abschnitt um 1 erhöhen  
                    Abschnitt += 1

                    'Nächstes zu bearbeitende Zeichen mithilfe des Array Begrenzungen laden  
                    Zeichen = Begrenzungen(Abschnitt, 0)
                    'Gleiches für Schritte  
                    Schritt = Begrenzungen(Abschnitt, 1)
                Else
                    'Wenn kein neuer abschnitt beginnt, nächstes Zeichen entsprechend Schritt nehmen  
                    Zeichen += Schritt
                End If
            Next
            Return Alphabet
        Catch ex As Exception
            RaiseEvent Fehler(ex, "AlphabetReihenfolge")  
            Return Nothing
        End Try
    End Function

    'Verschlüsselungsfunktion  
    Public Function Encrypt(ByVal KText As String)
        Try
            Dim CText As String = ""  

            'Zufälligen Schlüssel errechnen und Alphabete erzeugen und die Alphabete speichern  
            Dim Alphabete() As String = AlphabeteErzeugen(SchlüsselErzeugen(KText.Length))

            'Variable, die zeigt, welches Alphabet zur Verschlüsselung des nächsten Zeichen   
            'verwendet wird  
            Dim AlphabetNr As Byte = 0 'Startwert: Es wird immer mit dem ersten Alphabet begonnen  

            'Zu verschlüsselndes Zeichen  
            Dim ToCodeChar As Char

            'Schleife für jedes Zeichen in KText abarbeiten  
            For i As Integer = 0 To KText.Length - 1

                'Zu Codierendes Zeichen festlegen  
                ToCodeChar = KText.ElementAt(i)

                'Fehler wenn Zeichen nicht in Alphabet abfangen  
                If Not _Alphabet.Contains(ToCodeChar) Then
                    RaiseEvent Fehler(New Exception("Zeichen nicht in Alphabet enthalten"), "Encrypt")  
                    Return Nothing
                End If

                'Codiertes Zeichen an CText anfügen  
                CText &= Alphabete(AlphabetNr).ElementAt(_Alphabet.IndexOf(ToCodeChar))

                'Wenn das gerade verwendete Code-Alphabet nicht das letzte war, dann nächstes nehmen  
                'Entspricht einer ModuloFunktion:  
                AlphabetNr = (AlphabetNr + 1) Mod Alphabete.Count()
            Next

            'Ergebnis zurückgeben  
            Return CText
        Catch ex As Exception
            RaiseEvent Fehler(ex, "Encrypt")  
            Return Nothing
        End Try
    End Function
    'Funktion die einen Schlüssel mit maximallänge berrechnet und die errechneten Paare zurückgibt  
    Private Function SchlüsselErzeugen(ByVal MaxLength As Integer) As Byte(,)
        Try
            'Array für die Paare  
            Dim Paare(8, 1) As Byte

            'Grösster Wert der als Zahl für ein Paar genommen werden kann  
            Dim Max As Byte = _Alphabet.Length

            'Die beiden Zahlen eines Paars  
            Dim a As Byte
            Dim b As Byte

            'Anzahl der Paare: KTextlänge -1 aber kleiner als 10   
            Dim AnzahlPaare As Byte = MaxLength
            If AnzahlPaare > 9 Then AnzahlPaare = 9

            'Kette aller Zahlen, die für jedes Paare eine eindeutige (für jedes mögliche Paar   
            'eine andere) aus a und b berechnet werden  
            Dim Kombinationen As String = ""  

            'Kette aller Zeichenanzahlen der Kombinationen  
            Dim KombinationenZeichen As String = ""  

            'Zufallsgenerator Initialisieren  
            Randomize()

            'Die Paare erzeugen  
            For i As Byte = 0 To AnzahlPaare - 1

                'Erste Zahl des Paars; zwischen 2 und max  
                a = CByte(Int(2 + (Max - 2) * Rnd()))

                'Zweite Zahl; Wenn gleich erste, dann neue Zahl nehmen  
                Do
                    b = CByte(Int(2 + (Max - 2) * Rnd()))
                Loop Until a <> b

                'a und b in Paare schreiben:  
                Paare(i, 0) = a
                Paare(i, 1) = b

                'Kombinationszahl aus a und b berechnen und an Kombinationen anfügen  
                'Zur Erklärung siehe ganz am Ende des Codes  
                Kombinationen = Kombinationen & (a - 1) * Max + b
                'Anzahl Zeichen der neuen Kombination an KombinationenZeichen  
                KombinationenZeichen &= Str((a - 1) * Max + b).Length - 1
            Next

            'Kombinationen und KombinationenZeichen zusammenfügen  
            _Key = Kombinationen & KombinationenZeichen
            'Letzte Zeichenkettenlänge abschneiden und AnzahlPaare anfügen  
            _Key = Microsoft.VisualBasic.Left(_Key, _Key.Length - 1) & AnzahlPaare
            Return Paare
        Catch ex As Exception
            RaiseEvent Fehler(ex, "SchlüsselErzeugen")  
            Return Nothing
        End Try
    End Function

    'Enschlüsselungsfunktion  
    Public Function Decrypt(ByVal CText As String, ByVal Key_ As String) As String
        Try
            'Schlüssel in Schlüsselvariable speichern  
            _Key = Key_

            Dim KText As String = ""  

            'Paare ausrechnen und Alphabete erzeugen und Alphabete in Variable speichern  
            Dim Alphabete As String() = AlphabeteErzeugen(ErrechnePaare())

            'Variable, die zeigt, welches Alphabet zur Verschlüsselung des nächsten Zeichen   
            'verwendet wird  

            Dim AlphabetNr As Byte = 0 'Startwert: Es wird immer mit dem ersten Alphabet begonnen  

            'Zu verschlüsselndes Zeichen  
            Dim ToDecodeChar As Char

            'Schleife für jedes Zeichen in KText abarbeiten  
            For i As Integer = 0 To CText.Length - 1
                'Zu Codierendes Zeichen festlegen  
                ToDecodeChar = CText.ElementAt(i)
                'Codiertes Zeichen an CText anfügen  
                KText &= _Alphabet.ElementAt(Alphabete(AlphabetNr).IndexOf(ToDecodeChar))
                'Wenn das gerade verwendete Code-Alphabet nicht das letzte war, dann nächstes nehmen  
                'Entspricht einer ModuloFunktion:  
                AlphabetNr = (AlphabetNr + 1) Mod Alphabete.Count
            Next

            'Ergebnis zurückgeben  
            Return KText
        Catch ex As Exception
            RaiseEvent Fehler(ex, "Decrypt")  
            Return Nothing
        End Try
    End Function
    'Funktion die aus dem Schlüssel die Paare zurückgewinnt  
    Private Function ErrechnePaare() As Byte(,)
        Try
            'Variable für die Anzahl der Alphabete  
            Dim AnzahlAlphabete As Byte = CByte(CStr(_Key.Last))

            'Variable, die am Schluss zurückgegeben wird  
            Dim Paare(AnzahlAlphabete - 1, 1) As Byte

            'In dieser Variable steht der Teil des Schlüssels, der die Zeichenanzahlen der  
            'Paarkombinationen enthält. Dabei steht in AnzahlAlphabete das letzte Zeichen   
            'des Schlüssels. Dies sagt wieviele Paare man braucht. Da im Schlüssel die Zeichen-  
            'zahl des letzten fehlt, kann man die Zahl ohne Umrechnug nehmen  
            Dim PaareZeichen As String = Microsoft.VisualBasic.Right(_Key, AnzahlAlphabete)

            'Das letzte Zeichen, das das die Paaranzahl enthält, wird Abgeschnitten  
            PaareZeichen = Microsoft.VisualBasic.Left(PaareZeichen, AnzahlAlphabete - 1)

            'Diese Variable enthält den Teil des Schlüssels, der die zusammengefügten Paarkomb-  
            'binationen enthält. Das ist alles bis auf den Teil, der in PaareZeichen steht  
            Dim Bearbeit_Key As String = Microsoft.VisualBasic.Left(_Key, _Key.Length - AnzahlAlphabete)

            'Hier wird die Kombinationszahl des gerade bearbeitenden Paares gespeichert  
            Dim PaarKombiniert As Integer

            'Schleife wird für jedes Paar abgearbeitet  
            For i As Byte = 0 To AnzahlAlphabete - 1

                'Wenn nicht das letzte Paar bearbeitet wird...  
                If i < AnzahlAlphabete - 1 Then
                    '...dann die entsprechende Anzahl Zeichen (steht in PaareZeichen an i-ter stelle)  
                    ' von Bearbeit_Key abschneiden und in PaarKombiniert schreiben.  
                    PaarKombiniert = Microsoft.VisualBasic.Left( _
                        Bearbeit_Key, Microsoft.VisualBasic.Val(PaareZeichen.ElementAt(i)))

                    'Der Teil der in PaarKombiniert steht, von Bearbeit_Key abschneiden  
                    Bearbeit_Key = Microsoft.VisualBasic.Right(Bearbeit_Key, _
                                Bearbeit_Key.Length - CStr(PaarKombiniert).Length)
                Else
                    '...Sonst den Bearbeit_Key in PaarKombiniert laden, da die Zeichenanzahl nicht in  
                    'PaareZeichen steht (wurde bei der SChlüsselerzeugung abgeschnitten). Der Rest  
                    'ist aber sowieso das was man noch braucht  
                    PaarKombiniert = Bearbeit_Key
                End If

                'Erklärung zur Berechnung siehe ganz am Ende des Codes  
                Paare(i, 0) = Int(PaarKombiniert / (_Alphabet.Length)) + 1
                Paare(i, 1) = PaarKombiniert - (_Alphabet.Length) * (Paare(i, 0) - 1)
            Next
            Return Paare
        Catch ex As Exception
            RaiseEvent Fehler(ex, "ErrechnePaare")  
            Return Nothing
        End Try
    End Function
End Class

'Erklärung zum Aufbau der Alphabete  
'der Einfachheit halber wird hier das Grundalphabet "ABCDEFGHIJ" benutzt  
'  
'Jedes aus dem Grundalphabet generierte Alphabet lässt sich mit zwei Zahlen (a und b) definieren:  
'Wenn a kleiner b, dann sieht der Aufbau so aus:  
'z.B.: (a=4,b=8)  
'A B C D|E F G H|I J  
'       a       b  
'------>|<------|<--  
'   2.      1.    3.  
'-->Das Alphabet wir din 3 Teile geteilt (an den Stellen nach dem a-ten und b-ten Zeichen)  
'Diese Stücke werden dann in der oben genannten Richtung und Reihenfolge abgearbeitet:  
'H G F E|A B C D|J I  
'   1.      2.    3.  

'Ähnliches für a grösser b:  
'z.B.: (a=7,b=3)  
'A B C|D E F G|H I J  
'     b       a  
'<----|------>|---->  
'  2.     3.     1.  
'-->  
'H I J|C B A|D E F G  
'  1.    2.     3.  
'  
'  
'Erklärung zum Begrenzungsarry:  
'Hier drin werden die Begrenzungen der 3 Teilstücke abgespeichert, und zwar nach folgendem Schema:  
'Beg(x,0):Start des x-ten Teils  
'Beg(x,1):Richtung des x-ten Teils (-1,+1)  
'Beg(x,2):Ende des x-ten Teils  
'  
'  
'Erklärung zur Berechnug Paarkombination aus Paar und Umgekehrt:  
'  
'Man sollte sich eine quadratische Tabelle mit der Anzahl Reihen und Spalten vorstellen,  
'wie das benutzte Alphabet Buchstaben hat. Der Einfachheit halber wird hier eine 10x10 Tabelle  
'benutzt.  
'Bsp: (a und b sind nacher die Zahlen aus denen das Paar besteht)  
'  
' 1  2  3  4  5  6  7  8  9  10  
' 11 12 13 14 15 16 17 18 19 20   
' 21 22 23 24 25 26 27 28 29 30  
' 31 32 33 34 35 36 37 38 39 40  
' 41 42 43 44 45 46 47 48 49 50  
' 51 52 53 54 55 56 57 58 59 60  
' 61 62 63 64 65 66 67 68 69 70  
' 71 72 73 74 75 76 77 78 79 80  
' 81 82 83 84 85 86 87 88 89 90  
' 91 92 93 94 95 96 97 98 99 100  

'Die Felder werden von links nach rechts und von oben nach unten durchnummeriert.  
'Wenn man sich a als Spalten- und b als Zeilenindex vorstellt, die beide in einem Bereich  
'zwischen 1 und 5 (grösse der Tabelle) liegen, so sieht man, dass die Zehnerstelle dem a und  
'die Einerstelle dem b entspricht. Die Zehnerstelle lässt sich also so berechnen: a-1  
'Die Einerstelle ist einfach b. Zusammen hiesse das: Zehnerstelle*10 + Einerstelle.  
'Setzt man nun ein, so entsteht (a-1)*10+b. Das *10 lässt sich durch *Alphabetlänge ersetzen.  
'Dann hat man die im Code verwendete Formel ((a-1)*Alphabet.Length-1)+b. Das -1 kommt vom  
'Index, der bei 0 oder 1 beginnt.  
'  
'Die Umkehrung sollte sich nach etwas Überlegen selbst erklären. Die Formeln sind, um sie nicht  
'suchen zu müssen, hier nochmal hingeschrieben:  
'a = Int(Paar / Alphabet.Length  
'b = Paar - (a - 1) * Alphabet.Length  
'Abgeändert auf das 10*10 Feld:  
'a = Int((Paar - 1) / 10 ; Das - 1 nach Paar kommt davon, dass b im Beispiel 10 (Breite  
'der Tabelle) sein kann, im Code jedoch nicht.  
'b = Paar - (a-1) * 10  

   Private Sub New()
        Me.KlarText = New System.Windows.Forms.TextBox()
        Me.CodeText = New System.Windows.Forms.TextBox()
        Me.Entschlüsseln = New System.Windows.Forms.Button()
        Me.Verschlüsseln = New System.Windows.Forms.Button()
        Me.Schlüssel = New System.Windows.Forms.TextBox()
        Me.Label1 = New System.Windows.Forms.Label()
        Me.Label2 = New System.Windows.Forms.Label()
        Me.Label3 = New System.Windows.Forms.Label()
        Me.SuspendLayout()
        '  
        'KlarText  
        '  
        Me.KlarText.Font = New System.Drawing.Font("Microsoft Sans Serif", 8.25!)  
        Me.KlarText.Location = New System.Drawing.Point(57, 13)
        Me.KlarText.Name = "KlarText"  
        Me.KlarText.Size = New System.Drawing.Size(380, 20)
        Me.KlarText.TabIndex = 0
        '  
        'CodeText  
        '  
        Me.CodeText.Font = New System.Drawing.Font("Microsoft Sans Serif", 8.25!)  
        Me.CodeText.Location = New System.Drawing.Point(57, 40)
        Me.CodeText.Name = "CodeText"  
        Me.CodeText.Size = New System.Drawing.Size(380, 20)
        Me.CodeText.TabIndex = 1
        '  
        'Entschlüsseln  
        '  
        Me.Entschlüsseln.Location = New System.Drawing.Point(227, 93)
        Me.Entschlüsseln.Name = "Entschlüsseln"  
        Me.Entschlüsseln.Size = New System.Drawing.Size(210, 23)
        Me.Entschlüsseln.TabIndex = 2
        Me.Entschlüsseln.Text = "Entschlüsseln"  
        Me.Entschlüsseln.UseVisualStyleBackColor = True
        '  
        'Verschlüsseln  
        '  
        Me.Verschlüsseln.Location = New System.Drawing.Point(16, 93)
        Me.Verschlüsseln.Name = "Verschlüsseln"  
        Me.Verschlüsseln.Size = New System.Drawing.Size(209, 23)
        Me.Verschlüsseln.TabIndex = 3
        Me.Verschlüsseln.Text = "Verschlüsseln"  
        Me.Verschlüsseln.UseVisualStyleBackColor = True
        '  
        'Schlüssel  
        '  
        Me.Schlüssel.Font = New System.Drawing.Font("Microsoft Sans Serif", 8.25!)  
        Me.Schlüssel.Location = New System.Drawing.Point(74, 67)
        Me.Schlüssel.Name = "Schlüssel"  
        Me.Schlüssel.Size = New System.Drawing.Size(363, 20)
        Me.Schlüssel.TabIndex = 4
        '  
        'Label1  
        '  
        Me.Label1.AutoSize = True
        Me.Label1.Location = New System.Drawing.Point(13, 19)
        Me.Label1.Name = "Label1"  
        Me.Label1.Size = New System.Drawing.Size(38, 13)
        Me.Label1.TabIndex = 5
        Me.Label1.Text = "KText:"  
        '  
        'Label2  
        '  
        Me.Label2.AutoSize = True
        Me.Label2.Location = New System.Drawing.Point(13, 43)
        Me.Label2.Name = "Label2"  
        Me.Label2.Size = New System.Drawing.Size(38, 13)
        Me.Label2.TabIndex = 6
        Me.Label2.Text = "CText:"  
        '  
        'Label3  
        '  
        Me.Label3.AutoSize = True
        Me.Label3.Location = New System.Drawing.Point(13, 70)
        Me.Label3.Name = "Label3"  
        Me.Label3.Size = New System.Drawing.Size(55, 13)
        Me.Label3.TabIndex = 7
        Me.Label3.Text = "Schlüssel:"  
        '  
        'Form1  
        '  
        Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!)
        Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
        Me.ClientSize = New System.Drawing.Size(449, 128)
        Me.Controls.Add(Me.Label3)
        Me.Controls.Add(Me.Label2)
        Me.Controls.Add(Me.Label1)
        Me.Controls.Add(Me.Schlüssel)
        Me.Controls.Add(Me.Verschlüsseln)
        Me.Controls.Add(Me.Entschlüsseln)
        Me.Controls.Add(Me.CodeText)
        Me.Controls.Add(Me.KlarText)
        Me.Name = "Form1"  
        Me.Text = "Codierung"  
        Me.ResumeLayout(False)
        Me.PerformLayout()

    End Sub
    Friend WithEvents KlarText As System.Windows.Forms.TextBox
    Friend WithEvents CodeText As System.Windows.Forms.TextBox
    Friend WithEvents Entschlüsseln As System.Windows.Forms.Button
    Friend WithEvents Verschlüsseln As System.Windows.Forms.Button
    Friend WithEvents Schlüssel As System.Windows.Forms.TextBox
    Friend WithEvents Label1 As System.Windows.Forms.Label
    Friend WithEvents Label2 As System.Windows.Forms.Label
    Friend WithEvents Label3 As System.Windows.Forms.Label