PureBoard

Verfasst: **07.09.2007 12:01**

Hallo,

habe mehr eine theoretische Frage und zwar geht es um das Thema Sicherheit.
Problem:

Habe ein Program welches für Datenbankverbindung und Verbindung zum Mail Account Username und Passwörter braucht. Um die Pws nicht im Quelltext ändern zu müssen, sollte sich was an den Accountdaten ändern, sollte dies auch per Konfiguration möglich sein.

Allerdings war bei mir alles soweit gedanklich schon klar (wie ich das aufbau) bis ich auf ein Problem gestoßen bin. Wenn ich Klartext->DES->MD5 verwende und das PW auslese komme ich nicht mehr an das Klartext pw. und das Programm versucht mit MD5 einzuloggen.

Die Daten sollen in einer config.ini abgespeichert werden, diese Datei soll ebenfalls verschlüsselt sein.
Ergo ich brauch ne leicht knackbare Verschlüsselung(oder ?) um selbst an die Daten ranzukommen. Ebenfalls sieht das mit PWs aus.. ich muss sie ja selbst wieder entschlüsseln können.
Nun stellt sich bei mir die Frage wie Verschlüssel ich alles um das ganze sicher zu halten.

Idee:

Ich lese irgendwie etwas PC spezifisches aus woraus ich einen Key bilde und dieser Key wird der Schlüssel der die Tür schließt und öffnet. Somit verhindere ich das jemand auf einen fremden PC erst Ver/Entschlüsselung anwenden kann oder ?

So und nun steh ich an einen Punkt wo ich erstmal nicht so recht weiterweiß, so das es sicher ist aber trotzdem funktioniert.
Was habt ihr so für Tipps ?

Ich hoffe bekomme ein paar Antworten, werde mir bis dahin überlegen wie ich den ganzen misst realisiere.

(Gibt es andere möglichkeiten die PWs abzuspeichern?)

Bye Bye

Verfasst: **07.09.2007 12:49**

Hier ist eine einfache assynchrone Verschlüsselung. Je länger der Key, desto
sicherer ist das ganze. Wenn der Key so lang ist wie das Passwort, dann ist
100%-ige Sicherheit garantiert, außer der Key fällt jemandem in die Hände.
Das hat dann aber nichts mehr mit der Sicherheit des Algorhytmus zu tun.

Code: Alles auswählen

EnableExplicit

Procedure Encode(Password.s, key.s, *Size.Long)
  Protected *c1.Character, *c2.Character, *mem, *c3.Character, c.c
  
  If *Size = 0 : ProcedureReturn #False : EndIf
  *Size\l = Len(Password) * SizeOf(Character)
  *mem = AllocateMemory(*Size\l)
  If *mem = 0 : ProcedureReturn #False : EndIf
  
  *c1 = @Password
  *c2 = @key
  *c3 = *mem
  c = 0
  While *c1\c
    If *c2\c = 0 : *c2 = @key : EndIf
    *c3\c = (*c1\c ! *c2\c) ! c
    c = *c3\c
    
    *c1 + SizeOf(Character)
    *c2 + SizeOf(Character)
    *c3 + SizeOf(Character)
  Wend
  
  ProcedureReturn *mem
EndProcedure

Procedure.s DeCode(*mem, key.s, length.l)
  Protected Password.s, *c1.Character, *c2.Character, c.c, a.l
  
  *c1 = *mem
  *c2 = @key
  c = 0
  For a = 1 To length
    If *c2\c = 0 : *c2 = @key : EndIf
    Password + Chr(*c1\c ! *c2\c ! c)
    c = *c1\c
    *c1 + SizeOf(Character)
    *c2 + SizeOf(Character)
  Next
  
  ProcedureReturn Password
EndProcedure

Procedure WritePW(FileID.l, Password.s, key.s) ;Zum Speichern eines Passwortes in einer Datei
  Protected *mem, length.l
  
  *mem = Encode(Password, key, @length)
  If *mem = 0 : ProcedureReturn #False : EndIf
  
  WriteLong(FileID, length)
  WriteData(FileID, *mem, length)
  
  FreeMemory(*mem)
  ProcedureReturn #True
EndProcedure
Procedure.s ReadPW(FileID.l, key.s) ;Zum Lesen eines Passwortes aus einer Datei
  Protected *mem, length.l, p.l, Password.s
  
  p = Loc(FileID)
  length = ReadLong(FileID)
  *mem = AllocateMemory(length)
  If *mem = 0
    FileSeek(FileID, p)
    ProcedureReturn ""
  EndIf
  ReadData(FileID, *mem, length)
  
  Password = DeCode(*mem, key, length)
  
  ProcedureReturn Password
EndProcedure

Define length.l, Password.s, key.s, *mem

Password = "Feel the Pure Power!"
key = "PureBoard"

*mem = Encode(Password, key, @length)

If *mem
  Debug PeekS(*mem)
  
  Password = DeCode(*mem, key, length)
  
  Debug Password
  
  FreeMemory(*mem) ;<-- nicht vergessen!
EndIf

Zum Speichern hab ich noch zwei Procedures dazugepackt, die ich aber
noch nicht getestet hab.

Verfasst: **07.09.2007 13:07**

Danke werde mir das ganze mal durchlesen ^^
Da hab ich auch mal einen Grund mich mit den *Pointer und Speicherzugriff zu befassen.

Aber nur ne Frage für das Verständnis: Das mit den *Pointer muss sein um die Binärdaten zu bekommen, damit man das mit dem Bit-Xor so umwurschteln kann ?
Sonst müsste man doch jeden Buchstabe auslesen und das manuell Zusammensetzen ?

Bye

Verfasst: **07.09.2007 13:23**

Für zeichenweise Stringoperationen durchzuführen sind Pointer einfach
schneller und, wie ich finde, einfacher zu handhaben.

Die Procedures sollten auch im Unicode-Modus funktionieren, weil dann
'SizeOf(Character)' nicht mehr 1, sondern 2 zurück gibt.

Asynchron bedeutet übrigens, dass zum Verschlüsseln eines Zeichens das
schon verschlüsselte Zeichen davor auch mit einbezogen wird. Es kann aber
auch sein, dass ich das gerade mit asymmetrisch verwechsle.

Verfasst: **08.09.2007 02:02**

NicTheQuick hat geschrieben:dann ist
100%-ige Sicherheit garantiert,

Bitte nicht übertreiben, das mag zwar ziemlich sicher sein,
aber 100% hat noch keine geschafft

Verfasst: **08.09.2007 20:19**

Es ist aber so. Wenn der Key so lange ist, wie der zu verschlüsselnde Text,
kannst du ohne Key alles herausinterpretieren. Du kannst irgendeinen Key
holen und kannst dann alles mögliche entschlüsseln.

Verfasst: **09.09.2007 19:36**

Wenn man dann noch ein Wörterbuch dazunimmt,
dann kann sogar ein einfaches Programm erraten,
welche davon die verschlüsselte Nachricht ist.

Verfasst: **10.09.2007 07:47**

Nein, da könnte jeder Satz herauskommen.

Verfasst: **10.09.2007 09:29**

Mein Schlüssel ist aber mit Sicherheit länger als das pw. Aber normalerweiße sollte es sowieso nur einen Key generieren, wenn Benutzer "abc" angemeldet ist bei "xyz" gibts nur einen key = "".
Und wenn jemand mit einem anderen Programm das Knacken will, muss er ja auch erstmal auf die Schlüssel Zusammenstellung kommen.

Naja jetzt widme ich mich noch der Verschlüsselung vom File...

---------------
Edit 1:
Decode Procedur ist aber nicht gerade flexibel oder ? Da man ja die Länge, die man eigentlich nicht weiß mit angeben muss... oO mal schaun, dass werd ich wahrscheinlich anders gestalten gefällt mir so irgendwie nicht.

Encode Procedur hat auch irgendwie ein Bug oder ?

test1212
test121212
test121212t
test1212t

werden z.b. alle gleich Verschlüsselt...
Debugger ausgabe:

test6565
DSXW
test6565t65
DSXW
test6565t65656565
DSXW
test6565t65656565abc
DSXW

Es wird sicherlich nicht vorkommen das jemand solche PWs verwendet aber trotzdem ist das doch irgendwo ein Fehler oder ?

-------------------
Edit2:

Hmmm.. also habe das in deinem Beispiel probiert da scheint das ja zu gehen.
Aber wenn ich bei mir das ganze mal mit Debugger ausgeben lasse, ist der String abgeschnitten, wenn c=0 bzw. *c3\c ist.

Code: Alles auswählen

  While *c1\c 
    If *c2\c = 0 : *c2 = @key : EndIf
    *c3\c = (*c1\c ! *c2\c) ! c 
    c = *c3\c
    
    *c1 + SizeOf(Character)
    *c2 + SizeOf(Character)
    *c3 + SizeOf(Character)
    Debug Str(*c3) + "    " + Str(c) + "         " + Chr(c)
  Wend

-----------------
Edit 3:

Ja nach langen probieren und testen und umschreiben und Debuggerausgaben, weiß ich zumind. das es daran liegt das es ein Zeilenumbruch gibt und das readINI dann nicht mehr richtig ließt zumind. vermute ich das. Da es ja sonst unlogisch ist...

irgendwie steh ich heut total auf den schlauch.. naja mal gucken was wird ^^

Edit 4:

So endlich hab ich es denke ich mal geschafft lol ich war wohl gestern zu verschlafen.
Egal habe jedenfalls das Zeichenproblem mit div. chr(10) und chr(13) etc. so umgangen das ich noch einen Base64Encoder() bzw. Decoder nach dem Verschlüsseln drumgebastelt habe.

Das erhöht sogar vielleicht sogar noch die Sicherheit der Verschlüsselung. Aber okay endlich mal fertig mit dem Senf

Danke nochmal für den Algorithmus...

Verfasst: **11.09.2007 18:11**

Hier nochmal extra für dich eine abgeänderte Version mit druckbaren
Zeichen:

Code: Alles auswählen

EnableExplicit

Procedure.s Encode(Password.s, key.s)
  Protected *c1.Character, *c2.Character, c.c, s.s
 
  *c1 = @Password
  *c2 = @key
  c = $FF
  While *c1\c
    If *c2\c = 0 : *c2 = @key : EndIf
    c = (*c1\c ! *c2\c) ! c
    
    s + Right("0" + Hex(c), 2)
    *c1 + SizeOf(Character)
    *c2 + SizeOf(Character)
  Wend
 
  ProcedureReturn s
EndProcedure

Procedure.s DeCode(code.s, key.s)
  Protected Password.s, *c1.Character, *c2.Character, c.c, a.l, c1.c
  
  *c1 = @code
  *c2 = @key
  c = $FF
  While *c1\c
    If *c2\c = 0 : *c2 = @key : EndIf
    
    If *c1\c <= '9' : c1 = *c1\c - '0' : Else : c1 = *c1\c - 'A' + 10 : EndIf
    c1 * 16
    *c1 + SizeOf(Character)
    If *c1\c <= '9' : c1 + *c1\c - '0' : Else : c1 + *c1\c - 'A' + 10 : EndIf
    
    Password + Chr(c1 ! *c2\c ! c)
    c = c1
    
    *c1 + SizeOf(Character)
    *c2 + SizeOf(Character)
  Wend
 
  ProcedureReturn Password
EndProcedure

Procedure WritePW(FileID.l, Password.s, key.s) ;Zum Speichern eines Passwortes in einer Datei
  Protected code.s
 
  code = Encode(Password, key)
 
  WriteLong(FileID, Len(code))
  WriteString(FileID, code)
 
  ProcedureReturn #True
EndProcedure
Procedure.s ReadPW(FileID.l, key.s) ;Zum Lesen eines Passwortes aus einer Datei
  Protected code.s, length.l, Password.s
 
  length = ReadLong(FileID)
  code = Space(length)
  ReadData(FileID, @code, length * SizeOf(Character))
 
  Password = DeCode(code, key)
 
  ProcedureReturn Password
EndProcedure

Define length.l, Password.s, key.s, code.s

Password = "Feel the Pure Power!"
key = "PureBoard"

code = Encode(Password, key)

Debug code
Debug DeCode(code, key)

Übrigens ist beim Verschlüsseln das wichtigste der Key. Den darf niemand
wissen. Der Algorhytmus darf bekannt sein. Meiner ist übrigens bekannt,
weil er einer der einfachsten und sichersten ist, solange 'Len(Key)' groß
genug gewählt wurde.
Jeder kann dein Programm durch den Disassembler schicken und sich die
Verschlüsselungsroutine anschauen. Aber erst wenn derjenige den Key
kennt, kann er alles entschlüsseln.
Die besten Verschlüsselungsalgorythmen sind bekannt und du findest
sicherlich auch Source dazu, aber für Sicherheit brauchst du auch einen
Key.

PureBoard

Verschlüsselung (Datei, PWs)

Verschlüsselung (Datei, PWs)