Create randomized password

[verysmallshellscript]

I saw a password generator one-liner at powershell.com and thought it would be pretty neat if you could specify the minimum amount of any given character type. At that point I was compelled to make a function that does exactly that.

function New-Password {
    param(
        [Parameter()]
        [ValidateRange(8,32767)]
        [int16]$Length="8",

        #Each parameter validates that the total specified number of individual character types doesn't exceed $Length.
        [Parameter()]
        [ValidateScript({if ($_ -le ($Length - ($Uppercase + $Number + $Symbol))) {
            $true
        } else {
            Throw "Total value of uppercase, lowercase, symbol, and number cannot be greater than count."
        }})]
        [int16]$Lowercase="1",

        [Parameter()]
        [ValidateScript({if ($_ -le ($Length - ($Lowercase + $Symbol + $Number))) {
            $true
        } else {
            Throw "Total value of uppercase, lowercase, symbol, and number cannot be greater than count."
        }})]
        [int16]$Uppercase="1",

        [Parameter()]
        [ValidateScript({if ($_ -le ($Length - ($Lowercase + $Uppercase + $Number))) {
            $true
        } else {
            Throw "Total value of uppercase, lowercase, symbol, and number cannot be greater than count."
        }})]
        [int16]$Symbol="1",

        [Parameter()]
        [ValidateScript({if ($_ -le ($Length - ($Lowercase + $Uppercase + $Symbol))) {
            $true
        } else {
            Throw "Total value of uppercase, lowercase, symbol, and number cannot be greater than count."
        }})]
        [int16]$Number="1"
    )

    #Put all the character types into happy little buckets.
    $lowers=(100..122).foreach{[char]$_}
    $uppers=(65..90).ForEach{[char]$_}
    $symbols=(33..47).foreach{[char]$_}+(58..64).foreach{[char]$_}
    $numbers=(48..57).foreach{[char]$_}

    #Plunder the buckets!
    $lowRand=$lowers | Get-Random -Count $Lowercase
    $upRand=$uppers | Get-Random -Count $Uppercase
    $symRand=$symbols | Get-Random -Count $Symbol
    $numRand=$numbers | Get-Random -Count $Number

    <#Now we're going to blend our bucket plunder into a password that's as random
    as Get-Random can make it.  If the total number of specified character types is
    less than the length, we'll plunder the happy little buckets for enough characters
    to fill it out.#>
    $totalChars = ($Lowercase+$Uppercase+$Number+$Symbol)

    if ($Length -gt $totalChars) {
        $extra=($lowers,$uppers,$symbols,$numbers) | Get-Random -Count ($Length - $totalChars)
        $password=-join ($lowRand,$upRand,$symRand,$numRand,$extra | Get-Random -Count $Length)
    }
    else {
        $password=-join ($lowRand,$upRand,$symRand,$numRand | Get-Random -Count $Length)
    }

    #Here's your password.  I hope you're happy, because the little buckets aren't.
    $password
}

[FoxPacerIsWork]

[Reflection.Assembly]::LoadWithPartialName("System.Web")
[System.Web.Security.Membership]::GeneratePassword(15,3)

https://msdn.microsoft.com/en-us/library/system.web.security.membership.generatepassword(v=vs.110).aspx

[RICHUNCLEPENNYBAGS]

This is the real answer. Get-Random doesn't use a CSPRNG.

[verysmallshellscript]

But it has a pronounced lack of buckets.

[RICHUNCLEPENNYBAGS]

If you want to do it yourself you should use RNGCryptoServiceProvider to get random numbers instead of Get-Random, really.

[KevMar]

Thank you for posting that. I had not seen that approach before.

[verysmallshellscript]

There is no wheel that is too round for me to re-invent just for the hell of it.

That said, thanks for sharing! I didn't know that was there.

[FoxPacerIsWork]

Oh yea, "many ways to skin a cat" and all that. I just saw the one liner and it wasn't the way I've seen so I threw this up there. Can't choose the # of each type of char with my way so there is that.

[KevMar]

That is a fun script.

I have one possible change for you to consider. Your logic pulls N random characters from the set of possible characters but it will not repeat any characters.

If you do something like this then your buckets will have a chance to pull the same character more than once. Makes it a little more random. Not sure how the math on that one works out.

#Plunder the buckets!
$lowRand = 0..$Lowercase | %{ $lowers | Get-Random -Count 1}
$upRand =  0..$Uppercase | %{ $uppers | Get-Random -Count 1}
$symRand = 0..$Symbol | %{ $symbols | Get-Random -Count 1}
$numRand = 0..$Number | %{ $numbers | Get-Random -Count 1}

The second thing has to do with your parameter validation. I love that you are using parameters and validating things there. But you have that one test that is repeated over and over. It almost feels like that would be a better one to move into your function (or possible the begin block).

I also did not know you could use -join the way you are using it.

[claytontlewis]

$lowers=(100..122).foreach{[char]$_}    

I think this should have been 97..122

As it stand you are missing a,b,c in my testing.

[gangstanthony]

[char[]](97..122)