Du bist nicht angemeldet.

[VB.NET] Diffi-Hellman-Schlüsselaustausch in VB.Net

Nibel

adorable

  • »Nibel« ist der Autor dieses Themas

Beiträge: 210

Dabei seit: 7. April 2010

Hilfreich-Bewertungen: 18

  • Private Nachricht senden

1

Montag, 30. August 2010, 20:41

Diffi-Hellman-Schlüsselaustausch in VB.Net

Hi Leute,

ich zeige euch heute wie ein Diffi-Hellman-Schlüsselaustausch funktioniert. Diese Methode benutzen 2 Kommunikationspartner in einem unsicherem Netz, damit dies keiner abhören kann. D.h. damit könntet ihr verschlüsselte Nachrichten austauschen, ohne das sie gelesen werden können. Ihr dürft sie natürlich nicht so in einem einfachen Client speichern, der kann sehr einfach dekompiliert werden.
Also guckt euch mal lieber den Wikipedia-Artikel an, der kann das besser erklären : D
Das Prinzip basiert darauf, das 2 Zahlen ausgetauscht werden können, die einem Abhörer nichts bringen. Die Partner können aber daraus einen Key berechnen. Der Key ist jedes Mal ein anderer -> Man kann ihn auch nicht aus dem Quellcode berechnen
So als erstes speichern beide Partner 2 konstante Zahlen ab, die bei beiden gleich sein muss! Die eine ist eine Primzahl p, die 2. ist eine sog. Primitivwurzel g, welche kleiner als die Primzahl - 2 sein muss.
Nehmen wir einfach mal wie im Wiki als Beispiel p = 13 und g = 2.

Visual Basic Quellcode

 
1
2
3

'Bei beiden Partnern
Dim p As Integer = 13
Dim g As Integer = 2

Als nächstes berechnen die beiden Partner unhabhängig voneinander eine Zufahlszahl a und b gennant

Visual Basic Quellcode

 
1
2
3
4

' Beim Partner 1
Dim a As Integer = random.Next(1, p-2)
'Bei Partner 2
Dim b As Integer = random.Next(1, p-2)

Jetzt rechnen sich die Partner eine eigene Zahl aus, zu a entsprechend A und zu b dann B
Was Modular_Pow ist, seht ihr unten im Spoiler.

Visual Basic Quellcode

 
1
2
3
4

'Partner 1
Dim _A As Integer = Modular_Pow(g, a, p)
'Partner 2
Dim _B As Integer = Modular_Pow(g, b, p)

So das sind unsere Zahlen die übertragen werden. Jetzt hat Partner 1 die Zahl _B und P2 die Zahl _A
Daraus können jetzt beide den Key k berechnen, dieser wird aber nicht übertragen!

Visual Basic Quellcode

 
1
2
3
4

'Partner 1
K = Modular_Pow(_B, a, p)
'Partner 2
K = Modular_Pow(_A, b, p)

Jetzt kommt bei beiden das gleiche raus, was man an dieser Formel sehen kann:

Quellcode

 
1
2

K = B^a mod p = ( g^b mod p)^a mod p = g^(b*a) mod p = g^(a*b) mod p
K = A^b mod p = ( g^a mod p)^b mod p = g^(a*b) mod p

Sieht jetzt kompliziert aus, aber das müsst ihr euch nicht merken...
Ich habe auch mal eine ausführlichere Klasse dafür gebastelt:
 Hier klicken für weitere Informationen

Visual Basic Quellcode

 
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
101
102
103
104
105
106
107
108
109
110
111

Public Class Diffi_Hellman_Key_Exchange

Private p As Long
Private g As Long
Private a As Long
Private _A As Long
Private _B As Long
Private K As Long


Public Function Init(ByVal Prime_Number As Long, ByVal Primitive_Root As Long) As Long
    If Not Primitive_Root < (Prime_Number - 2) Then
        Return -1
    End If
    If Not Is_Prime_Number(Prime_Number) Then
        Return -1
    End If
    _B = -1
    K = -1
    p = Prime_Number
    g = Primitive_Root
    Dim r As New Random
    a = r.Next(1, p - 2)
    _A = Modular_Pow(g, a, p)
    Return _A
End Function


Public Function Is_Prime_Number(ByVal n As Long) As Boolean
    Dim b As Boolean = True
    For i As Integer = 2 To Int(Math.Sqrt(n))
        If (n Mod i = 0) Then
            b = False
            Return b
        End If
    Next i
    Return b
End Function


Public Function Modular_Pow(ByVal a As Long, ByVal b As Long, ByVal m As Long) As Long

        Dim result As Long = 1
        While b > 0
            If (b And 1) = 1 Then
                result = (result * a) Mod m
            End If
            b >>= 1
            a = (a * a) Mod m
        End While
        Return result

    End Function


Public Function Calc_Key(ByVal Received_Number_B As Long) As Long
    _B = Received_Number_B
    K = Modular_Pow(_B, a, p)
    Return K
End Function

Public ReadOnly Property Prime_Number() As Long
    Get
        Return p
    End Get
End Property

Public ReadOnly Property Primitive_Root() As Long
    Get
        Return g
    End Get
End Property

Public ReadOnly Property Random_Number() As Long
    Get
        Return a
    End Get
End Property

Public ReadOnly Property Calculated_Value_A_To_Send() As Long
    Get
        Return _A
    End Get
End Property

Public ReadOnly Property Key() As Long
    Get
        Return K
    End Get
End Property

Public Property Received_Value_B() As Long
    Get
        Return _B
    End Get
    Set(ByVal value As Long)
        _B = value
        K = Calc_Key(value)
    End Set
End Property

Public Sub New()
    p = -1
    g = -1
    a = -1
    _A = -1
    K = -1
    _B = -1
End Sub

End Class


Ich hoffe ich konnte euch helfen! Das ganze ist natürlich auch in php, c/c++, java usw. verfügbar, das müsst ich euch dann selber machen.

mfG Nibel

E: Danke an pico, wurde geändert!

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Nibel« (1. September 2010, 21:47)

Es haben bereits 2 registrierte Benutzer diesen Beitrag als hilfreich eingestuft.

Benutzer, die diesen Beitrag hilfreich fanden:

SenA, Triple-Axe

picoflop

Böse und gemein!

Beiträge: 5 843

Dabei seit: 19. März 2009

Hilfreich-Bewertungen: 546

  • Private Nachricht senden

2

Mittwoch, 1. September 2010, 07:48

Statt Math.Pow(a,b) mod m sollte man allerdings besser dieses verwenden:

Visual Basic Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13

Public Function Modular_Pow(ByVal a As Long, ByVal b As Long, ByVal m As Long) As Long

        Dim result As Long = 1
        While b > 0
            If (b And 1) = 1 Then
                result = (result * a) Mod m
            End If
            b >>= 1
            a = (a * a) Mod m
        End While
        Return result

    End Function


Math.Pow(a,b) wird irgendwann ungenau, da die Zahl in nem Double gespeichert wird und dabei fallen dann irgendwann signifikante Stellen weg. Ab einer bestimmten Größe kommt es außerdem zu einem Fehler, da das Zwischenergebnis (a hoch b) die maximale Größe eines Double überschreitet.
Von Hilfeanfragen via PN ist ABZUSEHEN!


GUI - Threading Best Of - Async - x64 Excp

Ähnliche Themen

Social Bookmarks