Earlier this week a colleague was asked to troubleshoot an issue where a user account kept getting locked out. So, we wanted to know from which device the faulty credentials were being used that were causing this (perhaps some crappy application which was using ‘old’ credentials? we didn’t knew…).

So, with the following PowerShell ‘oneliner’ you can quickly search through the eventlog of a domain controller for the event which describes the faulty logon attempt (or attempts):

Get-EventLog -ComputerName DC01 "Security" -InstanceID "4740" -Message *"USERNAME"*

This will give you a bunch of information per event it has found, so to filter it so it will only show the message and the time the event was generated:

Get-Eventlog -ComputerName DC01 "Security" -InstanceID "4740" -Message *"USERNAME"* | Format-List Timegenerated, Message

But perhaps you’ve got multiple domain controllers that you want to search through?

Get-Eventlog –ComputerName ([System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()).FindDomainController() "Security" -InstanceID "4740" -Message *"USERNAME"* | Format-List Timegenerated, Message

Every once in a while I need to get the domain name from a computer and use it in a PowerShell script. But when you do something like “Get-WMIObject –Class Win32_ComputerSystem | Select-Object –ExpandProperty Domain” you’ll get an output such as “jeffwouters.lan”.
But most of the times, a script will require an input like “DC=jeffwouters,DC=lan”

Now let’s say that we have a given variable:

$DomainName = “jeffwouters.lan”

By using the “split” method, you can split a string into separate values:

$DomainSplit = $DomainName.split(“.”)

This will give you a value “jeffwouters” and a value “lan” instead of the given value “jeffwouters.lan”.

Next, we would want to put something in front of the values, namely the “DC=” characters.
This can be done easily, just by creating a new variable with something like “DC=$(DomainSplit)”… but this will provide you with a nasty.
Why? Because there are multiple values in the variable (it has become an array ). The correct way to select the separate values is to add [0] or [1] after the variable where the number specifies the character.
Ow, and not to forget… between both values you will need to add a “,” since that’s the correct format for a distinguished name
So, to get the format you desire, the following command will do the trick:

$DomainName = “DC=$($DomainSplit[0]),DC=$($DomainSplit[1])”

This way, you’ve just converted “jeffwouters.lan” to “DC=jeffwouters,DC=lan”

Now, there is also a possibility that you have a child domain… something like “test.jeffwouters.lan”. You can convert this the same way as before, simply by adding another “DC=$($DomainSplit[2])”.
And to create a function out of this (since I like re-usable code…):

Function Convert-ToDistinguishedName()
{
<#
.Synopsis
Function to convert a domain name into a distinguished name format.

  .Description
Function to convert a domain name into a distinguished name format.
No default is used.

  .Example
Convert-ToDistinguishedName -DomainName “jeffwouters.lan”

  .Example
Convert-ToDistinguishedName -Name “jeffwouters.lan”

  .Notes
Author: Jeff Wouters | Methos IT
#>
param ( [Parameter(Position=0, Mandatory=$True)][ValidateNotNullOrEmpty()][Alias('Name')][String]$DomainName )
$DomainSplit = $DomainName.split(“.”)
if ($DomainSplit[2] -ne $null) {
$DomainName = “DC=$($DomainSplit[0]),DC=$($DomainSplit[1]),DC=$($DomainSplit[2])”
$DomainName
} else {
$DomainName = “DC=$($DomainSplit[0]),DC=$($DomainSplit[1])”
$DomainName
}
}

Now, this is a part of a larger deployment script I’m working on which I  will be posting parts of during the coming weeks.
After the script is finished, I’ll post it in the Microsoft Script Library and on this blog

Sometimes, when I demonstrate the ease and strength of PowerShell to a customer, I need to quickly generate some fake files en directory structure… also those files have to be from different sizes. For this, I’ve created the following script:

function New-DemoData ($Path)
{
  # Usage: New-DemoData “D:\Company”
  Push-Location
  1..10 | % { Set-Location -Path (New-Item -ItemType directory -path "$path\$_").fullname -ErrorAction SilentlyContinue
  for ( $i=1; $i -le (Get-Random -Minimum 10 -Maximum 200); $i++ )
    {
      fsutil file createnew ("File" + $i + ".txt") (Get-Random -Minimum 1024 -Maximum 819200)
    }
  }
  Pop-Location
}

This script will create 10 folders (named 1-10) at the target path (provided by the parameter) and create a random number of *.txt files (between 10 and 200) in each directory, each file between 1KB and 800KB in size.

This morning I received an email from a community peer stating that he was unable to manage Hyper-V 3.0 in Windows Server 2012 by using SCVMM 2012 CTP.
The specific error message: “Error (12704) : Unable to connect to the Hyper-V service on the server <server name>”

This is a known issue, but when you download/install/use the latest release of SCVMM 2012 (it’s RTM now as far as I know) the problem has been resolved

Note: Remember that CTP means Community Technology Preview… in other words: The product isn’t finished yet

Last week a community peer asked me on Facebook to assist him with a challenge.

His issue was that he had imported contacts into Active Directory by using a tool named “ldifde”. This tool also filled in the email address on the contact object in Active Directory.
But, he wanted to mail-enable them within Microsoft Exchange Server and set the mail address filled in the ‘Email address’ attached to the contact as the external mail address.
Since we’re talking about 2000+  contacts, this is not something you want to do by clicking… so we turned to PowerShell.

And here’s the PowerShell oneliner to do this.

Get-Contact -RecipientTypeDetails Contact -Filter ‘WindowsEmailAddress -ne $null’ | foreach { enable-mailcontact -Identity $_ -ExternalEmailAddress $_.WindowsEmailAddress.toS​tring() }

Note that this command will search through your entire AD… use the –OrganizationalUnit parameter to search more specific.
Now, this command took about 15 minutes to run… for about 2300 contacts. A lot better compared to clicking them manually, right?

Note: Getting an error stating that the “Get-Contact” cmdlet is unknown? Be sure that you’re a member of the “Exchange View-Only Administrators” group!

Yesterday I helped a fellow IT Pro out with an issue concerning Exchange and PowerShell.
Why user PowerShell? Well, in an Exchange 2010 SP2 Multi-tenant hosted environment there isn’t a management console
His goal was to use PowerShell to set full access rights for a group of users on a specific mailbox inside a multi-tenant environment.

When you look at the Add-MailboxPermissions cmdlet, you’ll see that there is a –User parameter. But when you would also expect a –Group parameter you will get a little disappointed; there isn’t any

All credits go toward the IT Pro I was helping, he found that instead of putting a username after the –User parameter, you can simple put a group name in there and it will work like a charm!

Add-MailboxPermission -Identity "user" -User "groupname" -AccessRights FullAccess -InheritanceType All

To me, this just doesn’t sound logical since a user is a user and not a group. So I’m hoping Microsoft will either change the name for the parameter or create a –Group parameter… but that’s for them to decide

Today I wrote a post with a Powershell function to create a complex password.
Although it does generate a complex password, it would not be enough for the complexity policy for passwords in Windows. This because the script didn’t check if there was a lowercase, uppercase, number and punctuation mark included.

Now, until now that script was sufficient for my customers because when you script a password you would not get prompted by a nasty error stating that the provided password does not meet the complexity requirements and stuff like that; it will just ram the password in your user object and be done with it.

Now, in the afternoon I received several comments (from Pete Zerger amongst others) about this limitation of my function, so (just to make the community peers happy) I re-wrote the function. And since I was at it, now a default length of 8 characters is used when no length is provided.

Function New-RandomComplexPassword ()
{
param ( [int]$Length = 8 )
#Usage: New-RandomComplexPassword 12
$Assembly = Add-Type -AssemblyName System.Web
$RandomComplexPassword = [System.Web.Security.Membership]::GeneratePassword($Length,2)
Write-Output $RandomComplexPassword
}

As you may have noticed, with this version I make use of a .NET assembly instead of native Powershell cmdlets. This is because using the .NET assembly makes the code a lot shorter and faster. Next to that, the script I started to write before I found this assembly was huge and way more complex than it needed to be.
For more information on the assembly I used, check the MSDN page.

This is part of one of my AD migration scripts which I find very useful.
Whenever creating a user, I like to generate a random and complex password. The length of the password differs for each of my customers, so that’s something I define with a parameter added to this function:

Function New-RandomPassword ($Length)
{
#Usage: New-RandomPassword 8
$Random = New-Object System.Random
$RandomPassword = (-join ([char[]](33..127) | Get-Random -Count $length))
Write-Output $RandomPassword
}

Note that this one is very basic, no check in there for when both a higher- and lower case character, number and/or punctuation mark is included. For most of my customers the function above is sufficient I Hope you find this one useful

Update: Changed the script based on feedback from Shay Levy through Twitter… thanks!

This year I was competing in the Windows PowerShell Scripting Games 2012.
One of the exercises in the Beginners class was to compare two folders.
Ed Wilson (Microsoft ScriptingGuy) provided a script to create two folders with a bunch of files in them and delete one file from each folder.

So, I started to script… by using the Compare-Object cmdlet. This lets you compare objects (sounds kinda logical when looking at the name of the cmdlet, right? ).

But, then there was the Expert Commentary… here the expert provided explanation of the exercise and the solution. The solution he provided was as follows:

$original = Get-Childitem -Path c:\1 | Sort-Object -Property Name
$copy = Get-Childitem -Path c:\2 | Sort-Object -Property Name
$difference = @(Compare-Object -ReferenceObject $original -DifferenceObject $copy -Property Name -PassThru)
if ($difference.Count -eq 0) {
Write-Host -ForegroundColor Green ‘Content is equal’
} else {
Write-Host -ForegroundColor Red ‘Content is different. Differences:’
$difference
}

Now, this is a easy and good solution
In short (by removing code that’s not required for the functionality of the script), this will become something like:

$original = Get-Childitem -Path c:\1 | Sort-Object -Property Name
$copy = Get-Childitem -Path c:\2 | Sort-Object -Property Name
$difference = @(Compare-Object -ReferenceObject $original -DifferenceObject $copy -Property Name -PassThru)

This differs from the solution I came up with since I’m a big fan of “one liners”
My solution:

Compare-Object –ReferenceObject (Get-ChildItem C:\1) –DifferenceObject (Get-ChildItem C:\2) –Passthru

Now, yesterday one of my students (in a PowerShell workshop I’m giving) came up with an even shorter solution (and I was thinking my solution was bad-ass ):

Compare-Object (Get-Childitem C:\1) (Get-ChildItem C:\2)

This is because Compare-Object automatically knows that if you provide the objects, the first is the ReferenceObject and the second will be the DifferenceObject… so even an easier way

Now this is the strength of PowerShell… it’s very easy, short, intelligent and understandable… but you can still make it as complex as you want

This is something I took from one of my larger deployment scripts and found it to be very useful and reusable.
Just to give you a use case: In my situation the parameter $NewComputerName is calculated based on the device type (server, laptop or desktop), the IP range and a random number taken from a text file located on a file share.

I hope you find it useful

Function Rename-Computer ($NewComputerName)
{
# Get the current credential.
$credential = Get-Credential

  # Get the current computer name
$OldComputerName = $Env:ComputerName

# Change the computer name.
Get-WmiObject Win32_ComputerSystem -ComputerName $OldComputerName -Authentication 6 | ForEach-Object {$_.Rename($NewComputerName,$credential.GetNetworkCredential().Password,$credential.Username)}

  # Reboot the computer to let the change take affect.
Shutdown.exe -r –t 7
}