SSH subsystems 

The SSH module hosts SFTP, shell (SCP) and tunneling subsystems.

The 'SCP/shell' subsystem provides "shell" and "exec" subsystems that implement simple shell commands to access the server's virtual filesystem. This makes it possible to access it with SSH clients such as PuTTY, SCP clients such as WinSCP, and of course with standard SSH ssh and scp commands. SCP support and built-in commands can be disabled, making it simple to implement a custom shell.

SSH shell 

The virtual shell environment offers two different shells:

Empty shell

ShellType.Empty is a clean, minimalist shell which only supports one predefined command - exit. It can be easily extended to handle any custom command using the ShellCommand event.

// creates a user with shell with only one command: 'exit'
// use ShellCommand event to handle custom commands
server.Users.Add("user", "password", ShellType.Empty);

// creates a user with same empty shell
// and set users home director (e.g. for SFTP access)
server.Users.Add("user", "password", @"c:\home\user", ShellType.Empty);

' creates a user with shell with only one command 'exit'
' use ShellCommand event to handle custom commands
server.Users.Add("user", "password", ShellType.Empty)

' creates a user with same empty shell
' And set users home director (e.g. for SFTP access)
server.Users.Add("user", "password", "c:\home\user", ShellType.Empty)

Virtual shell with SCP support

ShellType.Scp shell features built-in commands to access the virtual file system and also supports the SCP protocol.

This virtual shell environment can be easily extended by implementing additional commands. Even the built-in commands can be redefined to provide custom functionality, making it simple to use Rebex File Server as an SSH server that can be accessed by SSH client applications.

This makes it possible (for example) to simulate a simple Unix-like environment on Windows platforms for third-party applications and utilities designed to work with SSH and a Unix-like OS. See the Custom commands section for details.

// creates a user with shell with scp-related commands predefined
server.Users.Add("user", "password", @"c:\home\user", ShellType.Scp);

' creates a user with shell with scp-related commands predefined
server.Users.Add("user", "password", "c:\home\user", ShellType.Scp)

Automatic shell type detection

When ShellType.Default or no shell type is specified for a user, it will be determined automatically: Users with access to a virtual file system get Scp shell, users with no file system get Empty shell.

// creates a user with shell with scp-related commands predefined
server.Users.Add("user", "password", @"c:\home\user", ShellType.Default);
server.Users.Add("user", "password", @"c:\home\user"); // same as above

// creates a user with an empty shell
server.Users.Add("user", "password", ShellType.Default);
server.Users.Add("user", "password"); // same as above

' creates a user with shell with scp-related commands predefined
server.Users.Add("user", "password", "c:\home\user", ShellType.Default)
server.Users.Add("user", "password", "c:\home\user") ' same As above

' creates a user with an empty shell
server.Users.Add("user", "password", ShellType.Default)
server.Users.Add("user", "password") ' same As above

Custom commands 

It's very simple to implement custom commands for SSH "shell" and "exec" subsystems provided by the 'shell (SCP) subsystem'. Just write a ShellCommand event handler:

// implement several simple custom shell commands
server.ShellCommand += (sender, e) =>
{
    switch (e.Command)
    {
        case "date":
            e.WriteLine(DateTime.UtcNow);
            break;
        case "say":
            e.WriteLine(string.Join(" ", e.Arguments));
            break;
        case "fail":
            e.WriteLine("Command failed.");
            e.ExitCode = 1;
            break;
    }
};

' implement several simple custom shell commands
AddHandler server.ShellCommand,
    Sub(sender, e)
        Select Case e.Command
            Case "date"
                e.WriteLine(DateTime.UtcNow)
                Exit Select
            Case "say"
                e.WriteLine(String.Join(" ", e.Arguments))
                Exit Select
            Case "fail"
                e.WriteLine("Command failed.")
                e.ExitCode = 1
                Exit Select
        End Select
    End Sub

Alternatively, to implement commands that need to interact with the user or take a long time to complete, use the Action property:

// implement a complex command
server.ShellCommand += (sender, e) =>
{
    if (e.Command == "hello")
    {
        e.Action = (args, console) =>
        {
            // clear the terminal screen
            console.Clear();

            // ask a question and wait for answer
            console.WriteLine("Enter your name: ");
            string name = console.ReadLine();

            // say hello
            console.WriteLine("Hello, {0}!", name);

            // exit code
            return 0;
        };
    }
};

' implement a complex command
AddHandler server.ShellCommand,
    Sub(sender, e)
        If e.Command = "hello" Then
            e.Action =
                Function(args, console)
                    ' clear the terminal screen
                    console.Clear()

                    ' ask a question and wait for answer
                    console.WriteLine("Enter your name: ")
                    Dim name As String = console.ReadLine()

                    ' say hello
                    console.WriteLine("Hello, {0}!", name)

                    ' exit code
                    Return 0

                End Function
        End If
    End Sub

SSH settings 

The SSH module is tightly integrated into Rebex File Server. It can be configured through FileServer object's Settings property. It uses events such as Authentication and hosts SFTP and SCP subsystems.

Use FileServer.Settings.SshParameters object to specify various settings:

// get SSH parameters object
SshParameters par = server.Settings.SshParameters;

// only allow SHA-2 MAC ciphers
par.MacAlgorithms = SshMacAlgorithm.SHA256 | SshMacAlgorithm.SHA512;

// only allow AES and Chacha20/Poly1305 ciphers
par.EncryptionAlgorithms = SshEncryptionAlgorithm.AES | SshEncryptionAlgorithm.Chacha20Poly1305;

' get SSH parameters object
Dim par As SshParameters = server.Settings.SshParameters

' only allow SHA-2 MAC ciphers
par.MacAlgorithms = SshMacAlgorithm.SHA256 Or SshMacAlgorithm.SHA512

' only allow AES And Chacha20/Poly1305 ciphers
par.EncryptionAlgorithms = SshEncryptionAlgorithm.AES Or SshEncryptionAlgorithm.Chacha20Poly1305

SSH ciphers 

Rebex File Server's SSH module supports a number of security algorithms:

• Encryption algorithms (AES, AES/GCM, ChaCha20/Poly1305, Triple DES, Twofish, Blowfish, RC4).
• Encryption modes (CBC, CTR, AEAD).
• Host key algorithms (RSA, DSS, ECDSA, EdDSA).
• Key exchange algorithms (Diffie-Hellman or Elliptic Curve Diffie-Hellman).
• MAC algorithms (SHA-2, SHA-1, MD5).

Use FileServer.Settings.SshParameters property to specify all kinds of SSH ciphers:

Key Exchange Ciphers

Use SshParameters.KeyExchangeAlgorithms property to enable/disable whole categories of key exchange ciphers. If you need more control over key exchange ciphers, use SshParameters.SetKeyExchangeAlgorithms(...) method to specify supported ciphers in order of preference. The following table lists supported key exchange ciphers:

Host Key Algorithms

Use SshParameters.HostKeyAlgorithms property to enable/disable whole categories of host key algorithms. If you need more control over host key algorithms, use SshParameters.SetHostKeyAlgorithms(...) method to specify supported algorithms in order of preference. The following table lists supported host key algorithms:

Encryption Ciphers

Use SshParameters.EncryptionAlgorithms and SshParameters.EncryptionModes properties to enable/disable whole categories of encryption ciphers. If you need more control over encryption ciphers, use SshParameters.SetEncryptionAlgorithms(...) method to specify supported ciphers in order of preference. The following table lists supported encryption ciphers:

MAC Ciphers

Use SshParameters.MacAlgorithms property to enable/disable whole categories of message authentication code (MAC) ciphers. If you need more control over MAC ciphers, use SshParameters.SetMacAlgorithms(...) method to specify supported ciphers in order of preference. The following table lists supported MAC ciphers:

* Might be very slow on legacy Windows CE platforms

** Windows Vista and higher, or Windows Embedded Compact 2013