Code-Beispiel

Diffie-Hellman Demo

Lizenz:	Erster Autor:	Letzte Bearbeitung:
k. A.	schildron	17.01.2012
Diffie-Hellman Demostration

Der folgende Code stellt das Diffie-Hellman Verfahren zur Schlüssel erzeugung dar. Damit lassen sich auf sicherem Weg Schlüssel für andere kryptografische Verfahren austauschen.

Der folgende Code wurde zwar vielfach getestet, vereinzelte Fehler sind aber dennoch nicht ausgeschlossen. Zum Verschlüsseln von hoch-kritischer Information verwenden Sie deshalb bitte eine 'professionelle' Softwarelösung.
'--------------------------------------

'--------------------------------------

'Diffie-Hellman-Demoprogramm

'2011 by Schildron

'FBC 0.23.0

'--------------------------------------

'--------------------------------------



Randomize Timer , 3



#Include Once "big_int/big_int_full.bi"



#Ifndef NULL

#define NULL 0

#EndIf



Function ToStr (ByVal num As big_int Ptr) As String

    Dim As big_int_str Ptr s



    s = big_int_str_create( 1 )

    If( s = NULL ) Then

        Exit Function

    End If



    If( big_int_to_str( num, 10, s ) <> 0 ) Then

        Exit Function

    End If



    Return *s->Str



    big_int_str_destroy( s )



End Function



Sub print_num (ByVal num As big_int Ptr)

    Dim As big_int_str Ptr s



    s = big_int_str_create( 1 )

    If( s = NULL ) Then

        Exit Sub

    End If



    If( big_int_to_str( num, 10, s ) <> 0 ) Then

        Exit Sub

    End If



    Print *s->Str



    big_int_str_destroy( s )



End Sub



Print "-----------------------------------"

Print "Diffie-Hellman Demonstration"

Print "2011 by Schildron"

Print "-----------------------------------"

Print

Print



'------------------------------------------

'Eingabe des Nutzers

'------------------------------------------

Dim As ULongInt Eingabe_Lange

Dim As ULongInt Position

Input "Primzahlenlänge eingeben [Stellen (min 5)]: ", Position



If Position < 5 Then Position = 5

Eingabe_Lange = Position



'------------------------------------------

'Generiere nachste Primzahl

'------------------------------------------

'Zehnerpotenz mit Nachkomma Stellen für Vielfalt

Dim As big_int Ptr big_Position

big_Position = big_int_create( 1 )



Dim As String String_ZielPrim

For counter As Integer = 1 To Position

    String_ZielPrim = String_ZielPrim & Str(Int(Rnd*10))

Next counter



'-------------------------

'String in big_int umwandeln

String_ZielPrim = RTrim(LTrim(String_ZielPrim))     'leerzeichen vorne/hinten abfangen



Dim As big_int_str Ptr MyString

MyString = big_int_str_create( 1 )



big_int_str_copy_s( StrPtr( String_ZielPrim ), Len( String_ZielPrim ), MyString )

big_int_from_str(MyString,10,big_Position)



big_int_str_destroy(MyString)



'Primzahl generieren

Print "// generiere Primzahl //"

Dim As Integer Checksum = 0



Dim As big_int Ptr big_NextPrime

big_NextPrime = big_int_create( 1 )

big_int_next_prime(big_Position,big_NextPrime)



'Fertige Primzahl ausgeben

print_num(big_NextPrime)



'------------------------

'Für g: Summe kleiner Primzahl

'------------------------

Print "// generiere Basis g //"

Dim As ULongInt ProduktPrimzahlenKlein

Dim As Integer KleinePrim_Grosse



For Counter As Integer = 2 To 300'KleinePrim_Grosse



    Checksum = 0

    For i As Integer = 2 To Int(Sqr(Counter))+1

        If Counter Mod i = 0 Then Checksum = 1  'Primzahl NICHT mehr möglich

    Next  i



    If Checksum = 0 Then ProduktPrimzahlenKlein += Counter  'Um Counterwert erhöhen



Next Counter



'--------------------------

'Basis g berechnen

'--------------------------

Dim As big_int Ptr big_GrFaktor, big_GemFaktor, big_ProduktPrimzahlenKlein, big_eins

big_GrFaktor = big_int_create( 1 )

big_GemFaktor = big_int_create( 1 )

big_ProduktPrimzahlenKlein = big_int_create( 1 )

big_eins = big_int_create( 1 )

big_int_from_int( 1 , big_eins )



big_int_sub(big_NextPrime,big_eins,big_GrFaktor)



big_int_from_int( ProduktPrimzahlenKlein , big_ProduktPrimzahlenKlein )



big_int_div(big_GrFaktor,big_ProduktPrimzahlenKlein,big_GemFaktor)



Do While (Val(ToStr(big_GemFaktor)) > 1)

    big_int_div(big_GrFaktor,big_GemFaktor,big_GrFaktor)

    big_int_div(big_GrFaktor,big_ProduktPrimzahlenKlein,big_GemFaktor)

Loop



Dim As big_int Ptr big_Prim_1

big_Prim_1 = big_int_create( 1 )

big_int_sub(big_NextPrime,big_eins,big_Prim_1)

Dim As ULongInt Basis

big_int_div(big_Prim_1,big_GrFaktor,big_GrFaktor)



print_num(big_GrFaktor)     ''Basis g





Dim As ULongInt primzahl = Val(ToStr(big_NextPrime))

Basis = Val(ToStr(big_GrFaktor))



'----------------------------

'ALICE/BOB Zufallszahl

'----------------------------



'Zufallszahlen in String erzeugen

Dim As String String_Alice, String_Bob

For counter As Integer = 1 To Int(Eingabe_Lange*(Rnd*0.2+0.79)) 'Zufällige, Große Länge

    String_Alice = String_Alice & Str(Int(Rnd*10))

Next counter



For counter As Integer = 1 To Int(Eingabe_Lange*(Rnd*0.2+0.79)) 'Zufällige, Große Länge

    String_Bob = String_Bob & Str(Int(Rnd*10))

Next counter



'Variablen für große big_int Zufallszahl

Dim As big_int Ptr big_Alice, Big_Bob

big_Alice = big_int_create( 1 )

big_Bob = big_int_create( 1 )



'-------------------------

'String in big_int umwandeln

String_Alice = RTrim(LTrim(String_Alice))       'leerzeichen vorne/hinten abfangen

String_Bob = RTrim(LTrim(String_Bob))       'leerzeichen vorne/hinten abfangen



Dim As big_int_str Ptr MyString2

MyString2 = big_int_str_create( 1 )



big_int_str_copy_s( StrPtr( String_Alice ), Len( String_Alice ), MyString2 )

big_int_from_str(MyString2,10,big_Alice)



big_int_str_copy_s( StrPtr( String_Bob ), Len( String_Bob ), MyString2 )

big_int_from_str(MyString2,10,big_Bob)



big_int_str_destroy(MyString2)



Print

Print

Print "Zufallszahl von Alice:"

print_num( big_Alice )

Print "Zufallszahl von Bob:"

print_num( big_Bob )

Print



'----------------------------

'ALPHA/BETA

'----------------------------



Dim As big_int Ptr big_Alpha, big_Beta

Dim As big_int Ptr big_Ergebnis, big_Ergebnis2



big_Alpha = big_int_create( 1 )

big_Beta = big_int_create( 1 )



big_Ergebnis = big_int_create( 1 )

big_Ergebnis2 = big_int_create( 1 )



'Schritt eins

'Alice:

big_int_powmod(big_GrFaktor,big_Alice,big_NextPrime,big_Alpha)

'Bob:

big_int_powmod(big_GrFaktor,big_Bob,big_NextPrime,big_Beta)



Print

Print "Alphawert von Alice:"

print_num( big_Alpha )

Print "Betawert von Bob:"

print_num( big_Beta )

Print

'----------------------------

'Schlüssel berechnen

'----------------------------

'Alice:

big_int_powmod(big_Beta,big_Alice,big_NextPrime,big_Ergebnis)

'Bob:

big_int_powmod(big_Alpha,big_Bob,big_NextPrime,big_Ergebnis2)



Print

Print "Schlussel von Alice:"

print_num(big_Ergebnis)

Print

Print "Schlussel von Bob:"

print_num(big_Ergebnis2)





'-------------------------------

'Alle noch verbleibenden Variablen aus dem Speicher entfernen

'-------------------------------



big_int_destroy(big_Position)

big_int_destroy(big_NextPrime)



big_int_destroy(big_GrFaktor)

big_int_destroy(big_GemFaktor)

big_int_destroy(big_ProduktPrimzahlenKlein)

big_int_destroy(big_eins)

big_int_destroy(big_Prim_1)



big_int_destroy(big_Alpha)

big_int_destroy(big_Beta)

big_int_destroy(big_Alice)

big_int_destroy(Big_Bob)

big_int_destroy(big_Ergebnis)

big_int_destroy(big_Ergebnis2)



GetKey
Zusätzliche Informationen und Funktionen
Das Code-Beispiel wurde am 23.12.2011 von schildron angelegt.
Die aktuellste Version wurde am 17.01.2012 von schildron gespeichert.
Bearbeiten
Versionen