Diffi-Hellman-Schlüsselaustausch in VB.Net

    • VB.NET

    Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von picoflop.

      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.

      VB.NET-Quellcode

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

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

      VB.NET-Quellcode

      1. ' Beim Partner 1
      2. Dim a As Integer = random.Next(1, p-2)
      3. 'Bei Partner 2
      4. 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.

      VB.NET-Quellcode

      1. 'Partner 1
      2. Dim _A As Integer = Modular_Pow(g, a, p)
      3. 'Partner 2
      4. 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!

      VB.NET-Quellcode

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

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

      Quellcode

      1. K = B^a mod p = ( g^b mod p)^a mod p = g^(b*a) mod p = g^(a*b) mod p
      2. 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:
      Spoiler anzeigen

      VB.NET-Quellcode

      1. Public Class Diffi_Hellman_Key_Exchange
      3. Private p As Long
      4. Private g As Long
      5. Private a As Long
      6. Private _A As Long
      7. Private _B As Long
      8. Private K As Long
      11. Public Function Init(ByVal Prime_Number As Long, ByVal Primitive_Root As Long) As Long
      12. If Not Primitive_Root < (Prime_Number - 2) Then
      13. Return -1
      14. End If
      15. If Not Is_Prime_Number(Prime_Number) Then
      16. Return -1
      17. End If
      18. _B = -1
      19. K = -1
      20. p = Prime_Number
      21. g = Primitive_Root
      22. Dim r As New Random
      23. a = r.Next(1, p - 2)
      24. _A = Modular_Pow(g, a, p)
      25. Return _A
      26. End Function
      29. Public Function Is_Prime_Number(ByVal n As Long) As Boolean
      30. Dim b As Boolean = True
      31. For i As Integer = 2 To Int(Math.Sqrt(n))
      32. If (n Mod i = 0) Then
      33. b = False
      34. Return b
      35. End If
      36. Next i
      37. Return b
      38. End Function
      41. Public Function Modular_Pow(ByVal a As Long, ByVal b As Long, ByVal m As Long) As Long
      43. Dim result As Long = 1
      44. While b > 0
      45. If (b And 1) = 1 Then
      46. result = (result * a) Mod m
      47. End If
      48. b >>= 1
      49. a = (a * a) Mod m
      50. End While
      51. Return result
      53. End Function
      56. Public Function Calc_Key(ByVal Received_Number_B As Long) As Long
      57. _B = Received_Number_B
      58. K = Modular_Pow(_B, a, p)
      59. Return K
      60. End Function
      62. Public ReadOnly Property Prime_Number() As Long
      63. Get
      64. Return p
      65. End Get
      66. End Property
      68. Public ReadOnly Property Primitive_Root() As Long
      69. Get
      70. Return g
      71. End Get
      72. End Property
      74. Public ReadOnly Property Random_Number() As Long
      75. Get
      76. Return a
      77. End Get
      78. End Property
      80. Public ReadOnly Property Calculated_Value_A_To_Send() As Long
      81. Get
      82. Return _A
      83. End Get
      84. End Property
      86. Public ReadOnly Property Key() As Long
      87. Get
      88. Return K
      89. End Get
      90. End Property
      92. Public Property Received_Value_B() As Long
      93. Get
      94. Return _B
      95. End Get
      96. Set(ByVal value As Long)
      97. _B = value
      98. K = Calc_Key(value)
      99. End Set
      100. End Property
      102. Public Sub New()
      103. p = -1
      104. g = -1
      105. a = -1
      106. _A = -1
      107. K = -1
      108. _B = -1
      109. End Sub
      111. 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“ ()

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

      VB.NET-Quellcode

      1. Public Function Modular_Pow(ByVal a As Long, ByVal b As Long, ByVal m As Long) As Long
      3. Dim result As Long = 1
      4. While b > 0
      5. If (b And 1) = 1 Then
      6. result = (result * a) Mod m
      7. End If
      8. b >>= 1
      9. a = (a * a) Mod m
      10. End While
      11. Return result
      13. 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.