ab#55565

leefine02 · leefine02 · commit b3b215e89d6d · 2024-04-07T23:56:30.000Z
diff --git a/RemoteFile/RemoteCertificateStore.cs b/RemoteFile/RemoteCertificateStore.cs
@@ -23,6 +23,7 @@
 using Keyfactor.Extensions.Orchestrator.RemoteFile.Models;
 using Keyfactor.Logging;
 using System.Management.Automation;
+using System.Runtime.InteropServices;
 
 namespace Keyfactor.Extensions.Orchestrator.RemoteFile
 {
@@ -332,8 +333,8 @@ internal void Initialize()
         {
             logger.MethodEntry(LogLevel.Debug);
 
-            if (ServerType == ServerTypeEnum.Linux)
-                RemoteHandler = new SSHHandler(Server, ServerId, ServerPassword);
+            if (ServerType == ServerTypeEnum.Linux || RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                RemoteHandler = new SSHHandler(Server, ServerId, ServerPassword, ServerType == ServerTypeEnum.Linux);
             else
                 RemoteHandler = new WinRMHandler(Server, ServerId, ServerPassword);
 
diff --git a/RemoteFile/RemoteFile.csproj b/RemoteFile/RemoteFile.csproj
@@ -6,6 +6,14 @@
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebugType>none</DebugType>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DebugType>none</DebugType>
+  </PropertyGroup>
+
   <ItemGroup>
     <Compile Remove="ImplementedStoreTypes\JKS\JksStore.cs" />
     <Compile Remove="RemoteHandlers\SSHHelper.cs" />
diff --git a/RemoteFile/RemoteHandlers/SSHHandler.cs b/RemoteFile/RemoteHandlers/SSHHandler.cs
@@ -19,77 +19,91 @@
 using Keyfactor.Logging;
 using Keyfactor.PKI.PrivateKeys;
 using Keyfactor.PKI.PEM;
+using System.Runtime.InteropServices;
 
 namespace Keyfactor.Extensions.Orchestrator.RemoteFile.RemoteHandlers
 {
     class SSHHandler : BaseRemoteHandler
     {
         private const string LINUX_PERMISSION_REGEXP = "^[0-7]{3}$";
         private ConnectionInfo Connection { get; set; }
+        private bool RunLocal { get; set; }
+        private bool IsStoreServerLinux { get; set; }
 
         private SshClient sshClient;
 
-        internal SSHHandler(string server, string serverLogin, string serverPassword)
+        internal SSHHandler(string server, string serverLogin, string serverPassword, bool isStoreServerLinux)
         {
             _logger.MethodEntry(LogLevel.Debug);
             
             Server = server;
+            RunLocal = Server.ToLower() == "localhost" || Server.ToLower().EndsWith("|localmachine");
+            IsStoreServerLinux = isStoreServerLinux;
 
-            List<AuthenticationMethod> authenticationMethods = new List<AuthenticationMethod>();
-            if (serverPassword.Length < PASSWORD_LENGTH_MAX)
+            if (!RunLocal)
             {
-                authenticationMethods.Add(new PasswordAuthenticationMethod(serverLogin, serverPassword));
-            }
-            else
-            {
-                PrivateKeyFile privateKeyFile;
-
-                try
+                List<AuthenticationMethod> authenticationMethods = new List<AuthenticationMethod>();
+                if (serverPassword.Length < PASSWORD_LENGTH_MAX)
                 {
-                    using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(FormatRSAPrivateKey(serverPassword))))
-                    {
-                        privateKeyFile = new PrivateKeyFile(ms);
-                    }
+                    authenticationMethods.Add(new PasswordAuthenticationMethod(serverLogin, serverPassword));
                 }
-                catch (Exception ex)
+                else
                 {
-                    using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(ConvertToPKCS1(serverPassword))))
+                    PrivateKeyFile privateKeyFile;
+
+                    try
+                    {
+                        using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(FormatRSAPrivateKey(serverPassword))))
+                        {
+                            privateKeyFile = new PrivateKeyFile(ms);
+                        }
+                    }
+                    catch (Exception ex)
                     {
-                        privateKeyFile = new PrivateKeyFile(ms);
+                        using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(ConvertToPKCS1(serverPassword))))
+                        {
+                            privateKeyFile = new PrivateKeyFile(ms);
+                        }
                     }
+
+                    authenticationMethods.Add(new PrivateKeyAuthenticationMethod(serverLogin, privateKeyFile));
                 }
 
-                authenticationMethods.Add(new PrivateKeyAuthenticationMethod(serverLogin, privateKeyFile));
+                Connection = new ConnectionInfo(server, serverLogin, authenticationMethods.ToArray());
             }
 
-            Connection = new ConnectionInfo(server, serverLogin, authenticationMethods.ToArray());
-            
             _logger.MethodExit(LogLevel.Debug);
         }
 
         public override void Initialize()
         {
             _logger.MethodEntry(LogLevel.Debug);
 
-            try
-            {
-                sshClient = new SshClient(Connection);
-                sshClient.Connect();
-            }
-            catch (Exception ex)
+            if (!RunLocal)
             {
-                throw new RemoteFileException($"Error making a SSH connection to remote server {Connection.Host}, for user {Connection.Username}.  Please contact your company's system administrator to verify connection and permission settings.", ex);
+                try
+                {
+                    sshClient = new SshClient(Connection);
+                    sshClient.Connect();
+                }
+                catch (Exception ex)
+                {
+                    throw new RemoteFileException($"Error making a SSH connection to remote server {Connection.Host}, for user {Connection.Username}.  Please contact your company's system administrator to verify connection and permission settings.", ex);
+                }
             }
-            
+
             _logger.MethodExit(LogLevel.Debug);
         }
 
         public override void Terminate()
         {
             _logger.MethodEntry(LogLevel.Debug);
-            
-            sshClient.Disconnect();
-            sshClient.Dispose();
+
+            if (!RunLocal)
+            {
+                sshClient.Disconnect();
+                sshClient.Dispose();
+            }
             
             _logger.MethodExit(LogLevel.Debug);
         }
@@ -104,10 +118,18 @@ public override string RunCommand(string commandText, object[] arguments, bool w
 
             try
             {
-                if (withSudo)
+                if (withSudo && IsStoreServerLinux)
                     commandText = sudo + commandText;
 
-                commandText = echo + commandText;
+                if (IsStoreServerLinux)
+                {
+                    commandText = echo + commandText;
+                }
+                else
+                {
+                    commandText = "powershell -Command \"" + commandText + "\"";
+                    commandText = commandText.Replace(@"\", @"\\");
+                }
 
                 string displayCommand = commandText;
                 if (passwordsToMaskInLog != null)
@@ -162,7 +184,7 @@ public override void UploadCertificateFile(string path, string fileName, byte[]
 
                         using (MemoryStream stream = new MemoryStream(certBytes))
                         {
-                            client.Upload(stream, FormatFTPPath(uploadPath));
+                            client.Upload(stream, FormatFTPPath(uploadPath, false));
                         }
                     }
                     catch (Exception ex)
@@ -193,7 +215,7 @@ public override void UploadCertificateFile(string path, string fileName, byte[]
 
                         using (MemoryStream stream = new MemoryStream(certBytes))
                         {
-                            client.UploadFile(stream, FormatFTPPath(uploadPath));
+                            client.UploadFile(stream, FormatFTPPath(uploadPath, !IsStoreServerLinux));
                         }
                     }
                     catch (Exception ex)
@@ -209,7 +231,7 @@ public override void UploadCertificateFile(string path, string fileName, byte[]
                 }
             }
 
-            if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath))
+            if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath) && IsStoreServerLinux)
             {
                 //RunCommand($"cat {uploadPath} > {path}/{fileName}", null, ApplicationSettings.UseSudo, null);
                 RunCommand($"tee {path}/{fileName} < {uploadPath} > /dev/null", null, ApplicationSettings.UseSudo, null);
@@ -230,7 +252,7 @@ public override byte[] DownloadCertificateFile(string path)
             string altPathOnly = string.Empty;
             string altFileNameOnly = string.Empty;
 
-            if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath))
+            if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath) && IsStoreServerLinux)
             {
                 SplitStorePathFile(path, out altPathOnly, out altFileNameOnly);
                 downloadPath = ApplicationSettings.SeparateUploadFilePath + altFileNameOnly;
@@ -251,7 +273,7 @@ public override byte[] DownloadCertificateFile(string path)
 
                         using (MemoryStream stream = new MemoryStream())
                         {
-                            client.Download(FormatFTPPath(downloadPath), stream);
+                            client.Download(FormatFTPPath(downloadPath, false), stream);
                             rtnStore = stream.ToArray();
                         }
                     }
@@ -283,7 +305,7 @@ public override byte[] DownloadCertificateFile(string path)
 
                         using (MemoryStream stream = new MemoryStream())
                         {
-                            client.DownloadFile(FormatFTPPath(downloadPath), stream);
+                            client.DownloadFile(FormatFTPPath(downloadPath, !IsStoreServerLinux), stream);
                             rtnStore = stream.ToArray();
                         }
                     }
@@ -300,7 +322,7 @@ public override byte[] DownloadCertificateFile(string path)
                 }
             }
 
-            if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath))
+            if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath) && IsStoreServerLinux)
             {
                 RunCommand($"rm {downloadPath}", null, ApplicationSettings.UseSudo, null);
             }
@@ -322,8 +344,13 @@ public override void CreateEmptyStoreFile(string path, string linuxFilePermissio
                 linuxFileGroup = linuxGroupOwner[1];
             }
 
-            AreLinuxPermissionsValid(linuxFilePermissions);
-            RunCommand($"install -m {linuxFilePermissions} -o {linuxFileOwner} -g {linuxFileGroup} /dev/null {path}", null, ApplicationSettings.UseSudo, null);
+            if (IsStoreServerLinux)
+            {
+                AreLinuxPermissionsValid(linuxFilePermissions);
+                RunCommand($"install -m {linuxFilePermissions} -o {linuxFileOwner} -g {linuxFileGroup} /dev/null {path}", null, ApplicationSettings.UseSudo, null);
+            }
+            else
+                RunCommand($@"Out-File -FilePath ""{path}""", null, false, null);
 
             _logger.MethodExit(LogLevel.Debug);
         }
@@ -332,14 +359,15 @@ public override bool DoesFileExist(string path)
         {
             _logger.MethodEntry(LogLevel.Debug);
             _logger.LogDebug($"DoesFileExist: {path}");
-
+            
             using (SftpClient client = new SftpClient(Connection))
             {
                 try
                 {
                     client.Connect();
-                    string existsPath = FormatFTPPath(path);
+                    string existsPath = FormatFTPPath(path, false);
                     bool exists = client.Exists(existsPath);
+                    _logger.LogDebug(existsPath);
 
                     _logger.MethodExit(LogLevel.Debug);
 
@@ -406,12 +434,14 @@ private string ConvertToPKCS1(string privateKey)
             return pemString.Replace("PRIVATE", "RSA PRIVATE");
         }
 
-        private string FormatFTPPath(string path)
+        private string FormatFTPPath(string path, bool addLeadingSlashForWindows)
         {
             _logger.MethodEntry(LogLevel.Debug);
             _logger.MethodExit(LogLevel.Debug);
 
-            return path.Substring(0, 1) == @"/" ? path : @"/" + path.Replace("\\", "/");
+            string rtnPath = IsStoreServerLinux ? path : path.Replace("\\", "/");
+            _logger.LogTrace($"Formatted path: {rtnPath}");
+            return addLeadingSlashForWindows ? rtnPath : "/" + rtnPath;
         }
     }
 }
diff --git a/RemoteFile/RemoteHandlers/WinRMHandler.cs b/RemoteFile/RemoteHandlers/WinRMHandler.cs
@@ -26,13 +26,16 @@ class WinRMHandler : BaseRemoteHandler
 
         private Runspace runspace { get; set; }
         private WSManConnectionInfo connectionInfo { get; set; }
+        private bool RunLocal { get; set; }
 
         internal WinRMHandler(string server, string serverLogin, string serverPassword)
         {
             _logger.MethodEntry(LogLevel.Debug);
 
             Server = server;
-            if (Server.ToLower() != "localhost")
+            RunLocal = Server.ToLower() == "localhost" || Server.ToLower().EndsWith("|localmachine");
+
+            if (!RunLocal)
             {
                 connectionInfo = new WSManConnectionInfo(new System.Uri($"{Server}/wsman"));
                 if (!string.IsNullOrEmpty(serverLogin))
@@ -50,7 +53,7 @@ public override void Initialize()
 
             try
             {
-                if (Server.ToLower() == "localhost")
+                if (RunLocal)
                 {
                     runspace = RunspaceFactory.CreateRunspace();
                 }

Original file line number	Diff line number	Diff line change
`@@ -19,77 +19,91 @@`
`19`	`19`	`using Keyfactor.Logging;`
`20`	`20`	`using Keyfactor.PKI.PrivateKeys;`
`21`	`21`	`using Keyfactor.PKI.PEM;`
	`22`	`+using System.Runtime.InteropServices;`
`22`	`23`
`23`	`24`	`namespace Keyfactor.Extensions.Orchestrator.RemoteFile.RemoteHandlers`
`24`	`25`	`{`
`25`	`26`	`class SSHHandler : BaseRemoteHandler`
`26`	`27`	`{`
`27`	`28`	`private const string LINUX_PERMISSION_REGEXP = "^[0-7]{3}$";`
`28`	`29`	`private ConnectionInfo Connection { get; set; }`
	`30`	`+ private bool RunLocal { get; set; }`
	`31`	`+ private bool IsStoreServerLinux { get; set; }`
`29`	`32`
`30`	`33`	`private SshClient sshClient;`
`31`	`34`
`32`		`- internal SSHHandler(string server, string serverLogin, string serverPassword)`
	`35`	`+ internal SSHHandler(string server, string serverLogin, string serverPassword, bool isStoreServerLinux)`
`33`	`36`	`{`
`34`	`37`	`_logger.MethodEntry(LogLevel.Debug);`
`35`	`38`
`36`	`39`	`Server = server;`
	`40`	`+ RunLocal = Server.ToLower() == "localhost" \|\| Server.ToLower().EndsWith("\|localmachine");`
	`41`	`+ IsStoreServerLinux = isStoreServerLinux;`
`37`	`42`
`38`		`- List<AuthenticationMethod> authenticationMethods = new List<AuthenticationMethod>();`
`39`		`- if (serverPassword.Length < PASSWORD_LENGTH_MAX)`
	`43`	`+ if (!RunLocal)`
`40`	`44`	`{`
`41`		`- authenticationMethods.Add(new PasswordAuthenticationMethod(serverLogin, serverPassword));`
`42`		`- }`
`43`		`- else`
`44`		`- {`
`45`		`- PrivateKeyFile privateKeyFile;`
`46`		`-`
`47`		`- try`
	`45`	`+ List<AuthenticationMethod> authenticationMethods = new List<AuthenticationMethod>();`
	`46`	`+ if (serverPassword.Length < PASSWORD_LENGTH_MAX)`
`48`	`47`	`{`
`49`		`- using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(FormatRSAPrivateKey(serverPassword))))`
`50`		`- {`
`51`		`- privateKeyFile = new PrivateKeyFile(ms);`
`52`		`- }`
	`48`	`+ authenticationMethods.Add(new PasswordAuthenticationMethod(serverLogin, serverPassword));`
`53`	`49`	`}`
`54`		`- catch (Exception ex)`
	`50`	`+ else`
`55`	`51`	`{`
`56`		`- using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(ConvertToPKCS1(serverPassword))))`
	`52`	`+ PrivateKeyFile privateKeyFile;`
	`53`	`+`
	`54`	`+ try`
	`55`	`+ {`
	`56`	`+ using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(FormatRSAPrivateKey(serverPassword))))`
	`57`	`+ {`
	`58`	`+ privateKeyFile = new PrivateKeyFile(ms);`
	`59`	`+ }`
	`60`	`+ }`
	`61`	`+ catch (Exception ex)`
`57`	`62`	`{`
`58`		`- privateKeyFile = new PrivateKeyFile(ms);`
	`63`	`+ using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(ConvertToPKCS1(serverPassword))))`
	`64`	`+ {`
	`65`	`+ privateKeyFile = new PrivateKeyFile(ms);`
	`66`	`+ }`
`59`	`67`	`}`
	`68`	`+`
	`69`	`+ authenticationMethods.Add(new PrivateKeyAuthenticationMethod(serverLogin, privateKeyFile));`
`60`	`70`	`}`
`61`	`71`
`62`		`- authenticationMethods.Add(new PrivateKeyAuthenticationMethod(serverLogin, privateKeyFile));`
	`72`	`+ Connection = new ConnectionInfo(server, serverLogin, authenticationMethods.ToArray());`
`63`	`73`	`}`
`64`	`74`
`65`		`- Connection = new ConnectionInfo(server, serverLogin, authenticationMethods.ToArray());`
`66`		`-`
`67`	`75`	`_logger.MethodExit(LogLevel.Debug);`
`68`	`76`	`}`
`69`	`77`
`70`	`78`	`public override void Initialize()`
`71`	`79`	`{`
`72`	`80`	`_logger.MethodEntry(LogLevel.Debug);`
`73`	`81`
`74`		`- try`
`75`		`- {`
`76`		`- sshClient = new SshClient(Connection);`
`77`		`- sshClient.Connect();`
`78`		`- }`
`79`		`- catch (Exception ex)`
	`82`	`+ if (!RunLocal)`
`80`	`83`	`{`
`81`		`- throw new RemoteFileException($"Error making a SSH connection to remote server {Connection.Host}, for user {Connection.Username}. Please contact your company's system administrator to verify connection and permission settings.", ex);`
	`84`	`+ try`
	`85`	`+ {`
	`86`	`+ sshClient = new SshClient(Connection);`
	`87`	`+ sshClient.Connect();`
	`88`	`+ }`
	`89`	`+ catch (Exception ex)`
	`90`	`+ {`
	`91`	`+ throw new RemoteFileException($"Error making a SSH connection to remote server {Connection.Host}, for user {Connection.Username}. Please contact your company's system administrator to verify connection and permission settings.", ex);`
	`92`	`+ }`
`82`	`93`	`}`
`83`		`-`
	`94`	`+`
`84`	`95`	`_logger.MethodExit(LogLevel.Debug);`
`85`	`96`	`}`
`86`	`97`
`87`	`98`	`public override void Terminate()`
`88`	`99`	`{`
`89`	`100`	`_logger.MethodEntry(LogLevel.Debug);`
`90`		`-`
`91`		`- sshClient.Disconnect();`
`92`		`- sshClient.Dispose();`
	`101`	`+`
	`102`	`+ if (!RunLocal)`
	`103`	`+ {`
	`104`	`+ sshClient.Disconnect();`
	`105`	`+ sshClient.Dispose();`
	`106`	`+ }`
`93`	`107`
`94`	`108`	`_logger.MethodExit(LogLevel.Debug);`
`95`	`109`	`}`
`@@ -104,10 +118,18 @@ public override string RunCommand(string commandText, object[] arguments, bool w`
`104`	`118`
`105`	`119`	`try`
`106`	`120`	`{`
`107`		`- if (withSudo)`
	`121`	`+ if (withSudo && IsStoreServerLinux)`
`108`	`122`	`commandText = sudo + commandText;`
`109`	`123`
`110`		`- commandText = echo + commandText;`
	`124`	`+ if (IsStoreServerLinux)`
	`125`	`+ {`
	`126`	`+ commandText = echo + commandText;`
	`127`	`+ }`
	`128`	`+ else`
	`129`	`+ {`
	`130`	`+ commandText = "powershell -Command \"" + commandText + "\"";`
	`131`	`+ commandText = commandText.Replace(@"\", @"\\");`
	`132`	`+ }`
`111`	`133`
`112`	`134`	`string displayCommand = commandText;`
`113`	`135`	`if (passwordsToMaskInLog != null)`
`@@ -162,7 +184,7 @@ public override void UploadCertificateFile(string path, string fileName, byte[]`
`162`	`184`
`163`	`185`	`using (MemoryStream stream = new MemoryStream(certBytes))`
`164`	`186`	`{`
`165`		`- client.Upload(stream, FormatFTPPath(uploadPath));`
	`187`	`+ client.Upload(stream, FormatFTPPath(uploadPath, false));`
`166`	`188`	`}`
`167`	`189`	`}`
`168`	`190`	`catch (Exception ex)`
`@@ -193,7 +215,7 @@ public override void UploadCertificateFile(string path, string fileName, byte[]`
`193`	`215`
`194`	`216`	`using (MemoryStream stream = new MemoryStream(certBytes))`
`195`	`217`	`{`
`196`		`- client.UploadFile(stream, FormatFTPPath(uploadPath));`
	`218`	`+ client.UploadFile(stream, FormatFTPPath(uploadPath, !IsStoreServerLinux));`
`197`	`219`	`}`
`198`	`220`	`}`
`199`	`221`	`catch (Exception ex)`
`@@ -209,7 +231,7 @@ public override void UploadCertificateFile(string path, string fileName, byte[]`
`209`	`231`	`}`
`210`	`232`	`}`
`211`	`233`
`212`		`- if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath))`
	`234`	`+ if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath) && IsStoreServerLinux)`
`213`	`235`	`{`
`214`	`236`	`//RunCommand($"cat {uploadPath} > {path}/{fileName}", null, ApplicationSettings.UseSudo, null);`
`215`	`237`	`RunCommand($"tee {path}/{fileName} < {uploadPath} > /dev/null", null, ApplicationSettings.UseSudo, null);`
`@@ -230,7 +252,7 @@ public override byte[] DownloadCertificateFile(string path)`
`230`	`252`	`string altPathOnly = string.Empty;`
`231`	`253`	`string altFileNameOnly = string.Empty;`
`232`	`254`
`233`		`- if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath))`
	`255`	`+ if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath) && IsStoreServerLinux)`
`234`	`256`	`{`
`235`	`257`	`SplitStorePathFile(path, out altPathOnly, out altFileNameOnly);`
`236`	`258`	`downloadPath = ApplicationSettings.SeparateUploadFilePath + altFileNameOnly;`
`@@ -251,7 +273,7 @@ public override byte[] DownloadCertificateFile(string path)`
`251`	`273`
`252`	`274`	`using (MemoryStream stream = new MemoryStream())`
`253`	`275`	`{`
`254`		`- client.Download(FormatFTPPath(downloadPath), stream);`
	`276`	`+ client.Download(FormatFTPPath(downloadPath, false), stream);`
`255`	`277`	`rtnStore = stream.ToArray();`
`256`	`278`	`}`
`257`	`279`	`}`
`@@ -283,7 +305,7 @@ public override byte[] DownloadCertificateFile(string path)`
`283`	`305`
`284`	`306`	`using (MemoryStream stream = new MemoryStream())`
`285`	`307`	`{`
`286`		`- client.DownloadFile(FormatFTPPath(downloadPath), stream);`
	`308`	`+ client.DownloadFile(FormatFTPPath(downloadPath, !IsStoreServerLinux), stream);`
`287`	`309`	`rtnStore = stream.ToArray();`
`288`	`310`	`}`
`289`	`311`	`}`
`@@ -300,7 +322,7 @@ public override byte[] DownloadCertificateFile(string path)`
`300`	`322`	`}`
`301`	`323`	`}`
`302`	`324`
`303`		`- if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath))`
	`325`	`+ if (!string.IsNullOrEmpty(ApplicationSettings.SeparateUploadFilePath) && IsStoreServerLinux)`
`304`	`326`	`{`
`305`	`327`	`RunCommand($"rm {downloadPath}", null, ApplicationSettings.UseSudo, null);`
`306`	`328`	`}`
`@@ -322,8 +344,13 @@ public override void CreateEmptyStoreFile(string path, string linuxFilePermissio`
`322`	`344`	`linuxFileGroup = linuxGroupOwner[1];`
`323`	`345`	`}`
`324`	`346`
`325`		`- AreLinuxPermissionsValid(linuxFilePermissions);`
`326`		`- RunCommand($"install -m {linuxFilePermissions} -o {linuxFileOwner} -g {linuxFileGroup} /dev/null {path}", null, ApplicationSettings.UseSudo, null);`
	`347`	`+ if (IsStoreServerLinux)`
	`348`	`+ {`
	`349`	`+ AreLinuxPermissionsValid(linuxFilePermissions);`
	`350`	`+ RunCommand($"install -m {linuxFilePermissions} -o {linuxFileOwner} -g {linuxFileGroup} /dev/null {path}", null, ApplicationSettings.UseSudo, null);`
	`351`	`+ }`
	`352`	`+ else`
	`353`	`+ RunCommand($@"Out-File -FilePath ""{path}""", null, false, null);`
`327`	`354`
`328`	`355`	`_logger.MethodExit(LogLevel.Debug);`
`329`	`356`	`}`
`@@ -332,14 +359,15 @@ public override bool DoesFileExist(string path)`
`332`	`359`	`{`
`333`	`360`	`_logger.MethodEntry(LogLevel.Debug);`
`334`	`361`	`_logger.LogDebug($"DoesFileExist: {path}");`
`335`		`-`
	`362`	`+`
`336`	`363`	`using (SftpClient client = new SftpClient(Connection))`
`337`	`364`	`{`
`338`	`365`	`try`
`339`	`366`	`{`
`340`	`367`	`client.Connect();`
`341`		`- string existsPath = FormatFTPPath(path);`
	`368`	`+ string existsPath = FormatFTPPath(path, false);`
`342`	`369`	`bool exists = client.Exists(existsPath);`
	`370`	`+ _logger.LogDebug(existsPath);`
`343`	`371`
`344`	`372`	`_logger.MethodExit(LogLevel.Debug);`
`345`	`373`
`@@ -406,12 +434,14 @@ private string ConvertToPKCS1(string privateKey)`
`406`	`434`	`return pemString.Replace("PRIVATE", "RSA PRIVATE");`
`407`	`435`	`}`
`408`	`436`
`409`		`- private string FormatFTPPath(string path)`
	`437`	`+ private string FormatFTPPath(string path, bool addLeadingSlashForWindows)`
`410`	`438`	`{`
`411`	`439`	`_logger.MethodEntry(LogLevel.Debug);`
`412`	`440`	`_logger.MethodExit(LogLevel.Debug);`
`413`	`441`
`414`		`- return path.Substring(0, 1) == @"/" ? path : @"/" + path.Replace("\\", "/");`
	`442`	`+ string rtnPath = IsStoreServerLinux ? path : path.Replace("\\", "/");`
	`443`	`+ _logger.LogTrace($"Formatted path: {rtnPath}");`
	`444`	`+ return addLeadingSlashForWindows ? rtnPath : "/" + rtnPath;`
`415`	`445`	`}`
`416`	`446`	`}`
`417`	`447`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,13 +26,16 @@ class WinRMHandler : BaseRemoteHandler`
`26`	`26`
`27`	`27`	`private Runspace runspace { get; set; }`
`28`	`28`	`private WSManConnectionInfo connectionInfo { get; set; }`
	`29`	`+ private bool RunLocal { get; set; }`
`29`	`30`
`30`	`31`	`internal WinRMHandler(string server, string serverLogin, string serverPassword)`
`31`	`32`	`{`
`32`	`33`	`_logger.MethodEntry(LogLevel.Debug);`
`33`	`34`
`34`	`35`	`Server = server;`
`35`		`- if (Server.ToLower() != "localhost")`
	`36`	`+ RunLocal = Server.ToLower() == "localhost" \|\| Server.ToLower().EndsWith("\|localmachine");`
	`37`	`+`
	`38`	`+ if (!RunLocal)`
`36`	`39`	`{`
`37`	`40`	`connectionInfo = new WSManConnectionInfo(new System.Uri($"{Server}/wsman"));`
`38`	`41`	`if (!string.IsNullOrEmpty(serverLogin))`
`@@ -50,7 +53,7 @@ public override void Initialize()`
`50`	`53`
`51`	`54`	`try`
`52`	`55`	`{`
`53`		`- if (Server.ToLower() == "localhost")`
	`56`	`+ if (RunLocal)`
`54`	`57`	`{`
`55`	`58`	`runspace = RunspaceFactory.CreateRunspace();`
`56`	`59`	`}`