Create a potocol handler for a Powershell script

I thought I write up a decent guide on doing so since the information I found online was lacking some details.

https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85)

First off the security concerns

1. Any program, website, script etc. that is running on your computer can set off the protocol. There are no authorization checks.

2. You should NOT create a universal protocol handler. That would be a massive security issue concern. I mean that would enable a program, website, script etc. to run any powershell script or command on your computer.

Creating the protocol handler in Windows registry The protocol must be registered in Windows Registry. It's a simple task.

I'm calling my powershell protocol handler for pwsh

Step 1: Open the Registry Editor and navigate to Computer\HKEY_CLASSES_ROOT

For inspiration you can look at Computer\HKEY_CLASSES_ROOT\http to look at how that protocol handler is made.

Step 2: Create the following hierarchy:

Create the key pwsh: [Computer\HKEY_CLASSES_ROOT\pwsh]

Edit the default value of (Default) to URL:pwsh. Remember I call my protocol handler for pwsh, write whatever your is called.

Add a string value with the name URL Protocol and empty data.

It should look like this now:

Create a new key under pwsh, DefaultIcon: Computer\HKEY_CLASSES_ROOT\pwsh\DefaultIcon. Set the (Default) data field to a filepath that leads to an icon or image. I used the powershell icon for Powershell 7 C:\Program Files (x86)\PowerShell\7-preview\assets\ps_black_32x32.ico.

Then create the keys shell -> open -> command like shown on the image above.

In the key command change the (Default) data value to where powershell is installed and then the powershell script to be run.

When testing I do this: "C:\Program Files\PowerShell\6\pwsh.exe" -noexit -executionpolicy bypass -Command {Write-Host %1} Note I am using powershell core 6 and your path to powershell is probably different. You can test to check if it works by opening the run program in Windows(Windows+R).

Expected behavior is the powershell window to open with the text pwsh:Hello Stackoverflow printed.

Step 3: Create a powershell script to handle incoming actions on the protocol. The production ready data value for the command key: "C:\Program Files\PowerShell\6\pwsh.exe" -noexit -File C:\handleActions.ps1 %1

Param($Argument="") # If the protocol is ran you always at least get the protocol name as an argument. (if using the %1)
[String]
$Argument 

function Handle-Actions { # The cmdlet 'Handle-Actions' uses an unapproved verb. 
    [cmdletBinding()]
    param(
        [Parameter(Mandatory=$false, Position=0)]
        [String]
        $Argument 
    )
    $Argumuments = $Argument.Split([Char]0x003F) # Splits by `?`
    #Argumnets is now in an array, do whatever you need to next.
    $Argumuments | %{
        Write-Host $_ # Writes each argument that was seperated by ? to a line
    }
}

Handle-Actions -Argument $Argument

Given the run command pwsh:?firstArgument?SecondArgument the script will output:

pwsh:
firstArgument
SecondArgument

To complement your helpful guide with sample code that automates creation of a custom protocol handler:

The following:

• Creates a custom URI protocol custom: (rather than pwsh:, given that PowerShell is simply used to implement the protocol) to which an open-ended number of arguments can be passed.

• Does so for the current user only (HKEY_CURRENT_USER\Software\Classes) by default; however, it's easy to tweak the code to implement the custom protocol for all users instead (HKEY_LOCAL_MACHINE\Software\Classes), though you'll need to run the code with elevation (as administrator) then.

  • A handler *.ps1 script is automatically created:

    • At $env:USERPROFILE\customUriHandler.ps1 in the current-user scenario.

    • At $env:ALLUSERPROFILE\customUriHandler.ps1 in the all-users scenario.

  • The handler script simply echoes the arguments passed to it, and it is invoked in a PowerShell script window that is kept open after script execution (-NoExit); tweak the PowerShell command as needed.

• The protocol expects its arguments as if it were a shell command, i.e., as a space-separated list of arguments, with argument-individual "..." quoting, if necessary.

  • The sample command at the end uses Start-Process to invoke the following URI, which you could also submit from the Run dialog (WinKey-R), which passes arguments one, two & three, four:

    • URI: custom:one "two & three" four
    • Invocation via Start-Process: Start-Process 'custom:one "two & three" four'

  • Caveat: If you submit this URI via a web browser's address bar (note: doesn't seem to work with Microsoft Edge), it is URI-escaped, and a single one%20%22two%20&%20three%22%20four argument is passed instead, which would require custom parsing; similarly, submitting from File Explorer's address bar passes one%20two%20&%20three%20four, though note that the " chars. are - curiously - lost in the process.

# Determine the scope:
# Set to $false to install machine-wide (for all users)
# Note: Doing so then requires running with ELEVATION.
$currentUserOnly = $true

if (-not $currentUserOnly) {
  net session *>$null
  if ($LASTEXITCODE) { Throw "You must run this script as administrator (elevated)." }
}

$ErrorActionPreference = 'Stop'

# The name of the new protocol scheme
$schemeName = 'custom'

$pwshPathEscaped = (Get-Process -Id $PID).Path -replace '\\', '\\'

$handlerScript = ($env:ALLUSERSPROFILE, $env:USERPROFILE)[$currentUserOnly] + "\${schemeName}UriHandler.ps1"
$handlerScriptEscaped = $handlerScript -replace '\\', '\\'

# Create the protocol handler script.
@'

# Remove the protocol scheme name from the 1st argument.
$argArray = $args.Clone()
$argArray[0] = $argArray[0] -replace '^[^:]+:'
# If the 1st argument is now empty, remove it.
if ('' -eq $argArray[0]) { $argArray = $argArray[1..($argArray.Count-1)] }

"Received $($argArray.Count) argument(s)."

$i = 0
foreach ($arg in $argArray) {
  "#$((++$i)): [$arg]"
}

'@ > $handlerScript

# Construct a temp. *.reg file.
# Target the scope-appropriate root registrykey.
$rootKey = ('HKEY_LOCAL_MACHINE\Software\Classes', 'HKEY_CURRENT_USER\Software\Classes')[$currentUserOnly]
# Determine a temp. file path.
$tempFile = [IO.Path]::GetTempPath() + [IO.Path]::GetRandomFileName() + '.reg'
@"
Windows Registry Editor Version 5.00

[$rootKey\$schemeName]
@="URL:$schemeName"
"URL Protocol"=""

[$rootKey\$schemeName\DefaultIcon]
@="$pwshPathEscaped"

[$rootKey\$schemeName\shell]
@="open"

[$rootKey\$schemeName\shell\open\command]
; === Tweak the PowerShell command line here: ===
@="\"$pwshPathEscaped\" -ExecutionPolicy Bypass -NoProfile -NoExit -File \"$handlerScriptEscaped\" %1"

"@ > $tempFile

# Import the *.reg file into the registry.
& {
  $ErrorActionPreference = 'Continue'
  reg.exe import $tempFile 2>$null
  if ($LASTEXITCODE) { Throw "Importing with reg.exe failed: $tempFile"}
}

# Remove the temp. *.reg file.
Remove-Item -ErrorAction Ignore -LiteralPath $tempFile

# ---

# Sample invocation of the new protocol with 3 arguments:
$uri = "$schemeName`:one `"two & three`" four"
Write-Verbose -Verbose "Invoking the following URI: $uri"
Start-Process $uri