Passwörter generieren

[BlackFish]

Ein kleines Beispiel, dass zeigt, wie man mit PB verschiedene Arten von Passwörtern erzeugen kann:

Code: Alles auswählen

;================================================================================================================================
;SUBJECT: A small snippet to generate different types of passwords
;AUTHOR:  codeprof aka BlackFish
;LICENSE: PUBLIC DOMAIN (can be used without any restriction)
;         This software is provided 'as-is', without any express or implied warranty.
;         In the author cannot be held liable for any damages arising from the use of this software.
;         Use this software at your own risk. 
;DATE:    2013-03-10
;================================================================================================================================
Procedure.s GenerateReadablePassword(length.i = 6)
  Protected i, password.s = "" 
  Protected vocs.s = "aeiou"
  Protected cons.s = "bcdfghjklmnpqrstvwxyz"
  If OpenCryptRandom() 
  For i = 0 To length-1
    If i & 1
      password.s + Mid(vocs, CryptRandom(Len(vocs) - 1) + 1, 1)
    Else
      password.s + Mid(cons, CryptRandom(Len(cons) - 1) + 1, 1)       
    EndIf 
  Next
   CloseCryptRandom() 
  EndIf 
  ProcedureReturn password
EndProcedure

Procedure.s GenerateRandomPassword(length.i = 30, allowedChars.s = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$&§!?%*+-_")
  Protected i, password.s = ""
  If OpenCryptRandom()
    For i = 0 To length - 1
      password.s + Mid(allowedChars, CryptRandom(Len(allowedChars) - 1) + 1, 1)
    Next
    CloseCryptRandom()
  EndIf
  ProcedureReturn password
EndProcedure  

Procedure.s GeneratePassphrasePassword(length.i = 25, allowedSpecialChars.s = "$&§!?%*+-_")
  Protected password.s = ""  
  While (Len(password) < length)
    password + GenerateReadablePassword(4) + " " 
    password + GenerateRandomPassword(4, "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + allowedSpecialChars) + " "  
  Wend  
  
  password = Trim(Left(password, length))
  allowedSpecialChars = ReplaceString(allowedSpecialChars, " ", "")
  password + GenerateRandomPassword(length - Len(password), "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + allowedSpecialChars)
  ProcedureReturn password
EndProcedure  


For t=0 To 24
  Debug GenerateReadablePassword()
Next

For t=0 To 24
  Debug GenerateRandomPassword()
Next

For t = 0 To 24
  Debug GeneratePassphrasePassword()
Next 

/edit: kleine Verbesserung bzgl. Var. Deklaration. Danke an ts-soft

[cxAlex]

Gefällt mir, nur könntest du zur Verbesserung noch das ganze auf 1. Procedure beschränken und die verschiedenen Zeichen-Sets per Macro definieren, so sparst du dir viele Code Redundanzen. Nebenbei fängst du dir bei GenerateReadablePassword() eine kryptographische Schwachstelle ein (abgesehen davon das 6 eine zu kurze Länge ist, bitte mindestens 8 und verwende auch Zahlen dazu, gleich viel besser).

Bei deiner Generierung ist jeder 2. Buchstabe ein Vokal und jeder 2. ein Konsonant. Das stärkt das Passwort aber nicht sondern schwächt es. Ist dieses Schema bekannt sinkt die Chance das Passwort zu "erraten"/"brute-forcen" bei jedem Versuch von (1/26)^6 auf (1/21 * 1/5) ^ 3 also von ~ 0.04% auf ~0.3%.

Gruß, Alex

[BlackFish]

@cxAlex
Danke für dein Feedback.
Ja da hast du recht, aber GenerateReadablePassword() hab ich programmiert um ein möglichst lesbares Passwort zu generieren. Durch eine größere Länge, Großbuchstaben, Zahlen... wird es schlechter lesbar. Dafür gibt es dann ja GenerateRandomPassword()

[cxAlex]

@cxAlex
Danke für dein Feedback.
Ja da hast du recht, aber GenerateReadablePassword() hab ich programmiert um ein möglichst lesbares Passwort zu generieren. Durch eine größere Länge, Großbuchstaben, Zahlen... wird es schlechter lesbar. Dafür gibt es dann ja GenerateRandomPassword()

Ja, ok aber du könntest doch zumindest das Vokal - Konsonant Abwechseln ausbauen und jeden Buchstaben an jeder Stelle zulassen? Das würde schonmal die Passwort - Stärke erhöhen und die Lesbarkeit nicht beeinflussen?

Gruß, Alex

[ts-soft]

Wäre nett, wenn Du noch die 2 variablen in GenerateReadablePassword deklarieren würdest, damit es
auch mit EnableExplicit klappt.

Code: Alles auswählen

Procedure.s GenerateReadablePassword(length.i = 6)
  Protected i, password.s = "" 
  Protected vocs.s = "aeiou"
  Protected cons.s = "bcdfghjklmnpqrstvwxyz"
  If OpenCryptRandom() 
  For i = 0 To length-1
    If i & 1
      password.s + Mid(vocs, CryptRandom(Len(vocs) - 1) + 1, 1)
    Else
      password.s + Mid(cons, CryptRandom(Len(cons) - 1) + 1, 1)       
    EndIf 
  Next
   CloseCryptRandom() 
  EndIf 
  ProcedureReturn password
EndProcedure

Gruß
Thomas

/edit
und im anderem Beitrag ist val.q auch nicht deklariert, danke
http://www.purebasic.fr/german/viewtopi ... 72#p309972

[NicTheQuick]

Ich würde vor allem eher eine Bit-Angabe machen und nicht eine Längenangabe. So kann man im Voraus bestimmen wie viele Zufallsbits das Passwort enthalten soll.

Code: Alles auswählen

EnableExplicit

Procedure.s GenerateReadablePassword(bits.i = 128)
	If (bits > 1021)
		bits = 1021
	EndIf
	Static vocs.s = "aeiou"
	Static cons.s = "bcdfghjklmnpqrstvwxyz"
	
	Protected i.i, password.s = ""
	Protected invPossibility.d = 1.0
	
	If OpenCryptRandom()
		While bits > (Log(invPossibility) / Log(2))
			If i & 1
				password.s + Mid(vocs, CryptRandom(Len(vocs) - 1) + 1, 1)
				invPossibility * Len(vocs)
			Else
				password.s + Mid(cons, CryptRandom(Len(cons) - 1) + 1, 1)      
				invPossibility * Len(cons)
			EndIf
			;Debug password + " (Bits: " + StrD((Log(invPossibility) / Log(2)), 10) + ")"
			i + 1
		Wend
		CloseCryptRandom() 
	EndIf 
	ProcedureReturn password
EndProcedure

Update: Ich habe es mal mit der inversen Wahrscheinlichkeit gemacht. Das macht zwar keinen Unterschied, aber egal. Besonders genau wird die Funktion aber trotzdem nicht sein, da Doubles nun mal insgesamt nur aus 64 Bit bestehen. Und deshalb kann es passieren, dass bei Passwörtern oberhalb der 64 Bit mal ein Buchstabe mehr oder weniger ausgegeben wird als es sein sollte.

Update 2: Ich habe noch eine Begrenzung eingebaut. Ab 1022 Bits gibt es eine Endlosschleife, weil die Doubles dann nicht mehr ausreichen.

[BlackFish]

@cxAlex
Die abwechselnden Vokale und Konsonanten sollen das Wort ausspechbar machen und damit ist es (hoffentlich) besser merkbar. ( wird in einem Algoritmus von der NIST vorgeschlagen siehe http://www.marchansen.com/tn108/)

@NicTheQuick
Interresanter Vorschalg

[WPö]

Moin, Alex!

... Ist dieses Schema bekannt sinkt die Chance das Passwort zu "erraten"/"brute-forcen" bei jedem Versuch von (1/26)^6 auf (1/21 * 1/5) ^ 3 also von ~ 0.04% auf ~0.3%.

??? Kann ich nix verstehen.
(1/26)^6 ergibt 3,237e-9.
(1/21 * 1/5)^3 ergibt 455,2e-9, was das 140fache ist.
Die Chance, das Paßwort zu erraten, steigt also. Das haben bereits andere Kommentatoren festgehalten.

Gruß - WPö

[cxAlex]

(1/26)^6 ergibt 3,237e-9.
(1/21 * 1/5)^3 ergibt 455,2e-9, was das 140fache ist.
Die Chance, das Paßwort zu erraten, steigt also. Das haben bereits andere Kommentatoren festgehalten.

(1/21 * 1/5)^3 ergibt 8,64e-7 .... (http://bit.ly/13Q5Do9)

Die Chance das Passwort zu erraten steigt, hab ich doch gesagt? Die Abwechselnde Konsonanten/Vokale Version ist unsicherer, habe nichts anderes behauptet?

Gruß, Alex

[WPö]

Ups - im Wert vertan. Du hast Recht. Ist ja wurscht - wir wissen, was gemeint ist.