Ich habe mir einen einfachen Passwortgenerator mit PowerShell gebastelt. Gut, einfach nur ein Passwort generieren mit Get-Random ist relativ einfach. Doch ich wollte noch ein wenig mehr. Ich möchte bestimmen wie groß der Anteil (prozentual) von Großbuchstaben, Kleinbuchstaben, Nummern sowie Sonderzeichen ist. Soweit zur Idee.
Was habe ich im Script genutzt
Für dieses Script habe ich mehrere bereits beschriebene Elemente genutzt. Der Generator basiert auf der Funktion Get-Random, welche ich im Artikel PowerShell – 02 – Random beschrieben habe. Selbst einen Zufallsalgorithmus zu entwickeln ist hoch komplex und erfordert ebenfalls etwas mehr Zeit. Im Script setze mehrfach Get-Random ein um die zufällige Erstellung des Passwortes zu maximieren. Weiterhin habe ich die Switch- oder auch Case-Schleife verwendet. Diese habe ich im Artikel PowerShell – 11.1 – Logfiles mit einer Function erstellen näher beschrieben. Hier prüfe ich allerdings keine Worte/Zeichen sondern numerische Werte. Weiterhin lasse ich die benötigte Zeit ermitteln welche zur Erstellung des Passwortes benötigt wird. Dies kann entweder mit Measure-Command (PowerShell – Scriptdauer messen Teil 2) oder mit einer selbstgeschrieben Variante (PowerShell – Scriptdauer messen Teil 1) gemessen werden. Ich habe mich im Script für meine selbst erstellte Variante entschieden. Zu guter Letzt nutzet ich die Funktion Runden (Round) aus der Mathematikbibliothek (Math).
Input des Scriptes
Im Script müssen mehrere Variablen angeben werden. Diese habe ich in der folgenden Tabelle näher beschrieben.
| Name | Typ | Beschreibung |
| $PWDLength | Int32 | Diese Variable legt die Länge des Passwortes fest. Definiert ist sie als Int32 damit auch besonders lange Passwörter möglich sind (bis zu 2.147.483.647 Zeichen). |
| $AmountABC_percent | Int | Diese Variable legt den prozentualen Wert der Großbuchstaben (A-Z) fest. Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf. |
| $AmountABCsm_percent | Int | Diese Variable legt den prozentualen Wert der Kleinbuchstaben fest (a-z). Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf. |
| $AmountNR_percent | Int | Diese Variable legt den prozentualen Wert der Ziffern(0-9) fest. Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf. |
| $AmountSign_percent | Int | Diese Variable legt den prozentualen Wert der Sonderzeichen ($,!,%,^) fest. Dieser Wert kann von 0 bis 100 gesetzt werden. Wobei Gesamtsummer aller $Amount* Variablen nicht über 100 sein darf. |
| $AllAmounts_percent | Int |
Diese Variable fast alle $Amount* Variablen zusammen. Anschließend wird geprüft, ob diese größer gleich 100 ist. Ist sie größer als 100 wird ein Fehler ausgegeben mit dem Hinweis das die Werte angepasst werden müssen. Ist diese Variable kleiner 100 wird der Wert von $AmountABC_percent solange um jeweils 1 erhöht bis der Wert von $AllAmounts_percent 100 entspricht. |
Funktionsweise des Scriptes
Nachdem die oben genannten Werte angeben sind geht es im Script wie folgt weiter. Es wird zu erst geprüft, ob die Variable $AllAmounts_percent kleiner 100 ist. Trifft dies zu, wird der Wert der Variable $AmountABC_percent (Anzahl Großbuchstaben) jeweils um eins erhöht bis $AllAmounts_percent gleich 100 ist. Übersteigt $AllAmounts_percent jedoch den Wert 100 bricht das Script mit der Fehlermeldung „Prozentuale Werte sind über 100%!“ ab. Ausgelöst durch break.
Im nächsten Schritt werden vier Arrays ($Chars_*) initiiert für Groß- und Kleinbuchstaben, Ziffern sowie für Sonderzeichen. Diese können beliebig erweitert werden.
|
1 2 3 4 |
$Chars_ABC =@("A","B","C","D","E","F","G","H","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z") $Chars_ABCsm = @("a","b","c","d","e","f","g","h","i","j","k","m","n","o","p","q","r","s","t","u","v","w","x","y","z") $Chars_Nr = @("1","2","3","4","5","6","7","8","9") $Chars_sign = @("$","!","%","^") |
Nun wird eine als String deklarierte Variable $UserPassword angelegt. Die Variable wird im folgenden Switch-Statement verwendet. Dazu muss sie vorher bereits existieren. Inhalt der Variable ist am Ende das generierte Passwort.
|
1 |
[String]$UserPassword="" |
Es werden zwei weitere Arrays gebildet, $AllAmounts_array und $AllAmountsArray. Das Array $AllAmounts_array enthält alle vier Werte der $Amount* Variablen. $AllAmountsArray wird zunächst nur initiiert. Dieses wird für die folgende For-Schleife benötigt.
|
1 2 |
$AllAmounts_array =@($AmountABC_percent,$AmountABCsm_percent,$AmountNR_percent,$AmountSign_percent) $AllAmountsArray = @() |
In der folgenden For-Schleife kommt die Round Funktion der Math Bibliothek zum Einsatz. Hier breche ich die angegebenen prozentualen Werte auf Ganzahlen (integer) herunter. Dazu nehme ich die Länge des Passwortes geteilt durch 100. Das Ergebnis wird anschließend mit dem Wert von $AllAmounts_array[$i] multipliziert. $i entspricht jeweils dem Wert von $AmountABC_percent, $AmountABCsm_percent, $AmountNR_percent oder $AmountSign_percent.
|
1 2 3 4 5 |
for($i=0;$i -lt $AllAmounts_array.Count;$i++) { $Percentage = [math]::Round($PWDLength/100*$AllAmounts_array[$i]) $AllAmountsArray += $Percentage } |
Die gesamt ermittelten Werte von $AllAmountsArray werden auf die entsprechenden $Amount*_numeric Variablen verteilt. Es kann sein das die Gesamtsumme nicht 100 erreicht. Dies kommt durch das Runden der Prozentangaben.
|
1 2 3 4 5 |
$AmountABC_numeric = $AllAmountsArray[0] $AmountABCsm_numeric = $AllAmountsArray[1] $AmountNR_numeric = $AllAmountsArray[2] $AmountSign_numeric = $AllAmountsArray[3] [int32]$AllAmounts = $AmountABC_numeric+$AmountABCsm_numeric+$AmountNR_numeric+$AmountSign_numeric |
In der folgenden If-Schleife wir der Wert von $AllAmounts geprüft. Ist dieser nicht 100 wird auch hier wieder der Anteil von Großbuchstaben ($AmountABC_numeric) erhöht. Somit ist gewehrleistet, das die Passwortlänge in jedem Fall erreicht wird.
|
1 2 3 4 5 6 |
If ($AllAmounts -ne $PWDLength) { $difference = $PWDLength - $AllAmounts $AmountABC_numeric += $difference [int32]$AllAmounts = $AmountABC_numeric+$AmountABCsm_numeric+$AmountNR_numeric+$AmountSign_numeric } |
Nach diesen ganzem Vorgeplänkel kommt nun der eigentliche und spannende Teil, das Zusammenstellen des Passwortes. In der Do-While-Schleife wird erst eine Wert zwischen 0 und 3 mittels Get-Random ausgewürfelt (Daran denken, dass Null auch eine Zahl ist). Die „zufällig“ generiete Zahl spring dran in einen der vier Cases. Diese habe ich in der Tabelle kurz beschrieben.
| Case | Was passiert |
| 0 | Es wird ein Großbuchstabe dem Passwort ($UserPassword) hinzugefügt |
| 1 | Es wird ein Kleinbuchstabe dem Passwort ($UserPassword) hinzugefügt |
| 2 | Es wird eine Ziffer dem Passwort ($UserPassword) hinzugefügt |
| 3 | Es wird ein Sonderzeichen dem Passwort ($UserPassword) hinzugefügt |
Was passiert nun genau in diesem Case? In Case 0 wird geprüft, ob der Wert von $AmountABC_numeric gleich null ist. Ist der Wert der Variable nicht null wird dieser innerhalb der If-Bedingung um eins verringert und die Variable $UserPassword wird um ein Zeichen erweitert. Hierzu wird ein Wert des Array $Chars_ABC mittels Get-Random ausgewählt. Das Maximum bei Get-Random habe ich mit $Chars_ABC.Count festgelegt. So beleibt das Script dynamisch, da z.B. das Array $Chars_Sign um weitere Sonderzeichen erweitert werden kann. Die Do-While-Schleife wird solange ausgeführt bis die Länge von $UserPassword mit der gewünschten Länge ($PWDLength) übereinstimmt. Tritt dieser Fall ein, sind alle $Amount*_numeric Variablen gleich null. Der ganze Vorgang ist analog für die anderen Cases 1-3 zu betrachten.
Hinweis zu Get-Random:
Bei Get-Random muss das Minimum nicht zwingend angegeben werden, wenn es Null ist/ sein soll. Dennoch habe ich es bei den anderen Get-Randoms angegeben. Dies wäre aber nicht nötig.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
do{ Switch (Get-Random -Maximum 4) { 0{ If($AmountABC_numeric -ne 0) { $AmountABC_numeric-- $UserPassword += $Chars_ABC[$(Get-Random -Minimum 0 -Maximum $Chars_ABC.Count)] } } 1{ If($AmountABCsm_numeric -ne 0) { $AmountABCsm_numeric-- $UserPassword += $Chars_ABCsm[$(Get-Random -Minimum 0 -Maximum $Chars_ABCsm.Count)] } } 2{ If($AmountNR_numeric -ne 0) { $AmountNR_numeric-- $UserPassword += $Chars_Nr[$(Get-Random -Minimum 0 -Maximum $Chars_Nr.Count)] } } 3{ If($AmountSign_numeric -ne 0) { $AmountSign_numeric-- $UserPassword += $Chars_sign[$(Get-Random -Minimum 0 -Maximum $Chars_sign.Count)] } } } }while(!($UserPassword.Length -eq $PWDLength)) |
Anschließend folgt nur noch der Output. Hier wird zu erst das Passwort angezeigt, gefolgt von der Länge des Passwortes. Darunter wird noch die benötigte Zeit angeben die das Script gebraucht hat. Fertig 🙂
|
1 2 3 4 5 6 7 8 9 10 |
Write-Host "Passwort:"-BackgroundColor Magenta $UserPassword Write-Host "Passwortlänge:"-BackgroundColor Magenta $UserPassword.Length # Benötigte Zeit $endtime = date $time = $endtime - $startime Write-Host "Benötigte Zeit zur Erstellung:"-BackgroundColor Magenta Write-Host "$($time.Hours)h:$($time.Minutes)m:$($time.Seconds)s:$($time.Milliseconds)ms" -BackgroundColor Magenta |
Weitere Features
Das Script werde ich noch als Funktion umschreiben damit die Angabe der Werte einfacher von der Hand gehen. Zudem möchte ich das Script mit einer GUI verstehen und als umgewandelte ausführbare Datei (EXE) erstellen. Sodass ein einfache Starten als Tool möglich ist. Diesen Vorgang werde ich natürlich auch hier wieder detailliert beschreiben.
Eines der größeren Schritte soll dann die Aufnahme in ein selbst erstelltes Modul werden. Das Modul soll dann mehrere praktische Scripte enthalten und stets erweitert werden. Hierzu werde ich dann eine eigene Reihe von Artikeln auf meinem Blog verfassen.
Das komplette Script
Hier nun das Script in seiner vollen Länge mit Header und Versionsverwaltung. Beispielausgaben des Scriptes stehen darunter.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
<# Name Simple Password Generator Beschreibung Erzeugt ein beliebig langes Passwort aus vorgegebenen Zeichen. $PWDLength ist die Passwortlänge. Es kann der Prozentuale Anteil der 4 Zeichen-Bereiche gewählt werden. Dieser darf gesamt nicht über 100 kommen. Liegt er unterhalb von 100 wird der Wert vom Array $AmountABC_percent solange erhöht bis er 100 erreicht. Version, Datum, Beschreibung, Autor 1.0 | 22.07.2014 | Initiale Version | Stefan Rehwald 1.1 | 27.10.2015 | Prozentproblem bereinigt | Stefan Rehwald #> $startime = date [int32]$PWDLength = 10 $AmountABC_percent = 30 $AmountABCsm_percent = 20 $AmountNR_percent = 28 $AmountSign_percent = 22 $AllAmounts_percent = $AmountABC_percent + $AmountABCsm_percent + $AmountNR_percent + $AmountSign_percent If($AllAmounts_percent -lt 100) { do { $AmountABC_percent++ $AllAmounts_percent = $AmountABC_percent + $AmountABCsm_percent + $AmountNR_percent + $AmountSign_percent } while($AllAmounts_percent -ne 100) } elseif($AllAmounts_percent -gt 100) { Write-Host "Prozentuale Werte sind über 100%!" -ForegroundColor Red break } $Chars_ABC =@("A","B","C","D","E","F","G","H","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z") $Chars_ABCsm = @("a","b","c","d","e","f","g","h","i","j","k","m","n","o","p","q","r","s","t","u","v","w","x","y","z") $Chars_Nr = @("1","2","3","4","5","6","7","8","9") $Chars_sign = @("$","!","%","^") [String]$UserPassword="" $AllAmounts_array =@($AmountABC_percent,$AmountABCsm_percent,$AmountNR_percent,$AmountSign_percent) $AllAmountsArray = @() for($i=0;$i -lt $AllAmounts_array.Count;$i++) { $Percentage = [math]::Round($PWDLength/100*$AllAmounts_array[$i]) $AllAmountsArray += $Percentage } $AmountABC_numeric = $AllAmountsArray[0] $AmountABCsm_numeric = $AllAmountsArray[1] $AmountNR_numeric = $AllAmountsArray[2] $AmountSign_numeric = $AllAmountsArray[3] [int32]$AllAmounts = $AmountABC_numeric+$AmountABCsm_numeric+$AmountNR_numeric+$AmountSign_numeric If ($AllAmounts -ne $PWDLength) { $difference = $PWDLength - $AllAmounts $AmountABC_numeric += $difference [int32]$AllAmounts = $AmountABC_numeric+$AmountABCsm_numeric+$AmountNR_numeric+$AmountSign_numeric } do{ Switch (Get-Random -Maximum 4) { 0{ If($AmountABC_numeric -ne 0) { $AmountABC_numeric-- $UserPassword += $Chars_ABC[$(Get-Random -Minimum 0 -Maximum $Chars_ABC.Count)] } } 1{ If($AmountABCsm_numeric -ne 0) { $AmountABCsm_numeric-- $UserPassword += $Chars_ABCsm[$(Get-Random -Minimum 0 -Maximum $Chars_ABCsm.Count)] } } 2{ If($AmountNR_numeric -ne 0) { $AmountNR_numeric-- $UserPassword += $Chars_Nr[$(Get-Random -Minimum 0 -Maximum $Chars_Nr.Count)] } } 3{ If($AmountSign_numeric -ne 0) { $AmountSign_numeric-- $UserPassword += $Chars_sign[$(Get-Random -Minimum 0 -Maximum $Chars_sign.Count)] } } } }while(!($UserPassword.Length -eq $PWDLength)) # Output Write-Host "Passwort:"-BackgroundColor Magenta $UserPassword Write-Host "Passwortlänge:"-BackgroundColor Magenta $UserPassword.Length # Benötigte Zeit $endtime = date $time = $endtime - $startime Write-Host "Benötigte Zeit zur Erstellung:"-BackgroundColor Magenta Write-Host "$($time.Hours)h:$($time.Minutes)m:$($time.Seconds)s:$($time.Milliseconds)ms" -BackgroundColor Magenta |
Ausgabe des Script
Mit steigender Länge des Passwortes benötigt das Script entsprechend mehr Zeit. Das Script lässt sich garantiert noch etwas performanter gestalten, aber ich denke für ein Passwort mit 100 Stellen sind 75 ms ganz in Ordnung.Aus optischen Gründen habe ich die Passwörter in der Ausgabe als String in Kochkommas gestellt. Dieser werden in der normalen Ausgabe nicht angezeigt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
# $PWDLength = 20 # $AmountABC_percent = 30 # $AmountABCsm_percent = 20 # $AmountNR_percent = 28 # $AmountSign_percent = 22 #Ausgabe #Passwort: "^V^%SY$tqYikE739G732" #Passwortlänge: 20 #Benötigte Zeit zur Erstellung: 0h:0m:0s:44ms <# ================================== #> # $PWDLength = 100 #Ausgabe #Passwort: "yf8p5B12fe^$^Zker$X^61u!2WirCu5HA1MLM2V$Rgp$eX2AkFUdR923G1W!r1g$Q6%!fS^P7MX49G862%39345SFB!EE$$^^^!!" #Passwortlänge: 100 #Benötigte Zeit zur Erstellung: 0h:0m:0s:75ms <# ================================== #> # $PWDLength = 1.000 #Ausgabe #Passwort: "^d$7^x9uoSrPnxK%qPQ4Gk%HL7b$^!64^z^%^bq^a%$i92!58bCd9%8!Y%$7dzp%Y5S!7^t^JXb4S8!$GrfKRCUtj^9ACkYd^$c9S^%LWm91Lg%eZh!h^8MP^Fz8u^3Nq1x8f6t%xz13k$o6$p$Zk$x6!8$!!9!y9$g341M%!BW^B6eAW5Kr2L9JbNG%Z!1%o!!nQv!g!LN^^dzQoZ%16n$^7eKw2yGEtghf^%L^%s99EuqKeE74da92Q%!5MC%$! ZtFBn6de7515E4vCF%!u7B%B8F5$z965n1Tbw^%5N%$pwu!YS!B^y^9Tf$^3Y4qw$2$y9xTL%pyENck81Mx!1v7G$6tv!H43nz6W^!j3dE^92863eff3T!^m^NHn!o!En!!$1BF^$^2D8b^v6!$r^$Jsm8g2v2WR!kp%3%a!o5kjWC413w$v1Dy!$5Ti$j7H8^1mW$gCTL1^$^1w^4^82j$RGu76^NR$1k6CL55UH!5eyz$1i^%!G$$!!8!b2VEv% H3JjK3DAP9X%P2XZfP6enzi$2SW2zL!HtZNnor9w5b!!8T8cy6a$%py42!$1%gp%Krs62F!SWJ$Eo%6$8a9^3%!Q6Mp2DV^^z1$H$7oddA5$g!2^wx1%73^%$u9wP%R6XkKmry!Mf6$L62FxYZ559zjUhYB^8%4Dp^f^1^!E9^!$Dq9!382djAYK%^3W8$!UtN24q6V$^^^4VRgBK37%%y%9%a3!WtBEnvQfC!76E8$84vc923V!B!3%!EZ239!WG ^B21573G6ZBH3AQ!A$YL44^%L$G4%JT^636^$KL^44N775V$M35!934$!48H!6KK^22!FSB48$6R965BJ1632Y2JDE51ZD4BW942EMLG1KKP938981KSJ95V56X63542QP9WX81ZU8BDKR9R5R41UW8RT92CV4517849885ER659WXGV4739CMBX3W1SXW9YRC9QHSUXDPQRQXYAFRQXBVMHHBAPTUJKPQJDM" #Passwortlänge: 1000 #Benötigte Zeit zur Erstellung: 0h:0m:0s:300ms <# ================================== #> # $PWDLength = 10.000 #Ausgabe #Passwort: # Aus Platzgründen weggelassen. #Passwortlänge: 1000 #Benötigte Zeit zur Erstellung: 0h:0m:0s:300ms <# ================================== #> # $PWDLength = 100.000 #Ausgabe #Passwort: # Aus Platzgründen weggelassen. #Passwortlänge: 100000 Benötigte Zeit zur Erstellung: 0h:0m:38s:725ms |
Viele Grüße
rewe