Buchempfehlung
MySQL kurz & gut
MySQL kurz & gut
Das preiswerte Taschen- buch stellt MySQL-rele- vante Inhalte systematisch und knapp dar, sodass es sich optimal zum Nach- schlagen beim Pro- grammieren eignet. [Mehr Infos...]
FreeBASIC-Chat
Es sind Benutzer im FreeBASIC-Chat online.
(Stand:  )
FreeBASIC bei Twitter
Twitter FreeBASIC-Nachrichten jetzt auch über Twitter erhalten. Follow us!

Code-Beispiel

Code-Beispiele » Verschlüsselung

Diffie-Hellman Demo

Lizenz:Erster Autor:Letzte Bearbeitung:
k. A.Mitgliedschildron 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 Mitgliedschildron angelegt.
  • Die aktuellste Version wurde am 17.01.2012 von Mitgliedschildron gespeichert.
  Bearbeiten Bearbeiten  

  Versionen Versionen