Power Tips

PowerShell 7 comes with a new ForEach-Object that supports parallel execution:

1..100 | ForEach-Object -ThrottleLimit 20 -Parallel { Start-Sleep -Seconds 1; $_ }

If you use Windows PowerShell, you can use the same parallelization techniques. For example, download and install this free module:

Install-Module -Name PSParallel -Scope CurrentUser -Force 

It comes with a single command: Invoke-Parallel. You would use it…

PowerShell 7 comes with a built-in parameter to run different tasks in parallel. Here is a simple example:

1..100 | ForEach-Object -ThrottleLimit 20 -Parallel { Start-Sleep -Seconds 1; $_ }

In a normal ForEach-Object loop, this would take 100 seconds to execute. Thanks to -parallel, the code is executed in parallel. -ThrottleLimit defines the “chunks”, so in this example, there are 20 threads running in parallel, reducing…

Here is a somewhat unknown parameter: -RepeatHeader! What does it do?

Let’s assume you want to see results page by page (which only works in a console, not the PowerShell ISE):

 
PS> Get-Process | Out-Host -Paging 
 

The output now is paused per page until you press SPACE. However, the column headers are displayed only on the first page.

A better output can be produced like this:

 
PS> Get-Process | Format…

With PowerShell 7, the language gets a new operator that created a lot of debate. Basically, you don’t have to use it, but users with a developer background will welcome it.

Until now, to create a condition you’d always have to write a whole lot of code. For example, to find out whether your script runs in a 32-bit or 64-bit environment, you could query the length of a pointer like this:

[IntPtr]::Size -e…

In PowerShell 5, a new cmdlet called Get-ComputerInfo was introduced which does what systeminfo.exe did in the past, yet Get-ComputerInfo is object-oriented right away. There are no localization issues:

$infos = Get-ComputerInfo

You can now query individual details about your computer:

$infos.OsInstallDate
$infos.OsFreePhysicalMemory
$infos.BiosBIOSVersion

Or use Select-Object to select all properties that interest…

For a long time, the command-line utility systeminfo.exe provides a wealth of information about a computer and can return object-oriented results with a little trick:

$objects = systeminfo.exe /FO CSV |
  ConvertFrom-Csv

$objects.'Available Physical Memory'

On the pros side, systeminfo.exe is available on almost all Windows systems. On the cons side, the results are localized which can be a problem with the…

In this mini-series, we are looking at the differences between Get-WmiObject and Get-CimInstance. Future PowerShell versions no longer support Get-WmiObject, so it is time to switch to Get-CimInstance if you haven’t already.

In the previous part you learned that there are considerable differences when you query information across a network, and that Get-CimInstance can use fully configurable and reusable session…

In this mini-series, we are looking at the differences between Get-WmiObject and Get-CimInstance. Future PowerShell versions no longer support Get-WmiObject, so it is time to switch to Get-CimInstance if you haven’t already.

In the previous part you learned that both cmdlets return the same basic information for WMI classes, but the metadata properties added by both cmdlets differ considerably, and occasionally…

In this mini-series, we are looking at the differences between Get-WmiObject and Get-CimInstance. Future PowerShell versions no longer support Get-WmiObject, so it is time to switch to Get-CimInstance if you haven’t already.

In the previous part you learned that both cmdlets return the same basic information for WMI classes, but the metadata properties added by both cmdlets differ considerably. Now let’s take a…

WMI (Windows Management Instrumentation) is part of any Windows operating system and a common and widely used way of getting information about a computer system. PowerShell originally introduced the Get-WmiObject cmdlet. In PowerShell 3, the more modern Get-CimInstance was added.

Since Windows PowerShell always kept the old Get-WmiObject cmdlet for backwards compatibility, many scripters kept using it and ignored Get…

Converting old Word documents to the new .docx format can be a lot of work, and in part 1 you learned the basic steps to automate conversion.

However, to do it right, there are a number of extra steps. If you want to adhere to security guide lines, you need to find out whether there are macros in the documents, and change the extension accordingly. Also, if a document is in read-only mode, you cannot convert it and should…

Converting old Word documents to the new .docx format can be a lot of work. Thanks to PowerShell, you can automate the conversion:

function Convert-WordDocument
{
    param
    (
        [Parameter(Mandatory,ValueFromPipeline,ValueFromPipelineByPropertyName)]
        [string]
        [Alias('FullName')]
        $Path
    )
    begin
    {
        # launch Word
        $word = New-Object -ComObject Word.Application
  

Most PowerShell commands live in modules, and by adding new modules, you can add new commands to your PowerShell environment. To find out whether a command lives in a module, use Get-Command. The next line returns the module that ships the command Get-Service:

 
PS C:\> Get-Command -Name Get-Service | Select-Object -ExpandProperty Module
 

If the Module property is empty, then the command does not ship via a module…

WMI (Windows Management Instrumentation) is a great information source: you can find almost any information about your computer somewhere. The hard part isn’t the WMI query itself. The hard part is finding out the appropriate WMI class names and properties:

To get information about your BIOS, for example, run this:

 
PS> Get-CimInstance -ClassName Win32_BIOS


SMBIOSBIOSVersion : 1.0.9
Manufacturer      : Dell Inc…

Often, a single object needs to be examined, i.e. a process or an Active Directory user. When you display an object in a grid view window such as Out-GridView, the entire object is displayed in one long line.

A much better approach is to convert an object into a hash table. This way, each property is displayed in its own line, and you can search for individual properties via the text filter on top of the grid view window…

How about turning a single object into a hash table? This way, you can display one object property per line when you output the object in a grid view window:

# get any object
$object = Get-Process -Id $pid

# try and access the PSObject
$hash = $object.PSObject.Properties.Where{$null -ne $_.Value}.Name | 
    Sort-Object |
    ForEach-Object { $hash = [Ordered]@{} } { $hash[$_] = $object.$_ } { $hash }

# output regularly…

Let’s assume you want to hide all object properties that have no value (are empty). Here is a simple approach:

# get any object
$object = Get-Process -Id $pid

# try and access the PSObject
$propNames = $object.PSObject.Properties.Where{$null -ne $_.Value}.Name
$object | Select-Object -Property $propNames

This will output only the properties that have a value. You could even make sure the properties are sorted…

Via the secret “PSObject” property, you can get detailed information about object members. For example, if you’d like to know which object properties can actually be changed, try this:

# get any object
$object = Get-Process -Id $pid

# try and access the PSObject
$object.PSObject.Properties.Where{$_.IsSettable}.Name

The result is a list of properties in Process objects that can be assigned new values…

In PowerShell, most data are represented as PSObjects, a specific object “wrapper” added by PowerShell. To get to this specific wrapper, objects have a secret property called “PSObject”. Let’s take a look:

# get any object
$object = Get-Process -Id $pid

# try and access the PSObject
$object.PSObject

# get another object
$object = "Hello"

# try again
$object.PSObject

As you’ll…

This is the second part of our text encryption/decryption series. In the first part you learned how you can safely encrypt text on a machine. Now let’s take a look at the decrypting part.

To successfully decrypt text, you must specify the same encoding that was used during encryption. Based on your encryption parameters, you must specify the same password, and based on the -Scope settings, decryption will work only…

Let’s take a look at a safe way of encrypting text on a computer. The below Protect-Text function takes any text and encrypts it automatically, no password needed. Instead of a password, it uses either your user account and machine, or just your machine as a secret.

If you use -Scope LocalMachine, any user on that machine can decrypt the text, but if the text is leaked to someone else, it cannot be decrypted on…

Internally, Active Directory stores all passwords as so-called NTLM Hashes. There are a number of security-analysis tools that can read and dump these hashes.

While there fortunately is no feasible way of decrypting these hashes and retrieving the original passwords, you can take a (known) password and turn it into an NTLM hash yourself. This is the fundamental procedure of dictionary attacks: they take long lists of…

Here’s a fun PowerShell script that you can use to create a simple multi-channel chat room. All you need is a network share where everyone has read and write permissions.

The chat is file-based and makes use of PowerShell’s ability to monitor files for changes. So essentially, each chat channel is a text file, and whenever someone wants to “say” something, a text line is added to the file. Anyone connected to the…

In previous tips, we already talked about services such as haveIbeenpwned.com. They harvest leaked passwords from previous hacker attacks so you can check whether your password has been compromised and is likely to be included in future dictionary attacks.

Below, you find two useful functions: Test-Password asks for a SecureString so when you get prompted, your input is masked. Convert-SecureStringToText then converts…

It can be very useful to be able to convert an encrypted SecureString back to a plain text. This way, for example, you can use PowerShell’s “masked input” features. Simply ask for a SecureString, and PowerShell takes care of masking the user input. Next, take the SecureString and turn it into a plain text so you can use it internally for whatever you like:

function Convert-SecureStringToText
{
  par…