Use named pipe transport securely, remove TCP

* Use ACL'd named pipe as transport
* Remove TCP as a transport option

Author: TylerLeonhardt

PowerShellEditorServices.build.ps1

@@ -143,7 +143,10 @@ task TestPowerShellApi -If { !$script:IsUnix } {
 }
 
 task Build {
-    exec { & $script:dotnetExe build -c $Configuration .\src\PowerShellEditorServices.Host\PowerShellEditorServices.Host.csproj $script:TargetFrameworksParam }
+    exec { & $script:dotnetExe publish -c $Configuration .\src\PowerShellEditorServices.Host\PowerShellEditorServices.Host.csproj -f netstandard1.6 }
+    if (!$script:IsUnix) {
+        exec { & $script:dotnetExe publish -c $Configuration .\src\PowerShellEditorServices.Host\PowerShellEditorServices.Host.csproj -f net451 }
+    }
     exec { & $script:dotnetExe build -c $Configuration .\src\PowerShellEditorServices.VSCode\PowerShellEditorServices.VSCode.csproj $script:TargetFrameworksParam }
     exec { & $script:dotnetExe publish -c $Configuration .\src\PowerShellEditorServices\PowerShellEditorServices.csproj -f netstandard1.6 }
     Copy-Item $PSScriptRoot\src\PowerShellEditorServices\bin\$Configuration\netstandard1.6\publish\UnixConsoleEcho.dll -Destination $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\netstandard1.6
@@ -209,12 +212,15 @@ task LayoutModule -After Build {
     Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\netstandard1.6\* -Filter Microsoft.PowerShell.EditorServices*.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Core\
     Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\netstandard1.6\UnixConsoleEcho.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Core\
     Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\netstandard1.6\libdisablekeyecho.* -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Core\
+    Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\netstandard1.6\publish\runtimes\win\lib\netstandard1.3\* -Filter System.IO.Pipes*.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Core\
+
     if (!$script:IsUnix) {
         Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices\bin\$Configuration\net451\Serilog*.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Desktop
 
         Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\net451\* -Filter Microsoft.PowerShell.EditorServices*.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Desktop\
         Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\net451\Newtonsoft.Json.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Desktop\
         Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\net451\UnixConsoleEcho.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Desktop\
+        Copy-Item -Force -Path $PSScriptRoot\src\PowerShellEditorServices.Host\bin\$Configuration\net451\publish\System.Runtime.InteropServices.RuntimeInformation.dll -Destination $PSScriptRoot\module\PowerShellEditorServices\bin\Desktop\
     }
 
     # Copy Third Party Notices.txt to module folder

README.md

@@ -30,7 +30,7 @@ of the following classes:
 - TemplateService
 
 The intended usage model is now to host PowerShell Editor Services within powershell.exe
-and communicate with it over TCP sockets via the [Language Server Protocol](https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md)
+and communicate with it over named pipes (or Unix domain sockets on macOS & Linux) via the [Language Server Protocol](https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md)
 and [Debug Adapter Protocol](https://github.com/Microsoft/vscode-debugadapter-node/blob/master/protocol/src/debugProtocol.ts).
 Detailed usage documentation for this module is coming soon!
 

module/PowerShellEditorServices/PowerShellEditorServices.psm1

@@ -31,12 +31,6 @@ function Start-EditorServicesHost {
         [string]
         $HostVersion,
 
-        [int]
-        $LanguageServicePort,
-
-        [int]
-        $DebugServicePort,
-
         [switch]
         $Stdio,
 
@@ -110,16 +104,6 @@ function Start-EditorServicesHost {
         $debugServiceConfig.TransportType    = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Stdio
     }
 
-    if ($LanguageServicePort) {
-        $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Tcp
-        $languageServiceConfig.Endpoint = "$LanguageServicePort"
-    }
-
-    if ($DebugServicePort) {
-        $debugServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::Tcp
-        $debugServiceConfig.Endpoint = "$DebugServicePort"
-    }
-
     if ($LanguageServiceNamedPipe) {
         $languageServiceConfig.TransportType = [Microsoft.PowerShell.EditorServices.Host.EditorServiceTransportType]::NamedPipe
         $languageServiceConfig.Endpoint = "$LanguageServiceNamedPipe"

module/PowerShellEditorServices/Start-EditorServices.ps1

@@ -6,7 +6,7 @@
 # - Verifying the existence of dependencies like PowerShellGet
 # - Verifying that the expected version of the PowerShellEditorServices module is installed
 # - Installing the PowerShellEditorServices module if confirmed by the user
-# - Finding unused TCP port numbers for the language and debug services to use
+# - Creating named pipes for the language and debug services to use (if using named pipes)
 # - Starting the language and debug services from the PowerShellEditorServices module
 #
 # NOTE: If editor integration authors make modifications to this
@@ -39,7 +39,7 @@ param(
     [ValidateNotNullOrEmpty()]
     $LogPath,
 
-    [ValidateSet("Diagnostic", "Normal", "Verbose", "Error", "Diagnostic")]
+    [ValidateSet("Diagnostic", "Normal", "Verbose", "Error")]
     $LogLevel,
 
 	[Parameter(Mandatory=$true)]
@@ -75,8 +75,7 @@ param(
     $DebugServicePipeName = $null
 )
 
-$minPortNumber = 10000
-$maxPortNumber = 30000
+$DEFAULT_USER_MODE = "600"
 
 if ($LogLevel -eq "Diagnostic") {
     $VerbosePreference = 'Continue'
@@ -168,67 +167,71 @@ function Test-ModuleAvailable($ModuleName, $ModuleVersion) {
     return $false;
 }
 
-function Test-PortAvailability {
+function New-NamedPipeName {
+
+    # We try 10 times to find a valid pipe name
+    for ($i = 0; $i -lt 10; $i++) {
+        # add a guid to make the pipe unique
+        $PipeName = "PSES_$((New-Guid).Guid)"
+
+        if ((Test-NamedPipeName -PipeName $PipeName)) {
+            return $PipeName
+        }
+    }
+    ExitWithError "Could not find valid a pipe name."
+}
+
+function Get-NamedPipePath {
     param(
         [Parameter(Mandatory=$true)]
-        [int]
-        $PortNumber
+        [ValidateNotNullOrEmpty()]
+        [string]
+        $PipeName
     )
 
-    $portAvailable = $true
-
-    try {
-        # After some research, I don't believe we should run into problems using an IPv4 port
-        # that happens to be in use via an IPv6 address.  That is based on this info:
-        # https://www.ibm.com/support/knowledgecenter/ssw_i5_54/rzai2/rzai2compipv4ipv6.htm#rzai2compipv4ipv6__compports
-        $ipAddress = [System.Net.IPAddress]::Loopback
-        Log "Testing availability of port ${PortNumber} at address ${ipAddress} / $($ipAddress.AddressFamily)"
-
-        $tcpListener = Microsoft.PowerShell.Utility\New-Object System.Net.Sockets.TcpListener @($ipAddress, $PortNumber)
-        $tcpListener.Start()
-        $tcpListener.Stop()
+    if (-not $IsLinux -and -not $IsMacOS) {
+        return "\\.\pipe\$PipeName";
     }
-    catch [System.Net.Sockets.SocketException] {
-        $portAvailable = $false
-
-        # Check the SocketErrorCode to see if it's the expected exception
-        if ($_.Exception.SocketErrorCode -eq [System.Net.Sockets.SocketError]::AddressAlreadyInUse) {
-            Log "Port $PortNumber is in use."
-        }
-        else {
-            Log "SocketException on port ${PortNumber}: $($_.Exception)"
-        }
+    else {
+        # Windows uses NamedPipes where non-Windows platforms use Unix Domain Sockets.
+        # the Unix Domain Sockets live in the tmp directory and are prefixed with "CoreFxPipe_"
+        return (Join-Path -Path ([System.IO.Path]::GetTempPath()) -ChildPath "CoreFxPipe_$PipeName")
     }
 
-    $portAvailable
 }
 
-$portsInUse = @{}
-$rand = Microsoft.PowerShell.Utility\New-Object System.Random
-function Get-AvailablePort() {
-    $triesRemaining = 10;
-
-    while ($triesRemaining -gt 0) {
-        do {
-            $port = $rand.Next($minPortNumber, $maxPortNumber)
-        }
-        while ($portsInUse.ContainsKey($port))
-
-        # Whether we succeed or fail, don't try this port again
-        $portsInUse[$port] = 1
+# Returns True if it's a valid pipe name
+# A valid pipe name is a file that does not exist either
+# in the temp directory (macOS & Linux) or in the pipe directory (Windows)
+function Test-NamedPipeName {
+    param(
+        [Parameter(Mandatory=$true)]
+        [ValidateNotNullOrEmpty()]
+        [string]
+        $PipeName
+    )
 
-        Log "Checking port: $port, attempts remaining $triesRemaining --------------------"
-        if ((Test-PortAvailability -PortNumber $port) -eq $true) {
-            Log "Port: $port is available"
-            return $port
-        }
+    $path = Get-NamedPipePath -PipeName $PipeName
+    return -not (Test-Path $path)
+}
 
-        Log "Port: $port is NOT available"
-        $triesRemaining--;
+function Set-NamedPipeMode {
+    param(
+        [Parameter(Mandatory=$true)]
+        [ValidateNotNullOrEmpty()]
+        [string]
+        $PipeFile
+    )
+    chmod $DEFAULT_USER_MODE $PipeFile
+    if ($IsLinux) {
+        $mode = stat -c "%A" $PipeFile
+    }
+    else {
+        $mode = stat -f "%A" $PipeFile
+    }
+    if ($mode -ne $DEFAULT_USER_MODE) {
+        ExitWithError "Permissions to the pipe file were not set properly. Expected: $DEFAULT_USER_MODE Actual: $mode for file: $PipeFile"
     }
-
-    Log "Did not find any available ports!!"
-    return $null
 }
 
 # Add BundledModulesPath to $env:PSModulePath
@@ -251,21 +254,36 @@ try {
 
     Microsoft.PowerShell.Core\Import-Module PowerShellEditorServices -ErrorAction Stop
 
-	# Locate available port numbers for services
-	# There could be only one service on Stdio channel
-
-	$languageServiceTransport = $null
-	$debugServiceTransport = $null
+    # Locate available port numbers for services
+    # There could be only one service on Stdio channel
 
-	if ($Stdio.IsPresent -and -not $DebugServiceOnly.IsPresent) { $languageServiceTransport = "Stdio" }
-	elseif ($LanguageServicePipeName)                           { $languageServiceTransport = "NamedPipe"; $languageServicePipeName = "$LanguageServicePipeName" }
-	elseif ($languageServicePort = Get-AvailablePort)           { $languageServiceTransport = "Tcp" }
-	else                                                        { ExitWithError "Failed to find an open socket port for language service." }
+    $languageServiceTransport = $null
+    $debugServiceTransport = $null
 
-	if ($Stdio.IsPresent -and $DebugServiceOnly.IsPresent)      { $debugServiceTransport = "Stdio" }
-	elseif ($DebugServicePipeName)                              { $debugServiceTransport = "NamedPipe"; $debugServicePipeName = "$DebugServicePipeName" }
-	elseif ($debugServicePort = Get-AvailablePort)              { $debugServiceTransport = "Tcp" }
-	else                                                        { ExitWithError "Failed to find an open socket port for debug service." }
+    if ($Stdio.IsPresent) {
+        $languageServiceTransport = "Stdio"
+        $debugServiceTransport = "Stdio"
+    }
+    else {
+        $languageServiceTransport = "NamedPipe"
+        $debugServiceTransport = "NamedPipe"
+        if (-not $LanguageServicePipeName) {
+            $LanguageServicePipeName = New-NamedPipeName
+        }
+        else {
+            if (-not (Test-NamedPipeName -PipeName $LanguageServicePipeName)) {
+                ExitWithError "Pipe name supplied is already taken: $LanguageServicePipeName"
+            }
+        }
+        if (-not $DebugServicePipeName) {
+            $DebugServicePipeName = New-NamedPipeName
+        }
+        else {
+            if (-not (Test-NamedPipeName -PipeName $DebugServicePipeName)) {
+                ExitWithError "Pipe name supplied is already taken: $DebugServicePipeName"
+            }
+        }
+    }
 
     if ($EnableConsoleRepl) {
         Write-Host "PowerShell Integrated Console`n"
@@ -281,11 +299,9 @@ try {
             -LogPath $LogPath `
             -LogLevel $LogLevel `
             -AdditionalModules $AdditionalModules `
-            -LanguageServicePort $languageServicePort `
-            -DebugServicePort $debugServicePort `
             -LanguageServiceNamedPipe $LanguageServicePipeName `
             -DebugServiceNamedPipe $DebugServicePipeName `
-            -Stdio:$Stdio.IsPresent`
+            -Stdio:($TransportType -eq "Stdio")`
             -BundledModulesPath $BundledModulesPath `
             -EnableConsoleRepl:$EnableConsoleRepl.IsPresent `
             -DebugServiceOnly:$DebugServiceOnly.IsPresent `
@@ -300,11 +316,18 @@ try {
         "debugServiceTransport" = $debugServiceTransport;
     };
 
-    if ($languageServicePipeName) { $resultDetails["languageServicePipeName"] = "$languageServicePipeName" }
-    if ($debugServicePipeName)    { $resultDetails["debugServicePipeName"]    = "$debugServicePipeName" }
-
-    if ($languageServicePort)     { $resultDetails["languageServicePort"]     = $languageServicePort }
-    if ($debugServicePort)        { $resultDetails["debugServicePort"]        = $debugServicePort }
+    if ($LanguageServicePipeName) {
+        $resultDetails["languageServicePipeName"] = Get-NamedPipePath -PipeName $LanguageServicePipeName
+        if ($IsLinux -or $IsMacOS) {
+            Set-NamedPipeMode -PipeFile $resultDetails["languageServicePipeName"]
+        }
+    }
+    if ($DebugServicePipeName) {
+        $resultDetails["debugServicePipeName"] = Get-NamedPipePath -PipeName $DebugServicePipeName
+        if ($IsLinux -or $IsMacOS) {
+            Set-NamedPipeMode -PipeFile $resultDetails["debugServicePipeName"]
+        }
+    }
 
     # Notify the client that the services have started
     WriteSessionFile $resultDetails

src/PowerShellEditorServices.Channel.WebSocket/PowerShellEditorServices.Channel.WebSocket.csproj

@@ -14,7 +14,7 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json">
-      <Version>9.0.1</Version>
+      <Version>10.0.3</Version>
     </PackageReference>
   </ItemGroup>
 

src/PowerShellEditorServices.Host/EditorServicesHost.cs

@@ -31,7 +31,6 @@ public enum EditorServicesHostStatus
 
     public enum EditorServiceTransportType
     {
-        Tcp,
         NamedPipe,
         Stdio
     }
@@ -41,7 +40,6 @@ public class EditorServiceTransportConfig
         public EditorServiceTransportType TransportType { get; set; }
         /// <summary>
         /// Configures the endpoint of the transport.
-        /// For Tcp it's an integer specifying the port.
         /// For Stdio it's ignored.
         /// For NamedPipe it's the pipe name.
         /// </summary>
@@ -75,10 +73,6 @@ public class EditorServicesHost
 
         #region Properties
 
-        public int DebugServicePort { get; private set; }
-
-        public int LanguageServicePort { get; private set; }
-
         public EditorServicesHostStatus Status { get; private set; }
 
         #endregion
@@ -182,11 +176,13 @@ public void StartLogging(string logFilePath, LogLevel logLevel)
         }
 
         /// <summary>
-        /// Starts the language service with the specified TCP socket port.
+        /// Starts the language service with the specified config.
         /// </summary>
-        /// <param name="languageServicePort">The port number for the language service.</param>
-        /// <param name="profilePaths">The object containing the profile paths to load for this session.</param>
-        public void StartLanguageService(EditorServiceTransportConfig config, ProfilePaths profilePaths)
+        /// <param name="config">The config that contains information on the communication protocol that will be used.</param>
+        /// <param name="profilePaths">The profiles that will be loaded in the session.</param>
+        public void StartLanguageService(
+            EditorServiceTransportConfig config,
+            ProfilePaths profilePaths)
         {
             this.profilePaths = profilePaths;
 
@@ -253,9 +249,11 @@ await this.editorSession.PowerShellContext.ImportCommandsModule(
         }
 
         /// <summary>
-        /// Starts the debug service with the specified TCP socket port.
+        /// Starts the debug service with the specified config.
         /// </summary>
-        /// <param name="debugServicePort">The port number for the debug service.</param>
+        /// <param name="config">The config that contains information on the communication protocol that will be used.</param>
+        /// <param name="profilePaths">The profiles that will be loaded in the session.</param>
+        /// <param name="useExistingSession">Determines if we will reuse the session that we have.</param>
         public void StartDebugService(
             EditorServiceTransportConfig config,
             ProfilePaths profilePaths,
@@ -458,11 +456,6 @@ private IServerListener CreateServiceListener(MessageProtocolType protocol, Edit
         {
             switch (config.TransportType)
             {
-                case EditorServiceTransportType.Tcp:
-                {
-                    return new TcpSocketServerListener(protocol, int.Parse(config.Endpoint), this.logger);
-                }
-
                 case EditorServiceTransportType.Stdio:
                 {
                     return new StdioServerListener(protocol, this.logger);

src/PowerShellEditorServices.Host/PowerShellEditorServices.Host.csproj

@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json">
-      <Version>9.0.1</Version>
+      <Version>10.0.3</Version>
     </PackageReference>
     <PackageReference Include="Microsoft.PowerShell.SDK">
       <Version>6.0.0-alpha13</Version>