Managed File Transfer and Security Solutions

Communicating with SSH servers in .NET

Overview

       This article will demonstrate how to commnicate with SSH servers using SSH Factory for .NET.

Code Example

      Download license.txt  |  Download SSHEx.cs   |   Download SSHEx.vb

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Collections;

   4:  using System.Text;

   5:  using Jscape.Sftp;

   6:  using Jscape.Ssh;

   7:  using System.Net;

   8:  using Jscape.Ssh.Util;

   9:  using Jscape.Sftp.Packets;

  10:  using System.IO;

  11:   

  12:  namespace SSH

  13:  {

  14:      class SSHEx

  15:      {

  16:          public delegate void SSHExEmitDataEventHandler(String data);

  17:          public event SSHExEmitDataEventHandler SSHExEmitData;

  18:   

  19:          public void OnSSHExEmitData(String data)

  20:          {

  21:              if (SSHExEmitData != null)

  22:                  SSHExEmitData(data);

  23:          }

  24:   

  25:          public SSHEx(string server, string username, string password,

  26:                       bool validateHostKeys, string hostkey,

  27:                       bool usePublicKeyAuthentication, string privateKeyFile,

  28:                       string privateKeyPassword)

  29:          {

  30:              SshParameters sp = new SshParameters(server, username, password);

  31:              if (validateHostKeys == true)

  32:              {

  33:                  SshHostKeys keys = new SshHostKeys();

  34:                  keys.AddKey(Dns.GetHostEntry(server), hostkey);

  35:                  sp.SetHostKeys(keys, false);

  36:              }

  37:              else if (usePublicKeyAuthentication == true)

  38:              {

  39:                  sp.SetPrivateKey(new System.IO.FileInfo(privateKeyFile),

  40:                                   privateKeyPassword);

  41:              }

  42:            

  43:              this.Ssh = new Jscape.Ssh.Ssh(sp);

  44:              this.Ssh.LicenseKey = null; // copy license key from license.txt here

  45:              this.Ssh.SshConnectedEvent +=

  46:                  new Ssh.SshConnectedEventHandler(Ssh_SshConnectedEvent);

  47:              this.Ssh.SshDisconnectedEvent +=

  48:                  new Ssh.SshDisconnectedEventHandler(Ssh_SshDisconnectedEvent);

  49:              this.Ssh.SshDataEvent +=

  50:                  new Ssh.SshDataEventHandler(Ssh_SshDataEvent);

  51:          }

  52:   

  53:          private void Ssh_SshDataEvent(object source, SshDataEventArgs args)

  54:          {

  55:              OnSSHExEmitData(args.Data);

  56:          }

  57:   

  58:          private void Ssh_SshDisconnectedEvent(object source, SshDisconnectedEventArgs args)

  59:          {

  60:              Console.WriteLine("Disconnected to : " + args.Hostname);

  61:          }

  62:   

  63:          private void Ssh_SshConnectedEvent(object source, SshConnectedEventArgs args)

  64:          {

  65:              Console.WriteLine("Connected to : " + args.Hostname);

  66:          }

  67:   

  68:          public void openConnection()

  69:          {

  70:              this.Ssh.Connect();

  71:          }

  72:   

  73:          public void closeConnection()

  74:          {

  75:              this.Ssh.Disconnect();

  76:          }

  77:   

  78:          public ArrayList getHostKeys()

  79:          {

  80:              ArrayList ret = new ArrayList();

  81:              SshHostKeys keys = keys = this.Ssh.HostKeys;

  82:              IEnumerator iHosts = keys.GetHosts();

  83:              while (iHosts.MoveNext())

  84:              {

  85:                  DictionaryEntry entry = (DictionaryEntry)iHosts.Current;

  86:                  ret.Add(entry);

  87:              }

  88:              return ret;

  89:          }

  90:   

  91:          public void sendData(string line)

  92:          {

  93:              Stream output = this.Ssh.GetStream();

  94:              byte[] data = System.Text.Encoding.UTF8.GetBytes(line);

  95:              byte[] nl = System.Text.Encoding.UTF8.GetBytes("\r\n");

  96:              output.Write(data, 0, data.Length);

  97:              output.Write(nl, 0, nl.Length);

  98:              output.Flush();

  99:          }

 100:   

 101:          private Jscape.Ssh.Ssh _Ssh;

 102:          public Jscape.Ssh.Ssh Ssh

 103:          {

 104:              get

 105:              {

 106:                  return _Ssh;

 107:              }

 108:              set

 109:              {

 110:                  _Ssh = value;

 111:              }

 112:          }

 113:   

 114:          static void Main(string[] args)

 115:          {

 116:              try

 117:              {

 118:                  string server = "server";

 119:                  string username = "username";

 120:                  string password = "password";

 121:                  SSHEx e = new SSHEx(server, username, password, false,

 122:                                      "hostkey", false, "privateKeyFile",

 123:                                      "privateKeyPassword");

 124:                  e.openConnection();

 125:                  e.sendData("data");

 126:                  e.closeConnection();

 127:              }

 128:              catch (Exception e)

 129:              {

 130:                  Console.WriteLine(e.Message);

 131:              }

 132:   

 133:              Console.WriteLine("Press any key to continue ... ");

 134:              Console.Read();

 135:          }

 136:      }

 137:  }

Lines 1-10 : Necessary import statements.
Lines 16-23 : Event/Delegate for emitted data received from the server.
Lines 25-51 : Initialize Ssh instance. Connect event handlers.
Lines 53-56 : Event handler for receiving data from the server.
Lines 58-61 : Event handler when disconnected from the server.
Lines 63-66 : Event handler when connected to the server.
Lines 68-76 : Methods to open and close the connection.
Lines 78-89 : Get host keys. Each entry is of type KeyValuePair.
Lines 91-99 : Send data to the server.
Line 121    : Initialize SShEx instance.

Transferring files between a client and SSH server using SFTP in .NET

Overview

       This article will demonstrate how to transfer files between a client and SSH server using SSH Factory for .NET.

Code Example

      Download license.txt  |  Download SftpEx.cs  |   Download SFTP.vb

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.Collections;

   4:  using System.Text;

   5:  using Jscape.Sftp;

   6:  using Jscape.Ssh;

   7:  using Jscape.Sftp.Packets;

   8:   

   9:  namespace SFTP

  10:  {

  11:      class SftpEx 

  12:      {

  13:          public SftpEx(string server, string username, string password)

  14:          {

  15:              this.Sftp = new Sftp(new SshParameters(server, username, password));

  16:              this.Sftp.LicenseKey = null; // copy license key from 'license.txt' file here

  17:              this.Sftp.SftpConnectedEvent 
                       += new Sftp.SftpConnectedEventHandler(connectedEventHandler);

  18:              this.Sftp.SftpDisconnectedEvent
                       += new Sftp.SftpDisconnectedEventHandler(disconnectedEventHandler);

  19:          }

  20:   

  21:          public void connectedEventHandler(object sender, SftpConnectedEventArgs e)

  22:          {

  23:              Console.WriteLine("Connected to : " + e.Hostname);

  24:          }

  25:   

  26:          public void disconnectedEventHandler(object sender, SftpDisconnectedEventArgs e)

  27:          {

  28:              Console.WriteLine("Disconnected from : " + e.Hostname);

  29:          }

  30:   

  31:          public void openConnection()

  32:          {

  33:              this.Sftp.Connect();

  34:          }

  35:   

  36:          public void closeConnection()

  37:          {

  38:              this.Sftp.Disconnect();

  39:          }

  40:   

  41:          public void setLocalDir(string localdir)

  42:          {

  43:              this.Sftp.LocalDir = new System.IO.DirectoryInfo(localdir);

  44:          }

  45:   

  46:          public void setRemoteDir(string remotedir)

  47:          {

  48:              this.Sftp.RemoteDir = remotedir;

  49:          }

  50:   

  51:          public string GetDirListingAsString()

  52:          {

  53:              return this.Sftp.GetDirListingAsString();

  54:          }

  55:   

  56:          public ArrayList GetRemoteDirListing()

  57:          {

  58:              ArrayList ret = new ArrayList();

  59:              IEnumerator e = this.Sftp.GetDirListing();

  60:              while (e.MoveNext()) ret.Add((FileInfo)e.Current);

  61:              return ret;

  62:          }

  63:   

  64:          public ArrayList GetLocalDirListing()

  65:          {

  66:              ArrayList ret = new ArrayList();

  67:              IEnumerator e = this.Sftp.GetLocalDirListing();

  68:              while (e.MoveNext()) ret.Add((System.IO.FileSystemInfo)e.Current);

  69:              return ret;

  70:          }

  71:   

  72:          public void UploadDirectory(string dir)

  73:          {

  74:              this.Sftp.UploadDir(new System.IO.DirectoryInfo(dir));

  75:          }

  76:   

  77:          public void UploadTextFile(string localFile, string remoteFile, bool append)

  78:          {

  79:              this.Sftp.SetTextMode();

  80:              this.Sftp.Upload(localFile, remoteFile, append);

  81:          }

  82:   

  83:          public void UploadBinaryFile(string localFile, string remoteFile, bool append)

  84:          {

  85:              this.Sftp.SetBinaryMode();

  86:              this.Sftp.Upload(localFile, remoteFile, append);

  87:          }

  88:   

  89:          private Sftp _Sftp;

  90:          public Sftp Sftp

  91:          {

  92:              get

  93:              {

  94:                  return _Sftp;

  95:              }

  96:              set

  97:              {

  98:                  _Sftp = value;

  99:              }

 100:          }

 101:   

 102:          static void Main(string[] args)

 103:          {

 104:              try

 105:              {

 106:                  string server = "[servername]";

 107:                  string username = "[username]";

 108:                  string password = "[password]";

 109:                  SftpEx e = new SftpEx(server, username, password);

 110:                  e.openConnection();

 111:                  Console.WriteLine(e.GetDirListingAsString());

 112:                  ArrayList remoteList = e.GetRemoteDirListing();

 113:                  ArrayList localList = e.GetLocalDirListing();

 114:                  e.UploadTextFile("[localfile]", "[remotefile]", true);           

 115:                  e.closeConnection();

 116:              }

 117:              catch (Exception e)

 118:              {

 119:                  Console.WriteLine(e.Message);

 120:              }

 121:   

 122:              Console.WriteLine("Press any key to exit");

 123:              Console.Read();

 124:          }

 125:      }

 126:  }

Lines 1-7   : Necessary import statements.
Line  15    : Initialize Sftp instance.
Line  16    : License key (copy from license.text).
Lines 17-18 : Attach event handlers.
Lines 21-29 : Event handler methods.
Lines 31-39 : Methods to open and close connection to the server.
Lines 41-44 : Set local directory.
Lines 46-49 : Set remote directory.
Lines 51-54 : Get remote directories as a string.
Lines 56-62 : Get remote directories in an ArrayList instance.
Lines 64-70 : Get local directories in an ArrayList instance.
Lines 72-75 : Method to upload a directory.
Lines 77-81 : Upload a text file.
Lines 83-87 : Upload a binary file.
Lines 89-100  : Property for sftp instance.
Line 109      : Initialize SftpEx instance.
Lines 110-115 : Methods to test the SftpEx instance.

Updates to Email Factory for .NET and Secure iNet Factory

Email Factory for .NET (2.1.10) and Secure iNet Factory (7.4.3) component suites have received a patch which addresses a bug in the EmailMessage class.  The issue was that attachments that did not have a Content-Disposition header were not correctly recognized as attachments by the EmailMessage class.  The latest versions of these products have addressed this issue.