How to Update an Outlook for Windows Signature with PowerShell

How to Roll Your Own Outlook Signature with PowerShell

After finishing my article about Microsoft developing cloud signatures for Outlook, I decided to look at what’s involved with updating an Outlook signature with PowerShell. As it turns out, there’s quite a few methods suggested in various blogs and articles, mostly on the theme of how to use information from Active Directory into signatures (here’s an example).

Most of the scripts I met were old and suffered from one problem or another, like failing to support Office ProPlus (click to run) or not using Azure Active Directory. So I decided to explore the topic by putting together my own version.

Outlook and the System Registry

As noted in my other article, Outlook for Windows stores information about its settings in the system registry. The first issue was to find out from the registry which Azure Active Directory account is used with Outlook. My solution is to fetch the accounts information and parse out the user principal name. I then use the user principal name to fetch account properties from Azure Active Directory:

$UserAccount = Get-ItemProperty -Path HKCU:\Software\Microsoft\Office\Outlook\Settings -Name Accounts | Select -ExpandProperty Accounts
$UserId = (ConvertFrom-Json $UserAccount).UserUpn[0]
# Retrieve the properties of the user from Azure Active Directory
$UserProperties = Get-AzureADUser -ObjectId $UserId

Outlook Profiles

Outlook can have multiple profiles on a PC. Each profile has its own settings, including signatures. The default profile name is Outlook, and it’s the one that you’ll probably encounter most often (based on a limited test). But you can have more profiles and then must get into the business of figuring out how to update which profile with which signature. Given I was doing this on a wet Sunday afternoon, I decided to cheat by:

  • Fetching the profile information from the registry.
  • If only one was found, set things up to update the signature information for that profile.
  • If more than one profile exists, update the common settings for Outlook. This means that users can’t update signatures themselves, but it was an OK workaround given limited time.
# Find Outlook Profiles in registry
$CommonSettings = $False
$Profiles = (Get-ChildItem HKCU:\Software\Microsoft\Office\16.0\Outlook\Profiles).PSChildName
# This script can only deal with a single (default profile); more code needed to handle multiple profiles
If ($Profiles -eq $Null -or $Profiles.Count -ne 1) {
   Write-Host "Warning - Applying signature to all Outlook profiles" 
   $OutlookProfilePath = "HKCU:\Software\Microsoft\\Office\16.0\Common\MailSettings"
   $CommonSettings = $True}
Else { # Path to default profile is elsewhere in the registry
   $OutLookProfilePath = "HKCU:\Software\Microsoft\Office\16.0\Outlook\Profiles\" + $Profiles.Trim() + "\9375CFF0413111d3B88A00104B2A6676\00000001" }

Sometimes the path to the user profile in the registry ends with 00000002 (the first might point to the Outlook address book), so your code should be prepared to handle this situation.

Generating the Signature File

Now that I know where in the registry to update, we can proceed to generate the signature file. This is usually an RTF file written to %appdata%\Microsoft\Signatures (English language PCs). A HTML file is also acceptable. Many scripts call Word as a COM object to create or update a signature file. I looked at using the impressive PSWriteWord module (available in the PowerShell gallery) to do the job with code like this:

Import-Module PSWriteWord
$WordDocument = New-WordDocument $FilePath

$Line = $Null
Add-WordText -WordDocument $WordDocument -Text $Line
$Line = $UserProperties.DisplayName 
Add-WordText -WordDocument $WordDocument -Text $Line -Bold $True -FontSize 12 -FontFamily "Segoe UI"
$Line = $UserProperties.Title
Add-WordText -WordDocument $WordDocument -Text $Line -FontSize 12 -FontFamily "Segoe UI"
$Line = "Email: " +$UserProperties.WindowsEmailAddress
Add-WordText -WordDocument $WordDocument -Text $Line -FontSize 10 -FontFamily "Segoe UI"
$Line = "Telephone: " + $UserProperties.Phone + " Mobile: " + $UserProperties.MobilePhone
Add-WordText -WordDocument $WordDocument -Text $Line -FontSize 10 -FontFamily "Segoe UI"
$Line = $UserProperties.StreetAddress
Add-WordText -WordDocument $WordDocument -Text $Line -FontSize 10 -FontFamily "Segoe UI"
$Line = $UserProperties.StateOrProvince
Add-WordText -WordDocument $WordDocument -Text $Line -FontSize 10 -FontFamily "Segoe UI"
$Line = $UserProperties.PostalCode
Add-WordText -WordDocument $WordDocument -Text $Line -FontSize 10 -FontFamily "Segoe UI"

### Save document
Save-WordDocument $WordDocument -Language 'en-US' 

It’s easy to generate a Word DOCX file. You still must convert the signature file to RTF, which can be done using a Word COM instance, but I ran into some problems when calling Word, apparently due to failure to load a DLL.

$WordDocument = $WordApplication.Documents.Open($FilePath)                           
You cannot call a method on a null-valued expression.
At line:1 char:1
+ $WordDocument = $WordApplication.Documents.Open($FilePath)
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : InvokeMethodOnNull

HTML Works for Me

Not wanting to reinstall Office, I went back to my old backstop of creating formatted HTML text. To get a head start, I used the free email signature generator tool from Code Two Software to get some ideas of what should be in the signature and what the necessary HTML would look like. The code to build the HTML and write out the signature file is:

# Construct a signature file in HTML format using the information fetched from Azure Active Directory
$CompanyLogo      = ""
$HeadingLine      = "<title>Signature</title><br>"
$ImageLine        = ""
$PersonLine       = "'
$EndLine          = "<table style="`&quot;FONT-SIZE:" 8pt;="" color:="" gray;="" font-family:="" `'segoe="" ui`'="" `"=""> <tbody><tr><td><img src="&quot; + $CompanyLogo + &quot;" border="0"></td><td padding="0"><b>" + $UserProperties.DisplayName + " </b> " + $JobTitle + "<br>"
$CompanyLine      = "<b>" + $CompanyName + "</b> " + $StreetAddress + ", " + $City + ", " + $PostalCode + "<br>" + $UserProperties.TelephoneNumber + "/" + $UserProperties.Mobile + " Email: " + $UserProperties.Mail + "<br><br>"
# Facebook and Twitter icons
$IconsLine        = '</td></tr><tr><td style="font-size: 10pt; font-family: Arial, sans-serif; padding-bottom: 0px; padding-top: 5px; padding-left: 10px; vertical-align: bottom;" valign="bottom"><span><a href="" target="_blank" rel="noopener noreferrer"><img border="0" width="23" alt="facebook icon" style="border:0; height:23px; width:23px" src=""></a> </span><span><a href="" target="_blank" rel="noopener noreferrer"><img border="0" width="23" alt="twitter icon" style="border:0; height:23px; width:23px" src=""></a></span></td></tr></tbody></table><br><br>"

# Put everything together and output the HTML file
$SignatureHTML = $HeadingLine + $ImageLine + $PersonLine + $CompanyLine + $Iconsline + $EndLine | Out-File $HtmlPath

Updating the Registry

The final step is to update the registry with details of the new signature file. Here’s how I updated the settings (these settings mean that Outlook inserts the signature in new messages and replies/forwards):

# Update the registry settings where Outlook picks up its signature information
If (Test-Path $TargetForSignatures) {
   Get-Item -Path $OutlookProfilePath | New-Itemproperty -Name "New Signature" -value $SignatureName -Propertytype string -Force 
   Get-Item -Path $OutlookProfilePath | New-Itemproperty -Name "Reply-Forward Signature" -value $SignatureName -Propertytype string -Force }

The Final Signature

The resulting signature is pretty nice (Figure 1), and I am happy with it, even if the code to generate the signature is a bit kludgy. For this to work in production, you’d have to make sure that the script called the Connect-AzureAD cmdlet to connect to Azure Active Directory and add a pile of error checking and other essential pieces. It’s also important to underscore the importance of an accurate directory in this exercise. If your directory isn’t populated with up-to-date information about people, any signature which depends on that information won’t be successful. If you’re uncertain about the accuracy of your directory, maybe a visit to Hyperfish might be a good idea.

The Outlook signature generated with PowerShell
Figure 1: The Outlook signature generated with PowerShell

If you want to make the script better, you can grab a copy from GitHub. Make sure you let us know what you did to improve things by writing a comment to this post.

My wet afternoon’s coding taught me that the ISVs who build auto-signature products for Office 365 have a lot to cope with. And that Microsoft’s work to put Outlook signatures in the cloud can only be a good thing.

Making sure that users have the right signature is a mixture of client and mailbox management. The Office 365 for IT Pros eBook covers both topics in-depth and at length. You should subscribe!

6 Replies to “How to Update an Outlook for Windows Signature with PowerShell”

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.