Solving a strange Remote Desktop Gateway authentication problem

I recently deployed a new Remote Desktop Gateway server but when I authenticated it would tell me the logon failed even though I knew the policies were valid for the user (because I could logon from a different computer) and I knew the credential was correct.

There were no logs under TerminalServices-GatewayOperational which meant the problem was not a policy issue as the connection was not getting this far.

To start the troubleshooting Kerberos logging was enabled on the client machine:


On connecting again I could check the System event log and examined Kerberos logs. Sure enough there were Kerberos errors. The problem seemed to be on my machine the authentication did not fallback to NTLM which it did on the machines where it worked.

The solution was to add an SPN for the public facing name which solved the problem.

setspn -S HTTP/ dal-rdg01$

Easily configure Remote Desktop Gateway firewall rules

When you install Remote Desktop Gateway which enables RDP to be encapsulated in HTTPS a number of firewall exceptions are required which are enabled automatically. This also means the RDG has a public and private IP address.

There are many other firewall exceptions that are normal for Windows functionality that by default are enabled for the Any profile which when you have a public IP address on a NIC means they are also enabled to the Internet. What you really need is for those exceptions to be bound to the domain profile, i.e. the internal NIC. This is easy to do with PowerShell. Firstly you can list all the exceptions that are enabled for Any.

Get-NetFirewallRule -Enabled True | where {$_.Profile -eq "Any"} | ft name, displayname -AutoSize

This will list a lot of exceptions. Next we want to change them to a profile of Domain except for the two required for RDG, the RDG UDP and HTTPS rules. This can be done with the following:

Get-NetFirewallRule -Enabled True | where {$_.Profile -eq "Any" -and ($_.Name -ne "IIS-WebServerRole-HTTPS-In-TCP" -and $_.Name -ne "TSG-UDP-Transport-In-UDP")} | Set-NetFirewallRule -Profile Domain


Note, you could change the rules to be excluded for other requirements you may have for other types of server.

Deploying Operating Systems in Azure using Windows PE

In this article I want to walk-through deploying operating systems in Azure using a custom Windows PE environment and along the way cover some basics around PE and OS deployment. Before going any further I would stress I don’t recommend this. The best way to deploy in Azure is using templates, have generic images and then inject configuration into them using declarative technologies such as PowerShell DSC, Chef or Puppet however there are organizations that have multiple years of custom image development at their core that at least in the short term need to be maintained which was my goal for this investigation. Is it even possible to use your own Windows PE based deployment.

My starting point was to get a deployment working on-premises on Hyper-V. Azure uses Hyper-V and at this level there really is nothing special about what Azure does so my thinking is if I got a process running on-premises I should be able to take that VHD, upload it to Azure, make an image out of it and create VMs from it (and this proved to be true!). The benefit of this approach was speed of testing and the ability to interact with the Windows PE environment during the development and testing phase. Something that is much harder in Azure as there is no console access.

The first step was to create a VHD (not VHDX for Azure compatibility) that contained Windows PE which I would boot to. I downloaded the latest Windows ADK from (1709) and installed on a machine. Once installed I created my own Windows PE (x64) instance via the Deployment and Imaging Tools Environment. I used the following commands:

copype amd64 C:WinPE_amd64

I then wanted to add PowerShell and other components to it including imagex.exe:

Dism /Mount-Image /ImageFile:"C:WinPE_amd64mediasourcesboot.wim" /Index:1 /MountDir:"C:WinPE_amd64mount"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

Dism /Add-Package /Image:"C:WinPE_amd64mount" /PackagePath:"C:Program Files (x86)Windows Kits10Assessment and Deployment KitWindows Preinstallation"

copy "C:Program Files (x86)Windows Kits10Assessment and Deployment KitDeployment Toolsamd64DISMimagex.exe" c:winpe_amd64mount

Dism /Unmount-Image /MountDir:C:WinPE_amd64mount /Commit

Notice in the code above when I’m adding packages I do this my mounting the boot.wim file that is part of my copied PE environment, performing actions against it then committing those changes when I unmounts it. I’m modifying that boot.wim. This is an important point.

Once the PE was ready I wanted to quickly test so I built a VHD based on that PE environment.

create vdisk file="C:WinPEPS.vhd" maximum=100000 type=expandable
attach vdisk
create partition primary size=1000
assign letter=V
format fs=ntfs quick

MakeWinPEMedia /UFD C:WinPE_amd64 V:

select vdisk file="C:WinPEPS.vhd"
detach vdisk

This creates a new VHD file and attaches it to the current OS as drive V:. I then make bootable media of my PE folder to the V: folder then detach. I then copied this VHD file to a Hyper-V box and created a VM that used it as its boot disk. Sure enough it booted and I was facing a PE environment. The next step was to format the disks and apply an image automatically. My initial though was “how can I format the disk and apply an OS to the disk if booted from it (PE)?” however quickly it became obvious that the PE I was booted into wasn’t really running from the local disk. Instead what happens is on boot the boot.wim file on the PE media is read into a writable RAM disk which is where the PE actually runs from (the X drive). Therefore even though the C: drive contained that boot.wim it’s not actually being used and do it can be wiped. Therefore I created a script that did three things

  1. Wiped the disk and create the system and windows partitions
  2. Applied a Windows Server image (1709 Server Core)
  3. Make the disk bootable

To partition the disk I created a text file, parts.txt which contained:

Select disk 0
create partition primary size=350
format quick fs=ntfs label="System"
assign letter="S"
create partition primary
format quick fs=ntfs label="Windows"
assign letter="W"

I could then call this with (I would copy this to my Windows PE environment as well):

diskpart /s x:parts.txt

The WIM file I placed on a file share (this would be an Azure Files share once in Azure) so I had to map to the network drive and apply so the complete file became:

Diskpart /s x:parts.txt

Net use z: \savdalfssoftware /user:savilltechadmin password

x:Imagex /apply "z:OS ImagesWindows Server 2016 1709Expandedsourcesinstall.wim" 2 w:

W:WindowsSystem32bcdboot W:Windows /l en-US


I saved this as autolaunch.bat and added to the root of my Windows PE boot.wim (by remounting it) along with the parts.txt. I also modified the startnet.cmd found under the WindowsSystem32 folder of my mounted PE environment to call my autolaunch.bat file, e.g.



I then unmounted and created a new VHD. I made sure my install.wim was present in my file server as referenced, copied over the VHD to my Hyper-V server, changed the VM to use the new VHD and sure enough it booted, formatted the disks and laid down the image. Note you are putting a password in the file, this is not ideal. Also not if your password contains special characters you may have to escape them in the batch file or they won’t work correctly, for example if you password contained % you actually need %% in the string!

The next step was to try this in Azure. I created a storage account in Azure, added an Azure Files share and uploaded the install.wim file to it. I changed the autolaunch.bat to map to the Azure Files share instead of the local file share (along with the path to the WIM file). It therefore became:

net use Z: \ /u:AZUREsavpoc Lbk0C7HVG8X1P8UtMtw6irBGjSQ==

And execute to:

x:Imagex /apply "z:install.wim" 2 w:

To upload the VHD to Azure and create an image from that uploaded file I used the following PowerShell. This is important. Trying to upload from other tools or the Azure portal seems to leave the VHD in a strange state and unusable.



Select-AzureRmSubscription -SubscriptionId "subid"

$rgImgName = "RGSCUSPOC"
$urlOfUploadedImageVhd = ""
Add-AzureRmVhd -ResourceGroupName $rgImgName -Destination $urlOfUploadedImageVhd `
 -LocalFilePath "S:OS ImagesPE1709WinPEPS.vhd"

#Create image
$location = "South Central US" 
$imageName = "WinPEImage"

$imageConfig = New-AzureRmImageConfig -Location $location
$imageConfig = Set-AzureRmImageOsDisk -Image $imageConfig -OsType Windows -OsState Generalized -BlobUri $urlOfUploadedImageVhd
$image = New-AzureRmImage -ImageName $imageName -ResourceGroupName $rgImgName -Image $imageConfig

From here I created a new VM from my image. I used PowerShell below to create my VM. Note I’m enabling boot diagnostics. This allowed me to view the console even if I couldn’t interact with it. Therefore I had some idea what was happening

$location = "South Central US" 
$rgname = "POCRG"
$vmName = "poc"
$computerName = "poc"
$vmSize = "Standard_DS1_v2"
$netRG = "RG_SCUS"
$vnetname = "RG_SCUS-vnet"
$subnetname = "default"
$stotype = 'Standard_LRS'
$stoname = "sasavpocdiag"
$user = "localadmin"
$password = 'passwordhere'
$securePassword = ConvertTo-SecureString $password -AsPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential ($user, $securePassword) 
$imageName = "WinPEImage" 
$rgImgName = "RGSCUSPOC"
$image = get-azurermimage -ImageName $imageName -ResourceGroupName $rgImgName

$vnet = Get-AzureRmVirtualNetwork -ResourceGroupName $netrg -Name $vnetName

New-AzureRmResourceGroup -Name $rgname -Location $location

$ipName = "POCPip"
$pip = New-AzureRmPublicIpAddress -Name $ipName -ResourceGroupName $rgName -Location $location `
 -AllocationMethod Dynamic

$nicName = "pocNIC"
$nic = New-AzureRmNetworkInterface -Name $nicName -ResourceGroupName $rgName -Location $location `
 -SubnetId $vnet.Subnets[0].Id -PublicIpAddressId $pip.Id

$vm = New-AzureRmVMConfig -VMName $vmName -VMSize $vmSize
$vm = Set-AzureRmVMSourceImage -VM $vm -Id $image.Id

$vm = Set-AzureRmVMOSDisk -VM $vm -DiskSizeInGB 1024 `
-CreateOption FromImage -Caching ReadWrite

$vm = Set-AzureRmVMOperatingSystem -VM $vm -Windows -ComputerName $computerName `
-Credential $cred #-ProvisionVMAgent -EnableAutoUpdate

$vm = Add-AzureRmVMNetworkInterface -VM $vm -Id $nic.Id

New-AzureRmStorageAccount -ResourceGroupName $rgname -Name $stoname -Location $location -Type $stotype
$vm = Set-AzureRmVMBootDiagnostics -VM $vm -Enable -ResourceGroupName $rgName -StorageAccountName $stoname

New-AzureRmVM -VM $vm -ResourceGroupName $rgName -Location $location

I then jumped over to the portal and via the Support + Troubleshooting section – Boot diagnostics – Screenshot I could see it deploying in Azure (updated about every 30 seconds or so).

This worked! The OS installed and strangely I could RDP to it even though I never enabled this, it had the right name, it had the Azure agent installed. What trickery is this and then it hit me. I never added my own unattend.xml file. All I did was apply a 2016 image to a disk and it rebooted. Basically the same as if I had used a template with 2016. The ISO file that Azure automatically creates when deploying a VM that contains an unattend.xml file and other setup files still got created, still got attached and was therefore still used. This was good but also bad as I wanted to use my own unattend.xml file to further prove we could customize.

The next step was to generate my own unattend.xml file and use it. At this point I didn’t want to keep having to rebuild the VHD every time I made a script change and so I broke apart the logic so the autolaunch.bat just connected to the Azure Files, partitioned the disk then copied down an imageinstall.bat file and executed. This way I could change imageinstall.bat on the file share whenever I wanted to change the functionality. autolaunch.bat became:

Diskpart /s x:parts.txt
net use Z: \ /u:AZUREsavpoc Lbk0C7HVG..BGjSQ==
copy z:imageinstall.bat x:
call x:imageinstall.bat

And imageinstall.bat which was placed on the file share became:

x:Imagex /apply "z:install.wim" 2 w:
W:WindowsSystem32bcdboot W:Windows /l en-US
mkdir w:windowspanther
copy z:unattend.xml w:windowspanther
powershell -executionpolicy bypass -nologo -noprofile -file z:unattendupdate.ps1

I created a new VHD with the reduced autolaunch.bat and uploaded to Azure (and created a new image after deleting the old one with Remove-AzureRmImage -ImageName $imageName -ResourceGroupName $rgImgName).

Now I’m jumping over a few steps here but basically I created an unattend file to set a default password, have a placeholder for the computer name, enable auto mount of disks, move the pagefile to D:, enable RDP and required firewall rules and also launch the install.cmd that Azure normally runs. This would install the agent, register with Azure fabric etc. Because I place my unattend.xml in the windowspanther folder it overrides any found on removable media, i.e. the Azure one! My unattend file was:

<?xml version=”1.0″ encoding=”utf-8″?>
<unattend xmlns=”urn:schemas-microsoft-com:unattend”>
<settings pass=”specialize”>
<component name=”Microsoft-Windows-TerminalServices-LocalSessionManager” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<component name=”Networking-MPSSVC-Svc” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<FirewallGroup wcm:action=”add” wcm:keyValue=”RemoteDesktop”>
<Group>Remote Desktop</Group>
<component name=”Microsoft-Windows-TerminalServices-RDP-WinStationExtensions” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<component name=”Microsoft-Windows-Shell-Setup” processorArchitecture=”wow64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<component name=”Microsoft-Windows-Deployment” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<RunSynchronousCommand wcm:action=”add”>
<Description>Execute Install.cmd</Description>
<Path>cmd.exe /c “(for %1 in (z y x w v u t s r q p o n m l k j i h g f e d c b a) do @(DIR %1: 1&gt;NUL 2&gt;&amp;1 &amp;&amp; if exist %1:Install.cmd (%1:Install.cmd &amp; exit))) &amp; exit 3″</Path>
<settings pass=”windowsPE”>
<component name=”Microsoft-Windows-Setup” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<settings pass=”offlineServicing”>
<component name=”Microsoft-Windows-PartitionManager” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<settings pass=”oobeSystem”>
<component name=”Microsoft-Windows-Shell-Setup” processorArchitecture=”amd64″ publicKeyToken=”31bf3856ad364e35″ language=”neutral” versionScope=”nonSxS” xmlns:wcm=”; xmlns:xsi=””&gt;
<cpi:offlineImage cpi:source=”wim://savdalfs/software/os%20images/windows%20server%202016%201709/expanded/sources/install.wim#Windows Server 2016 SERVERDATACENTERACORE” xmlns:cpi=”urn:schemas-microsoft-com:cpi” />

Now in this file I have a placeholder string for the computername, <ComputerName>TSCAEDPH</ComputerName> . I wanted to replace this with the computername specified on the Azure fabric. How would I get this from inside the guest? Well Azure has an endpoint at that can be called from within a VM and basic information can be found and so I created a PowerShell script that would find the computername and update the unattend.xml I had copied to the panther folder of the deployed image:

$url = ""
$data = Invoke-RestMethod -Uri $url -Headers @{'Metadata'='true'} -Method Get
$computedata = $data | select-object -ExpandProperty compute
$computename = $

$attendfile = "w:windowspantherunattend.xml"
(Get-Content $attendfile).Replace('TSCAEDPH',$computename) | Set-Content $attendfile

This was saved as unattendupdate.ps1 on the Azure Files share as well which now contained the install.wim, unattend.xml, imageinstall.bat and this ps1 file. Fingers crossed I kicked off a new VM build. It worked. It used my unattend.xml file but still got the Azure agent etc installed. It also still renamed the local administrator account to that specified as part of the VM creation as that happens as part of the Azure install step process which I was now calling from my unattend.xml file.

Now there are some problems here. If Azure changes the structure of their ISO file with the install.cmd this will break so it would have to be re-investigated however this is still better than trying to duplicate everything they do manually which is far more likely to change far more often.

So there you go. You can use your own PE in Azure to customize and create deployments including unattend. You can still call the Azure agent install and finalize. But ideally, use images 😉



New video on publishing corporate apps to iOS with Intune and Configuration Manager

Decided to create a video that walked through the exact process to deploy corporate applications to iOS (and Android) through Intune while actually performing the management with Configuration Manager. Additionally I lock it down so corporate data cannot flow from corporate apps to personal apps. Available at