public static void CopyFileFromRemoteToLocal(string host, string user, string password, string localPath, string remotePath) { using (SftpClient client = new SftpClient(host, user, password)) { client.KeepAliveInterval = TimeSpan.FromSeconds(60); client.ConnectionInfo.Timeout = TimeSpan.FromMinutes(180); client.OperationTimeout = TimeSpan.FromMinutes(180); client.Connect(); bool connected = client.IsConnected; // RunCommand(host, user, password, "sudo chmod 777 -R " + remotePath); var file = File.OpenWrite(localPath); client.DownloadFile(remotePath, file); file.Close(); client.Disconnect(); } }
public bool UploadFile(string filePath) { ConnectionInfo connectionInfo = new PasswordConnectionInfo(_address, ConstFields.SFTP_PORT, _username, _password); try { using (var sftp = new SftpClient(connectionInfo)) { sftp.Connect(); using (var file = File.OpenRead(filePath)) { if (!sftp.Exists(ConstFields.TEMP_PRINT_DIRECTORY)) { sftp.CreateDirectory(ConstFields.TEMP_PRINT_DIRECTORY); } sftp.ChangeDirectory(ConstFields.TEMP_PRINT_DIRECTORY); string filename = Path.GetFileName(filePath); sftp.UploadFile(file, filename); } sftp.Disconnect(); } } catch (Renci.SshNet.Common.SshConnectionException) { Console.WriteLine("Cannot connect to the server."); return false; } catch (System.Net.Sockets.SocketException) { Console.WriteLine("Unable to establish the socket."); return false; } catch (Renci.SshNet.Common.SshAuthenticationException) { Console.WriteLine("Authentication of SSH session failed."); return false; } return true; }
private void PollHandler() { var exchange = new Exchange(_processor.Route); var ipaddress = _processor.UriInformation.GetUriProperty("host"); var username = _processor.UriInformation.GetUriProperty("username"); var password = _processor.UriInformation.GetUriProperty("password"); var destination = _processor.UriInformation.GetUriProperty("destination"); var port = _processor.UriInformation.GetUriProperty<int>("port"); var interval = _processor.UriInformation.GetUriProperty<int>("interval", 100); var secure = _processor.UriInformation.GetUriProperty<bool>("secure"); do { Thread.Sleep(interval); try { if (secure) { SftpClient sftp = null; sftp = new SftpClient(ipaddress, port, username, password); sftp.Connect(); foreach (var ftpfile in sftp.ListDirectory(".")) { var destinationFile = Path.Combine(destination, ftpfile.Name); using (var fs = new FileStream(destinationFile, FileMode.Create)) { var data = sftp.ReadAllText(ftpfile.FullName); exchange.InMessage.Body = data; if (!string.IsNullOrEmpty(data)) { sftp.DownloadFile(ftpfile.FullName, fs); } } } } else { ReadFtp(exchange); } } catch (Exception exception) { var msg = exception.Message; } } while (true); }
private void sendSFTP(string filePath, string fileName) { SftpClient sftp = new SftpClient("194.2.93.194", "userece", "AdminPOCNUC01"); sftp.Connect(); using (FileStream filestream = File.OpenRead(filePath)) { sftp.UploadFile(filestream, "/"+fileName, null); sftp.Disconnect(); } }
public bool TryGetFileFromFtp(string fileName, DateTime lastUpdated) { if (!DirectoryUtil.VerifyDirectory(fileName)) { return false; } var fileToDownload = fileName; Log.Debug(string.Format("Attempting to download file " + fileToDownload)); try { Log.Debug("Opening FTP Connection to " + Hostname); using (var client = new SftpClient(Hostname, Username, Password)) { client.Connect(); Log.Debug(string.Format("Connection to {0} opened.", Hostname)); var fileUpdated = client.GetLastWriteTime(fileName); Log.Debug(string.Format("File {0} was last modified on {1}.", fileName, DateUtil.ToIsoDate(fileUpdated))); if (fileUpdated <= lastUpdated) { Log.Info(string.Format("Did not download file {0}, it was last modified {1} and we last processed it on {2}.", fileName, DateUtil.ToIsoDate(fileUpdated), DateUtil.ToIsoDate(lastUpdated)), this); return false; } var outputPath = string.Format("{0}\\{1}", UserCsvImportSettings.CsvFolderPath, fileName); Log.Debug(string.Format("Downloading file {0} and saving to path {1}.", fileName, outputPath)); using (var fileStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write)) { client.DownloadFile(fileName, fileStream); Log.Debug("File successfully written to " + fileStream.Name); } Log.Debug("File Download complete."); Log.Debug("Updating timestamp."); File.SetLastWriteTime(outputPath, fileUpdated); Log.Debug("File timestamp set to " + fileUpdated.ToString()); } } catch (Exception e) { Log.Error("File did not download successfully.", this); Log.Error(string.Format("Could not download file {0} from {1} using user {2}.", fileToDownload, Hostname, Username), e, this); return false; } return true; }
public static IEnumerable<SftpFile> GetList(string host, string folder, string userName, string password) { using (var sftp = new SftpClient(host, userName, password)) { sftp.ErrorOccurred += Sftp_ErrorOccurred; sftp.Connect(); var toReturn = sftp.ListDirectory(folder).ToList(); sftp.Disconnect(); return toReturn; } }
protected override void ProcessRecord() { if (keyfile.Equals("")) { //########################################### //### Connect using Username and Password ### //########################################### ConnectionInfo connectInfo; var KIconnectInfo = new KeyboardInteractiveAuthenticationMethod(credential.GetNetworkCredential().UserName); foreach (var computer in computername) { if (proxyserver != "") { // Set the proper proxy type var ptype = Renci.SshNet.ProxyTypes.Http; WriteVerbose("A Proxy Server has been specified"); switch (proxytype) { case "HTTP": ptype = Renci.SshNet.ProxyTypes.Http; break; case "Socks4": ptype = Renci.SshNet.ProxyTypes.Socks4; break; case "Socks5": ptype = Renci.SshNet.ProxyTypes.Socks5; break; } var PassconnectInfo = new PasswordAuthenticationMethod(credential.GetNetworkCredential().UserName, credential.GetNetworkCredential().Password); WriteVerbose("Connecting to " + computer + " with user " + credential.GetNetworkCredential().UserName); connectInfo = new ConnectionInfo(computer, port, credential.GetNetworkCredential().UserName, ptype, proxyserver, proxyport, proxycredential.GetNetworkCredential().UserName, proxycredential.GetNetworkCredential().Password, KIconnectInfo, PassconnectInfo); } else { WriteVerbose("Using Username and Password authentication for connection."); // Connection info for Keyboard Interactive var PassconnectInfo = new PasswordAuthenticationMethod(credential.GetNetworkCredential().UserName, credential.GetNetworkCredential().Password); WriteVerbose("Connecting to " + computer + " with user " + credential.GetNetworkCredential().UserName); connectInfo = new Renci.SshNet.ConnectionInfo(computer, credential.GetNetworkCredential().UserName, PassconnectInfo, KIconnectInfo); } // Event Handler for interactive Authentication KIconnectInfo.AuthenticationPrompt += delegate(object sender, AuthenticationPromptEventArgs e) { foreach (var prompt in e.Prompts) { if (prompt.Request.Contains("Password")) prompt.Response = credential.GetNetworkCredential().Password; } }; try { //Ceate instance of SFTP Client with connection info var Client = new SftpClient(connectInfo); // Handle host key Client.HostKeyReceived += delegate(object sender, HostKeyEventArgs e) { var sb = new StringBuilder(); foreach (var b in e.FingerPrint) { sb.AppendFormat("{0:x}:", b); } string FingerPrint = sb.ToString().Remove(sb.ToString().Length - 1); // this.Host.UI.WriteVerboseLine("Key algorithm of " + Client.ConnectionInfo.CurrentHostKeyAlgorithm); //this.Host.UI.WriteVerboseLine("Key exchange alhorithm " + Client.ConnectionInfo.CurrentKeyExchangeAlgorithm); //this.Host.UI.WriteVerboseLine("Host key fingerprint: " + FingerPrint); if (SSHHostKeys.ContainsKey(computer)) { if (SSHHostKeys[computer] == FingerPrint) { //this.Host.UI.WriteVerboseLine("Fingerprint matched trusted fingerpring for host " + computer); e.CanTrust = true; } else { throw new System.Security.SecurityException("SSH fingerprint mistmatch for host " + computer); } } else { int choice; if (acceptkey) { choice = 0; } else { Collection<ChoiceDescription> choices = new Collection<ChoiceDescription>(); choices.Add(new ChoiceDescription("Y")); choices.Add(new ChoiceDescription("N")); choice = this.Host.UI.PromptForChoice("Server SSH Fingerprint", "Do you want to trust the fingerprint " + FingerPrint, choices, 1); } if (choice == 0) { var keymng = new TrustedKeyMng(); //this.Host.UI.WriteVerboseLine("Saving fingerprint " + FingerPrint + " for host " + computer); keymng.SetKey(computer, FingerPrint); e.CanTrust = true; } else { e.CanTrust = false; } } }; // Set the connection timeout Client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(connectiontimeout); // Set Keepalive for connections Client.KeepAliveInterval = TimeSpan.FromSeconds(keepaliveinterval); // Connect to host using Connection info Client.Connect(); WriteObject(SSHModHelper.AddToSFTPSessionCollection(Client, this.SessionState), true); } catch (Exception ex) { throw ex; } } } else { //########################## //### Connect using Keys ### //########################## WriteVerbose("Using SSH Key authentication for connection."); var fullPath = Path.GetFullPath(keyfile); if (File.Exists(fullPath)) { foreach (var computer in computername) { PrivateKeyConnectionInfo connectionInfo; if (proxyserver != "") { // Set the proper proxy type var ptype = Renci.SshNet.ProxyTypes.Http; WriteVerbose("A Proxy Server has been specified"); switch (proxytype) { case "HTTP": ptype = Renci.SshNet.ProxyTypes.Http; break; case "Socks4": ptype = Renci.SshNet.ProxyTypes.Socks4; break; case "Socks5": ptype = Renci.SshNet.ProxyTypes.Socks5; break; } if (credential.GetNetworkCredential().Password == "") { WriteVerbose("Using key with no passphrase."); var sshkey = new PrivateKeyFile(File.OpenRead(@fullPath)); connectionInfo = new PrivateKeyConnectionInfo(computer, credential.GetNetworkCredential().UserName, sshkey); } else { WriteVerbose("Using key with passphrase."); var sshkey = new PrivateKeyFile(File.OpenRead(@fullPath), credential.GetNetworkCredential().Password); if (proxycredential.UserName == "") { connectionInfo = new PrivateKeyConnectionInfo(computer, credential.GetNetworkCredential().UserName, ptype, proxyserver, proxyport, sshkey); } else { connectionInfo = new PrivateKeyConnectionInfo(computer, credential.GetNetworkCredential().UserName, ptype, proxyserver, proxyport, proxycredential.GetNetworkCredential().UserName, proxycredential.GetNetworkCredential().Password, sshkey); } } } else { WriteVerbose("Using SSH Key authentication for connection."); if (credential.GetNetworkCredential().Password == "") { WriteVerbose("Using key with no passphrase."); var sshkey = new PrivateKeyFile(File.OpenRead(@fullPath)); connectionInfo = new PrivateKeyConnectionInfo(computer, credential.GetNetworkCredential().UserName, sshkey); } else { WriteVerbose("Using key with passphrase."); var sshkey = new PrivateKeyFile(File.OpenRead(@fullPath), credential.GetNetworkCredential().Password); connectionInfo = new PrivateKeyConnectionInfo(computer, credential.GetNetworkCredential().UserName, sshkey); } } try { //Ceate instance of SSH Client with connection info var Client = new SftpClient(connectionInfo); // Handle host key Client.HostKeyReceived += delegate(object sender, HostKeyEventArgs e) { var sb = new StringBuilder(); foreach (var b in e.FingerPrint) { sb.AppendFormat("{0:x}:", b); } string FingerPrint = sb.ToString().Remove(sb.ToString().Length - 1); //this.Host.UI.WriteVerboseLine("Key algorithm of " + Client.ConnectionInfo.CurrentHostKeyAlgorithm); //this.Host.UI.WriteVerboseLine("Key exchange alhorithm " + Client.ConnectionInfo.CurrentKeyExchangeAlgorithm); //this.Host.UI.WriteVerboseLine("Host key fingerprint: " + FingerPrint); if (SSHHostKeys.ContainsKey(computer)) { if (SSHHostKeys[computer] == FingerPrint) { //this.Host.UI.WriteVerboseLine("Fingerprint matched trusted fingerpring for host " + computer); e.CanTrust = true; } else { throw new System.Security.SecurityException("SSH fingerprint mistmatch for host " + computer); } } else { int choice; if (acceptkey) { choice = 0; } else { Collection<ChoiceDescription> choices = new Collection<ChoiceDescription>(); choices.Add(new ChoiceDescription("Y")); choices.Add(new ChoiceDescription("N")); choice = this.Host.UI.PromptForChoice("Server SSH Fingerprint", "Do you want to trust the fingerprint " + FingerPrint, choices, 1); } if (choice == 0) { var keymng = new TrustedKeyMng(); //this.Host.UI.WriteVerboseLine("Saving fingerprint " + FingerPrint + " for host " + computer); keymng.SetKey(computer, FingerPrint); e.CanTrust = true; } else { e.CanTrust = false; } } }; // Set the connection timeout Client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(connectiontimeout); // Connect to host using Connection info Client.Connect(); WriteObject(SSHModHelper.AddToSFTPSessionCollection(Client, this.SessionState), true); } catch (Exception ex) { throw ex; } } // for each computer } // file exists else { throw new System.IO.FileNotFoundException("Key file " + fullPath + " was not found."); } } // End process record }
private async Task _ensureConnected(CancellationToken ctk) { if (!_client.IsConnected) { await Task.Run(() => _client.Connect(), ctk); } }
private async Task DownloadFilesWithSftpAsync(Endpoint endpoint, string decodedPass) { var client = new SftpClient(endpoint.Url, endpoint.Username, decodedPass); client.Connect(); SftpFile[] filesOnServer = (await this.ListRemoteDirectoriesAsync(client, endpoint.RemoteDirectory)).Where( x => !this.excludedListOfFiles.Any(y => x.Name.Equals(y))).ToArray(); var primaryLocalDirectory = endpoint.Destinations.FirstOrDefault(x => x.Type == DestinationType.Primary); var archiveLocalDirectory = endpoint.Destinations.FirstOrDefault(x => x.Type == DestinationType.Archive); var primaryAndArchiveAreNotExisting = primaryLocalDirectory == null || archiveLocalDirectory == null; if (primaryAndArchiveAreNotExisting) { progress.ReportLine("You haven't provided the primary or archive folder"); return; } var filteredLocalFiles = FilterLocalFiles(filesOnServer, GetFilesListInFolder(primaryLocalDirectory.Name)); await this.GetFilesAsync(filteredLocalFiles, endpoint.RemoteDirectory, primaryLocalDirectory.Name, client).ContinueWith(x => client.Disconnect()); this.ArchiveFiles(GetFilesListInFolder(primaryLocalDirectory.Name), primaryLocalDirectory, archiveLocalDirectory); }
/// <summary> /// List all entries of a folder. /// </summary> /// <param name="path">The folder path to list</param> /// <param name="ctk"></param> /// <returns> /// All entries found (files, folders, symlinks) /// </returns> public async Task <IEnumerable <FtpEntry> > ListDirectoryAsync(string path = "./", CancellationToken ctk = default(CancellationToken)) { await Task.Yield(); var ftpPath = path.GetFtpPath(); _logger.Trace("Listing directory: {0} -> {1}", path, ftpPath); using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5))) using (var linked = CancellationTokenSource.CreateLinkedTokenSource(ctk, cts.Token)) { var result = new List <FtpEntry>(); using (var sFtpClient = new Renci.SshNet.SftpClient(new ConnectionInfo(Host, Port, Credentials.UserName, new PasswordAuthenticationMethod(Credentials.UserName, Credentials.Password)))) { sFtpClient.Connect(); var rawLs = await sFtpClient.ListDirectoryAsync(path); _logger.Trace("Starting parsing response for path {0}", path); result = _parse(rawLs, linked.Token); } linked.Token.ThrowIfCancellationRequested(); return(result); } }
public SshFactory(String host, String username, String password) { _connection = new SshClient(host, username, password); _connection.Connect(); _sftp = new SftpClient(_connection.ConnectionInfo); _sftp.Connect(); }
private void checkFingerpint(ConnectionInfo con, string knownHostsPath) { _knownHosts = new KnownHostStore(knownHostsPath); using (Renci.SshNet.SftpClient client1 = new Renci.SshNet.SftpClient(con)) { client1.HostKeyReceived += (sender, eventArgs) => { eventArgs.CanTrust = CanTrustHost(client1.ConnectionInfo.Host, eventArgs); }; try { client1.Connect(); this.fingerprint = true; } catch (Exception) { this.error.setError("SF012", "unknown host"); this.channel = null; this.fingerprint = false; } finally { client1.Disconnect(); } } }
public void beginCracking() { log("beginning cracking process.."); var connectionInfo = new PasswordConnectionInfo (xml.Config.host, xml.Config.port, "root", xml.Config.Password); using (var sftp = new SftpClient(connectionInfo)) { using (var ssh = new SshClient(connectionInfo)) { PercentStatus("Establishing SSH connection", 5); ssh.Connect(); PercentStatus("Establishing SFTP connection", 10); sftp.Connect(); log("Cracking " + ipaInfo.AppName); PercentStatus("Preparing IPA", 25); String ipalocation = AppHelper.extractIPA(ipaInfo); using (var file = File.OpenRead(ipalocation)) { log("Uploading IPA to device.."); PercentStatus("Uploading IPA", 40); sftp.UploadFile(file, "Upload.ipa"); } log("Cracking! (This might take a while)"); PercentStatus("Cracking", 50); String binaryLocation = ipaInfo.BinaryLocation.Replace("Payload/", ""); String TempDownloadBinary = Path.Combine(AppHelper.GetTemporaryDirectory(), "crackedBinary"); var crack = ssh.RunCommand("Clutch -i 'Upload.ipa' " + binaryLocation + " /tmp/crackedBinary"); log("Clutch -i 'Upload.ipa' " + binaryLocation + " /tmp/crackedBinary"); log("cracking output: " + crack.Result); using (var file = File.OpenWrite(TempDownloadBinary)) { log("Downloading cracked binary.."); PercentStatus("Downloading cracked binary", 80); try { sftp.DownloadFile("/tmp/crackedBinary", file); } catch (SftpPathNotFoundException e) { log("Could not find file, help!!!!!"); return; } } PercentStatus("Repacking IPA", 90); String repack = AppHelper.repack(ipaInfo, TempDownloadBinary); PercentStatus("Done!", 100); log("Cracking completed, file at " + repack); } } }
public SFTP(Uri targetServer,string password) { _sftp = new SftpClient(targetServer.Host,targetServer.Port, targetServer.UserInfo, password); log.InfoFormat("SFTP - Connecting to {0}", targetServer); _sftp.Connect(); log.InfoFormat("SFTP - Changing dir to {0}", targetServer.LocalPath); _sftp.ChangeDirectory(targetServer.LocalPath); }
public static void UploadFile(string localFileToUpload, string host, string targetFile, string userName, string password) { using (var sftp = new SftpClient(host, userName, password)) { sftp.OperationTimeout = new TimeSpan(0, 0, seconds: 40); sftp.Connect(); UploadFileWithOpenConnection(localFileToUpload, targetFile, sftp); sftp.Disconnect(); } }
public static void DeleteRemoteDirectory(string host, string directory, string username, string password) { using (var sftp = new SftpClient(host, username, password)) { sftp.Connect(); sftp.DeleteDirectory(directory); sftp.Disconnect(); } }
public void Connect() { if(Protocol == SSHTransferProtocol.SCP) { ScpClt = new ScpClient(Host, Port, User, Password); ScpClt.Connect(); } if (Protocol == SSHTransferProtocol.SFTP) { SftpClt = new SftpClient(Host, Port, User, Password); SftpClt.Connect(); } }
public async Task UploadFileAsync(string path, byte[] content, CancellationToken ctk = default) { using (var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5))) using (var linked = CancellationTokenSource.CreateLinkedTokenSource(ctk, cts.Token)) { using (var sFtpClient = new Renci.SshNet.SftpClient(new ConnectionInfo(Host, Port, Credentials.UserName, new PasswordAuthenticationMethod(Credentials.UserName, Credentials.Password)))) { sFtpClient.Connect(); using (var ms = new MemoryStream(content)) { await sFtpClient.UploadAsync(ms, path); } } } }
public static void CopyFileFromLocalToRemote(string host, string user, string password, string localPath, string remotePath) { using (SftpClient client = new SftpClient(host, user, password)) { client.KeepAliveInterval = TimeSpan.FromSeconds(60); client.ConnectionInfo.Timeout = TimeSpan.FromMinutes(180); client.OperationTimeout = TimeSpan.FromMinutes(180); client.Connect(); bool connected = client.IsConnected; // RunCommand(host, user, password, "sudo chmod 777 -R " + remotePath); FileInfo fi = new FileInfo(localPath); client.UploadFile(fi.OpenRead(), remotePath + fi.Name, true); client.Disconnect(); } }
/// <summary> /// authenticates and returns an sftp client connection /// via ssh.NET /// </summary> /// <returns> /// the sftp client /// </returns> private Renci.SshNet.SftpClient GetSftpClient() { if (_client == null || !_client.IsConnected) { var connectionInfo = new ConnectionInfo( _host, _username, new PasswordAuthenticationMethod(_username, _password)); _client = new Renci.SshNet.SftpClient(connectionInfo); _client.Connect(); } return(_client); }
/// <summary> /// Defines a SFTP Client transaction /// </summary> /// <param name="_cred">The SSH transaction credentials</param> /// <param name="task">The Transaction task</param> public static void SFTPTransactionVoid(SiteCredentials _cred, Action <Renci.SshNet.SftpClient> task) { using (var client = new Renci.SshNet.SftpClient(_cred.Host, _cred.Port, _cred.User, _cred.Password)) { try { client.Connect(); task(client); client.Disconnect(); } catch (System.Exception exc) { Console.WriteLine(exc.Message); } } }
/// <summary> /// Sync output of current compilation to <paramref name="dir"/> /// </summary> /// <param name="dir"></param> /// <returns></returns> private bool SyncTo(string dir) { // Copy files over using (var sftp = new SftpClient(Machine, Port, Username, Password)) { sftp.Connect(); if (!sftp.IsConnected) { return false; } // Perform recursive copy of all the folders under `dir`. This is required // as the sftp client only synchronize directories at their level only, no // subdirectory. var dirs = new Queue<DirectoryInfo>(); dirs.Enqueue(new DirectoryInfo(dir)); var parentPath = new UDirectory(dir); while (dirs.Count != 0) { var currentDir = dirs.Dequeue(); var currentPath = new UDirectory(currentDir.FullName); foreach (var subdir in currentDir.EnumerateDirectories()) { dirs.Enqueue(subdir); } // Get the destination path by adding to `Location` the relative path of `dir` to `currentDir`. var destination = UPath.Combine(new UDirectory(Location.ItemSpec), currentPath.MakeRelative(parentPath)); Log.LogMessage("Synchronizing " + currentPath + " with " + destination.FullPath); // Try to create a remote directory. If it throws an exception, we will assume // for now that the directory already exists. See https://github.com/sshnet/SSH.NET/issues/25 try { sftp.CreateDirectory(destination.FullPath); Log.LogMessage("Creating remote directory " + destination.FullPath); } catch (SshException) { // Do nothing, as this is when the directory already exists } // Synchronize files. foreach (var file in sftp.SynchronizeDirectories(currentPath.FullPath, destination.FullPath, "*")) { Log.LogMessage("Updating " + file.Name); } } return true; } }
internal BasicRemoteOperations(IDeploymentContext context, IHost host) { Context = context; Sftp = new SftpClient(host.Hostname, host.Username, host.Password) { OperationTimeout = TimeSpan.FromMinutes(2), ConnectionInfo = {Timeout = TimeSpan.FromMinutes(2)}, BufferSize = 1024*16 }; Sftp.Connect(); Shell = new SshClient(host.Hostname, host.Username, host.Password); Shell.Connect(); ShellStream = Shell.CreateShellStream( String.Format("{0}@{1}", host.Username, host.Hostname), 0, 0, 0, 0, 1024); }
/// <summary> /// Defines a SFTP Client transaction /// </summary> /// <param name="_cred">The SSH transaction credentials</param> /// <param name="task">The Transaction task</param> /// <returns>The transaction result</returns> public static Object SFTPTransaction(SiteCredentials _cred, Func <Renci.SshNet.SftpClient, Object> task) { Object result = null; using (var client = new Renci.SshNet.SftpClient(_cred.Host, _cred.Port, _cred.User, _cred.Password)) { try { client.Connect(); result = task(client); client.Disconnect(); } catch (System.Exception exc) { Console.WriteLine(exc.Message); } } return(result); }
/// <summary> /// Test the credentials connection /// </summary> /// <param name="_cred">The credential connections</param> /// <param name="errMsg">The error message</param> /// <returns>True if the credentials are valid to connect to the host</returns> public static Boolean TestConnection(SiteCredentials _cred, out string errMsg) { Boolean result = true; errMsg = String.Empty; using (var client = new Renci.SshNet.SftpClient(_cred.Host, _cred.Port, _cred.User, _cred.Password)) { try { client.Connect(); client.Disconnect(); } catch (System.Exception exc) { errMsg = Message.MSG_ERR_NO_CONN + ".\n" + exc.Message; result = false; } } return(result); }
RenciSftpClient InstantiateClient() { var connectionInfo = new ConnectionInfo(Options.Host, Options.UserName, new PasswordAuthenticationMethod(Options.UserName, Options.Password)); var client = new RenciSftpClient(connectionInfo); client.Connect(); if (!client.ConnectionInfo.IsAuthenticated) { throw new Exception("SFTP: Could not authenticate"); } if (!string.IsNullOrWhiteSpace(Options.RemoteWorkingDirectory)) { client.ChangeDirectory(Options.RemoteWorkingDirectory); if (client.WorkingDirectory != Options.RemoteWorkingDirectory) { throw new Exception("SFTP: Do not match"); } } return(client); }
/// <inheritdoc /> public void CheckConnection() { _sftpClient.Connect(); _sftpClient.Disconnect(); }
public void CreateConnection() { try { if (string.IsNullOrWhiteSpace(_connectivitySettings.PrivateKeyPath)) { #region guard clause if (string.IsNullOrWhiteSpace(_connectivitySettings.Host) || string.IsNullOrWhiteSpace(_connectivitySettings.UserName) || string.IsNullOrWhiteSpace(_connectivitySettings.Password)) { Exception connectivityException = new Exception($"One or more connectivity-settings are incorrect: Host={_connectivitySettings.Host}, UserName={_connectivitySettings.UserName}, password=*******"); _logger.LogError(connectivityException, connectivityException.Message); throw connectivityException; } #endregion guard clause // connect using just username/password: _sftpClient = new Renci.SshNet.SftpClient( _connectivitySettings.Host, _connectivitySettings.Port, _connectivitySettings.UserName, _connectivitySettings.Password); } else { #region guard clause if (string.IsNullOrWhiteSpace(_connectivitySettings.Host) || string.IsNullOrWhiteSpace(_connectivitySettings.UserName) || String.IsNullOrWhiteSpace(_connectivitySettings.Password) || string.IsNullOrWhiteSpace(_connectivitySettings.PrivateKeyPath)) { Exception connectivityException = new Exception($"One or more connectivity-settings are incorrect: Host={_connectivitySettings.Host}, UserName={_connectivitySettings.UserName}, privateKeyPath={_connectivitySettings.PrivateKeyPath}"); _logger.LogError(connectivityException, connectivityException.Message); throw connectivityException; } #endregion guard clause // connect using just username/private key file/password as pass-phrase: _logger.LogInformation($"Will log on with keyfile {_connectivitySettings.PrivateKeyPath}, with the pass-phrase given."); VerifyPrivateKeyFileIsReadable(_connectivitySettings.PrivateKeyPath); VerifyPrivateKeyIsNotPuttyFormat(_connectivitySettings.PrivateKeyPath); PrivateKeyFile keyFile = new PrivateKeyFile(File.OpenRead(_connectivitySettings.PrivateKeyPath), @_connectivitySettings.Password); _sftpClient = new Renci.SshNet.SftpClient( _connectivitySettings.Host, _connectivitySettings.Port, _connectivitySettings.UserName, keyFile); } _logger.LogInformation($"Will connect to {_connectivitySettings.Host}, port {_connectivitySettings.Port}..."); // Retry, waiting a specified duration between each retry var policy = Policy .Handle <SocketException>() .WaitAndRetry(DEFAULT_NUMBER_OF_CONNECTION_RETRIES, retryNumber => TimeSpan.FromSeconds(retryNumber * DEFAULT_WAIT_SECONDS), (ex, tsp) => { // method to call on retries. // TODO: implement logging here. System.Diagnostics.Debug.WriteLine($"Trying again in {tsp}"); }); policy.Execute(() => _sftpClient.Connect()); } catch (Exception exception) when(exception.Message == @"Invalid private key file.") // Catch specific key file error, redirect to possible solution. { // The SSH.Net component supports RSA and DSA private key in both OpenSSH and SSH.COM format. // Some tools, such as PuTTYgen, generates key-files that need to be converted to another format in order to work with SSH.Net. Exception innerException = new Exception($@"Invalid key file, possible https://stackoverflow.com/questions/43915130/does-ssh-net-accept-only-openssh-format-of-private-key-if-not-what-are-the-res issue.", exception); // wrap exception in own specific exception. DotNetSftpClientException dotNetSftpClientException = new DotNetSftpClientException("DotNetSftpClient error, see inner Exception for details", innerException); throw dotNetSftpClientException; } catch (Exception exception) { // wrap exception in own specific exception. DotNetSftpClientException dotNetSftpClientException = new DotNetSftpClientException("DotNetSftpClient error, see inner Exception for details", exception); throw dotNetSftpClientException; } }
public void ftpConnect() { ftp = new SftpClient(connectionInfo); ftp.Connect(); }
public override async Task Connect(bool reconnecting = false) { Notifications.ChangeTrayText(reconnecting ? MessageType.Reconnecting : MessageType.Connecting); Log.Write(l.Debug, "{0} client...", reconnecting ? "Reconnecting" : "Connecting"); ConnectionInfo connectionInfo; if (Controller.IsPrivateKeyValid) { connectionInfo = new PrivateKeyConnectionInfo(Controller.Account.Host, Controller.Account.Port, Controller.Account.Username, new PrivateKeyFile(Controller.Account.PrivateKeyFile, Controller.Account.Password)); } else { connectionInfo = new PasswordConnectionInfo(Controller.Account.Host, Controller.Account.Port, Controller.Account.Username, Controller.Account.Password); } connectionInfo.Encoding = this.Charset; connectionInfo.AuthenticationBanner += (o, x) => Log.Write(l.Warning, x.BannerMessage); _sftpc = new Renci.SshNet.SftpClient(connectionInfo); _sftpc.HostKeyReceived += (o, x) => { var fingerPrint = x.FingerPrint.GetCertificateData(); // if ValidateCertificate handler isn't set, accept the certificate and move on if (ValidateCertificate == null || Settings.TrustedCertificates.Contains(fingerPrint)) { Log.Write(l.Client, "Trusted: {0}", fingerPrint); x.CanTrust = true; return; } var e = new ValidateCertificateEventArgs { Fingerprint = fingerPrint, Key = x.HostKeyName, KeySize = x.KeyLength.ToString() }; // Prompt user to validate ValidateCertificate?.Invoke(null, e); x.CanTrust = e.IsTrusted; }; var caughtException = default(Exception); await Task.Run(() => { try { _sftpc.Connect(); } catch (SshAuthenticationException ex) { ex.LogException(); caughtException = new AuthenticationException(ex.Message, ex.InnerException); } catch (SshConnectionException ex) { ex.LogException(); caughtException = new CertificateDeclinedException(ex.Message, ex.InnerException); } catch (Exception ex) { ex.LogException(); caughtException = ex; } }); if (caughtException != default(Exception)) { throw caughtException; } _sftpc.ErrorOccurred += async(o, e) => { if (!IsConnected) { Notifications.ChangeTrayText(MessageType.Nothing); } OnConnectionClosed(new ConnectionClosedEventArgs { Text = e.Exception.Message }); if (e.Exception is SftpPermissionDeniedException) { Log.Write(l.Warning, "Permission denied error occured"); } if (e.Exception is SshConnectionException) { await Reconnect(); } }; Controller.HomePath = WorkingDirectory; if (IsConnected) { if (!string.IsNullOrWhiteSpace(Controller.Paths.Remote) && !Controller.Paths.Remote.Equals("/")) { WorkingDirectory = Controller.Paths.Remote; } } Log.Write(l.Debug, "Client connected sucessfully"); Notifications.ChangeTrayText(MessageType.Ready); if (Settings.IsDebugMode) { LogServerInfo(); } }
public static void DeleteRemoteFile(string host, string file, string username, string password) { using (var sftp = new SftpClient(host, username, password)) { sftp.Connect(); sftp.Delete(file); sftp.Disconnect(); } }
public SecureCopier(ResourceNode node) { Log.Info("SCP: Establishing connection to node " + node.ResourceName + "." + node.NodeName); var nodeAddress = node.NodeAddress; // todo : OR ExecutionUrl????!!!!! var addrParts = node.NodeAddress.Split(':'); int port = DEFAULT_SCP_PORT; if (addrParts.Length == 2) { int.TryParse(addrParts[1], out port); nodeAddress = addrParts[0]; } // if resource asks us for password interactively: var interactiveAuthMethod = new KeyboardInteractiveAuthenticationMethod(node.Credentials.Username); interactiveAuthMethod.AuthenticationPrompt += delegate(object sender, Renci.SshNet.Common.AuthenticationPromptEventArgs e) { foreach (var prompt in e.Prompts) { Log.Debug("Interactive request by resource node " + node.NodeName + ": '" + prompt.Request + "'"); if (prompt.Request.ToLowerInvariant().Contains("password")) { Log.Debug("Responding by password"); prompt.Response = node.Credentials.Password; } } }; ConnectionInfo connectionInfo; if (!String.IsNullOrWhiteSpace(node.Credentials.CertFile)) { connectionInfo = new ConnectionInfo(nodeAddress, port, node.Credentials.Username, new PrivateKeyAuthenticationMethod( node.Credentials.Username, new PrivateKeyFile(node.Credentials.CertFile, node.Credentials.Password) ) ); } else { connectionInfo = new ConnectionInfo(nodeAddress, port, node.Credentials.Username, new PasswordAuthenticationMethod(node.Credentials.Username, node.Credentials.Password), interactiveAuthMethod ); } try { _sftpClient = new SftpClient(connectionInfo); _sftpClient.Connect(); _scp = null; } catch (Exception e) { Log.Warn("Unable to use sftp. Rolling bask to SCP for resource node " + node.ResourceName + "." + node.NodeName + ": " + e.ToString()); _sftpClient = null; _scp = new Scp(nodeAddress, node.Credentials.Username, node.Credentials.Password); _scp.Connect(port); } }
public Task<bool> ConnectAsync(string password) { Task<bool> task = new Task<bool>(() => { try { SecureString securePasswod = DecryptString(password); _sftp = new SftpClient(Host, UserName, ToInsecureString(securePasswod)); _sftp.OperationTimeout = new TimeSpan(0, 0, 10); _sftp.Connect(); _ssh = new SshClient(Host, UserName, ToInsecureString(securePasswod)); _ssh.Connect(); IsConnected = true; return true; } catch (Exception) { IsConnected = false; return false; } }); task.Start(); return task; }
protected void NBR_Send(int msgid, string m_ftp_host, string m_ftp_username, string m_ftp_password, string m_sftp_path, string m_messagename) { var m_headline = ""; string m_customer = "NBR"; var m_msgid = msgid.ToString(); String connectionString = ConfigurationManager.ConnectionStrings["azureConnectionString"].ConnectionString; try { // Connect to the database and run the query. SqlConnection con = new SqlConnection(connectionString); string strSQL = "Select headline from story where storyid = " + msgid; SqlCommand cmd = new SqlCommand(strSQL, con); cmd.CommandType = CommandType.Text; con.Open(); SqlDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { m_headline = (dr["headline"].ToString()); } cmd.Dispose(); con.Close(); con.Dispose(); } catch (Exception ex) { // The connection failed. Display an error message. PublishLog(m_msgid, m_headline, m_customer, ex.Message, "Pub Error"); } //PublishLog(m_msgid, m_headline, m_customer, "NBR NEW SFTP Step 1", "Step 1 OK"); string m_msg_file = m_msgid + "_NBR.xml"; string m_fileroot = "http://businessdesk.blob.core.windows.net/messages/"; string m_file = m_fileroot + m_msg_file; CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=businessdesk;AccountKey=zWYFxlr7zhbMhXLptJ2lvtrORvoPTVunsDAf/v8B0tDsUWMigwFOJs9wEZ62XU6UdFWM1BQJ/SN9dZ0JsWVlpw=="); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); CloudBlobContainer container = blobClient.GetContainerReference("messages"); CloudBlockBlob blockBlob = container.GetBlockBlobReference(m_msg_file); string pathToFiles = Server.MapPath("/Stories/"); string m_File = pathToFiles + m_msg_file; //PublishLog(m_msgid, m_File, m_customer, "NBR Before Blob Download", "Blob "); try { using (var fileStream = File.OpenWrite(m_File)) { blockBlob.DownloadToStream(fileStream); } } catch (Exception ex) { PublishLog(m_msgid, "Blob Error", m_customer, ex.Message, "Blob"); } //PublishLog(m_msgid, m_File, m_customer, "NBR After Blob Download", "Blob"); string host = "sftp.nbr.co.nz"; string username = "******"; string password = "******"; var proxy_host = "us-east-1-static-brooks.quotaguard.com"; var proxy_username = "******"; var proxy_password = "******"; int port = 22; ConnectionInfo infoConnection = new ConnectionInfo(host, port, username, ProxyTypes.Socks5, proxy_host, 1080, proxy_username, proxy_password, new PasswordAuthenticationMethod(username, password)); //PublishLog(m_msgid, m_headline, m_customer, "NBR NEW SFTP con init OK", "Init OK"); try { SftpClient client = new SftpClient(infoConnection); client.Connect(); // PublishLog(m_msgid, m_headline, m_customer, "NBR NEW SFTP Connx OK", "Connx OK"); using (var fileStream = new FileStream(m_File, FileMode.Open)) { client.UploadFile(fileStream, m_msg_file, true); } PublishLog(m_msgid, m_headline, m_customer, "NBR NEW SFTP Pub OK", "Publish OK"); } catch (WebException ex) { PublishLog(m_msgid, m_headline, m_customer, ex.Message, "NBR Pub Error"); } }
public void Connect() { if (sshConnection != null) { if (sshConnection.IsConnected) { try { sshConnection.Disconnect(); } catch { } } sshConnection = null; } if (sshServer != "" && sshUsername != "" && sshPassword != "") { sshConnection = new SftpClient(sshServer, sshPort, sshUsername, sshPassword); // connect in a different thread, we don't want to block the main thread new Thread(new ThreadStart(delegate { bool ok = false; try { sshConnection.Connect(); ok = true; } catch (Exception ex) { Tray.ShowBalloonTip(5000, "SFTP", "Failed to connect to SFTP server: \"" + (ex.InnerException != null ? ex.InnerException.Message : ex.Message) + "\"", ToolTipIcon.Error); sshConnection = null; } if (connectionDoneCallback != null) { connectionDoneCallback(ok); connectionDoneCallback = null; } })).Start(); } }
/// <summary> /// Connect to the remote servers, with the details from Profile /// </summary> /// <param name="reconnecting">True if this is an attempt to re-establish a closed connection</param> public void Connect(bool reconnecting = false) { Notifications.ChangeTrayText(reconnecting ? MessageType.Reconnecting : MessageType.Connecting); Log.Write(l.Debug, "{0} client...", reconnecting ? "Reconnecting" : "Connecting"); if (FTP) { _ftpc = new FtpClient { Host = controller.Account.Host, Port = controller.Account.Port }; // Add accepted certificates _ftpc.ClientCertificates.AddRange(Certificates); if (controller.Account.Protocol == FtpProtocol.FTPS) { _ftpc.ValidateCertificate += (sender, x) => { var fingerPrint = new X509Certificate2(x.Certificate).Thumbprint; if (_ftpc.ClientCertificates.Count <= 0 && x.PolicyErrors != SslPolicyErrors.None) { Certificates.Add(x.Certificate); x.Accept = false; return; } // if ValidateCertificate handler isn't set, accept the certificate and move on if (ValidateCertificate == null || Settings.TrustedCertificates.Contains(fingerPrint)) { Log.Write(l.Client, "Trusted: {0}", fingerPrint); x.Accept = true; return; } var e = new ValidateCertificateEventArgs { Fingerprint = fingerPrint, SerialNumber = x.Certificate.GetSerialNumberString(), Algorithm = x.Certificate.GetKeyAlgorithmParametersString(), ValidFrom = x.Certificate.GetEffectiveDateString(), ValidTo = x.Certificate.GetExpirationDateString(), Issuer = x.Certificate.Issuer }; // Prompt user to validate ValidateCertificate(null, e); x.Accept = e.IsTrusted; }; // Change Security Protocol if (controller.Account.FtpsMethod == FtpsMethod.Explicit) _ftpc.EncryptionMode = FtpEncryptionMode.Explicit; else if (controller.Account.FtpsMethod == FtpsMethod.Implicit) _ftpc.EncryptionMode = FtpEncryptionMode.Implicit; } _ftpc.Credentials = new NetworkCredential(controller.Account.Username, controller.Account.Password); try { _ftpc.Connect(); } catch (Exception exc) { // Since the ClientCertificates are added when accepted in ValidateCertificate, the first // attempt to connect will fail with an AuthenticationException. If this is the case, a // re-connect is attempted, this time with the certificates properly set. // This is a workaround to avoid storing Certificate files locally... if (exc is System.Security.Authentication.AuthenticationException && _ftpc.ClientCertificates.Count <= 0) Connect(); else throw; } } else // SFTP { ConnectionInfo connectionInfo; if (controller.isPrivateKeyValid) connectionInfo = new PrivateKeyConnectionInfo(controller.Account.Host, controller.Account.Port, controller.Account.Username, new PrivateKeyFile(controller.Account.PrivateKeyFile, controller.Account.Password)); else connectionInfo = new PasswordConnectionInfo(controller.Account.Host, controller.Account.Port, controller.Account.Username, controller.Account.Password); _sftpc = new SftpClient(connectionInfo); _sftpc.ConnectionInfo.AuthenticationBanner += (o, x) => Log.Write(l.Warning, x.BannerMessage); _sftpc.HostKeyReceived += (o, x) => { var fingerPrint = x.FingerPrint.GetCertificateData(); // if ValidateCertificate handler isn't set, accept the certificate and move on if (ValidateCertificate == null || Settings.TrustedCertificates.Contains(fingerPrint)) { Log.Write(l.Client, "Trusted: {0}", fingerPrint); x.CanTrust = true; return; } var e = new ValidateCertificateEventArgs { Fingerprint = fingerPrint, Key = x.HostKeyName, KeySize = x.KeyLength.ToString() }; // Prompt user to validate ValidateCertificate(null, e); x.CanTrust = e.IsTrusted; }; _sftpc.Connect(); _sftpc.ErrorOccurred += (o, e) => { if (!isConnected) Notifications.ChangeTrayText(MessageType.Nothing); if (ConnectionClosed != null) ConnectionClosed(null, new ConnectionClosedEventArgs { Text = e.Exception.Message }); if (e.Exception is Renci.SshNet.Common.SftpPermissionDeniedException) Log.Write(l.Warning, "Permission denied error occured"); if (e.Exception is Renci.SshNet.Common.SshConnectionException) Reconnect(); }; } controller.HomePath = WorkingDirectory; if (isConnected) if (!string.IsNullOrWhiteSpace(controller.Paths.Remote) && !controller.Paths.Remote.Equals("/")) WorkingDirectory = controller.Paths.Remote; Log.Write(l.Debug, "Client connected sucessfully"); Notifications.ChangeTrayText(MessageType.Ready); if (Settings.IsDebugMode) LogServerInfo(); // Periodically send NOOP (KeepAlive) to server if a non-zero interval is set SetKeepAlive(); }
private static bool SshUpload(Uri url) { Console.WriteLine("Select SSH method"); using (var sftp = new SftpClient(url.Host , url.IsDefaultPort?22:url.Port, ConfigurationManager.AppSettings["UserName"], ConfigurationManager.AppSettings["Password"])) { try { sftp.Connect(); } catch (Exception e) { Console.WriteLine("Can't connect to {0}",url); Console.WriteLine("Details :{0}", e.Message); return false; } using (var file = File.OpenRead(_fileNameZip)) { Console.WriteLine("Uploading..."); sftp.UploadFile(file, String.Format("{0}{1}", ConfigurationManager.AppSettings["RemotePath"], Path.GetFileName(_fileNameZip)), true); } Console.WriteLine("Disconnect"); sftp.Disconnect(); } return true; }
public Response UploadSFTP(DataExtensionImport dataExtensionImport) { var response = new Response { Success = true, Warning = false }; try { const int port = 22; const string host = "ftp.s6.exacttarget.com"; const string username = "******"; const string password = "******"; const string workingdirectory = "/Import//"; using (var client = new SftpClient(host, port, username, password)) { client.Connect(); client.ChangeDirectory(workingdirectory); string extension = Path.GetExtension(dataExtensionImport.Ruta); string nombreArchivo = string.Format("{0}{1}", dataExtensionImport.Nombre, extension); using (var fileStream = new FileStream(dataExtensionImport.Ruta, FileMode.Open)) { client.BufferSize = 4 * 1024; // bypass Payload error large files client.UploadFile(fileStream, nombreArchivo); } } } catch (Exception ex) { response.Success = false; response.Message = ex.Message; } return response; }
//turn this into some kind of interface public GatherResults DownloadQtyFiles(IVendorDirectory dir) { var files = new List<File>(); using (var sftp = new SftpClient(_config.QtyFileHost, _config.QtyFilePort, _config.QtyFileUsername, _config.QtyFilePassword)) { sftp.Connect(); dir.EnsureExists(); var localFile = dir.GetNewRawFile(FileTypes.Qty); using (var stream = new FileStream(localFile.Name.GetPath(), FileMode.Create)) { sftp.DownloadFile(_config.QtyFileName, stream); } files.Add(localFile); sftp.Disconnect(); } return new GatherResults { VendorHandle = dir.VendorHandle, Files = files }; }
public void Initialize() { if (SftpClient != null) return; SftpClient = new SftpClient(Host, Port, User, Password); SftpClient.Connect(); // Try to setup a ssh connection to speedup file listing try { SshClient = new SshClient(Host, Port, User, Password); SshClient.Connect(); } catch { SshClient = null; } }
/// <summary> /// This function will connect to the SFTP server for Wells Fargo /// </summary> private static void sftpConnect() { client = new Renci.SshNet.SftpClient(sftpHost, sftpPort, sftpUsername, new PrivateKeyFile(new MemoryStream(Encoding.ASCII.GetBytes(sftpKeyFile)))); try { client.Connect(); client.ChangeDirectory(downloadPath); } catch (Exception e) { appendToBody(String.Format("Download client threw an exception: {0}", e.Message.ToString())); Console.WriteLine(string.Format("exception...{0}", e)); } }
private bool Sftp(string server, int port, bool passive, string username, string password, string filename, int counter, byte[] contents, out string error, bool rename) { bool failed = false; error = ""; try { int i = 0; filename = filename.Replace("{C}", counter.ToString(CultureInfo.InvariantCulture)); if (rename) filename += ".tmp"; while (filename.IndexOf("{", StringComparison.Ordinal) != -1 && i < 20) { filename = String.Format(CultureInfo.InvariantCulture, filename, Helper.Now); i++; } var methods = new List<AuthenticationMethod> { new PasswordAuthenticationMethod(username, password) }; var con = new ConnectionInfo(server, port, username, methods.ToArray()); using (var client = new SftpClient(con)) { client.Connect(); var filepath = filename.Trim('/').Split('/'); var path = ""; for (var iDir = 0; iDir < filepath.Length - 1; iDir++) { path += filepath[iDir] + "/"; try { client.CreateDirectory(path); } catch { //directory exists } } if (path != "") { client.ChangeDirectory(path); } filename = filepath[filepath.Length - 1]; using (Stream stream = new MemoryStream(contents)) { client.UploadFile(stream, filename); if (rename) { try { //delete target file? client.DeleteFile(filename.Substring(0, filename.Length - 4)); } catch (Exception) { } client.RenameFile(filename, filename.Substring(0, filename.Length - 4)); } } client.Disconnect(); } MainForm.LogMessageToFile("SFTP'd " + filename + " to " + server + " port " + port, "SFTP"); } catch (Exception ex) { error = ex.Message; failed = true; } return !failed; }
public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction) { try { using (var sftp = new SftpClient(Host, Port, Username, Password)) { sftp.Connect(); using (var file = File.OpenWrite(TargetPath)) { sftp.DownloadFile(SourcePath, file); } return DTSExecResult.Success; } } catch (Exception ex) { log.Write(string.Format("{0}.Execute", GetType().FullName), ex.ToString()); return DTSExecResult.Failure; } }
private void Uploadfiles(PasswordConnectionInfo connectionInfo, IEnumerable<AchFileEntity> achFilesToUpload) { using (var sftp = new SftpClient(connectionInfo)) { try { sftp.Connect(); foreach (var achfile in achFilesToUpload) { using (var stream = new MemoryStream()) { var fileName = achfile.Name + ".ach"; var writer = new StreamWriter(stream); // writer.Write(achfile.AchFileBody); writer.Flush(); stream.Position = 0; sftp.UploadFile(stream, fileName); this.Manager.ChangeAchFilesStatus(achfile, AchFileStatus.Uploaded); this.Manager.UnLock(achfile); } } } finally { sftp.Disconnect(); } } }