<PackageReference Include="SSH.NET" Version="2013.4.7" />

---

API Differences between 2013.4.7 and 2016.0.0-beta3

1278 Additions 0 Removals

Renci.SshNet

• public abstract class AuthenticationMethod
  • public IEnumerable<string> AllowedAuthentications { get; protected set; }
  • public string ErrorMessage { get; }
  • public abstract string Name { get; }
  • public string Username { get; }
  • protected AuthenticationMethod(string username)
  • public abstract AuthenticationResult Authenticate(Session session)
• public enum AuthenticationResult
  • Failure = 2
  • PartialSuccess = 1
  • Success = 0
• public abstract class BaseClient : IDisposable
  • public ConnectionInfo ConnectionInfo { get; }
  • public bool IsConnected { get; }
  • public TimeSpan KeepAliveInterval { get; set; }
  • protected Session Session { get; }
  • public event EventHandler<ExceptionEventArgs> ErrorOccurred
  • public event EventHandler<HostKeyEventArgs> HostKeyReceived
  • public BaseClient(ConnectionInfo connectionInfo)
  • public void Connect()
  • public void Disconnect()
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • protected virtual void OnConnected()
  • protected virtual void OnConnecting()
  • protected virtual void OnDisconnected()
  • protected virtual void OnDisconnecting()
  • public void SendKeepAlive()
• public class CipherInfo
  • public Func<byte[], byte[], Cipher> Cipher { get; }
  • public int KeySize { get; }
  • public CipherInfo(int keySize, Func<byte[], byte[], Cipher> cipher)
• public class CommandAsyncResult : IAsyncResult
  • public object AsyncState { get; }
  • public WaitHandle AsyncWaitHandle { get; }
  • public int BytesReceived { get; set; }
  • public int BytesSent { get; set; }
  • public bool CompletedSynchronously { get; }
  • public bool IsCompleted { get; }
• public class ConnectionInfo
  • public IEnumerable<AuthenticationMethod> AuthenticationMethods { get; }
  • public IDictionary<string, RequestInfo> ChannelRequests { get; }
  • public string ClientVersion { get; }
  • public IDictionary<string, Type> CompressionAlgorithms { get; }
  • public string CurrentClientCompressionAlgorithm { get; }
  • public string CurrentClientEncryption { get; }
  • public string CurrentClientHmacAlgorithm { get; }
  • public string CurrentHostKeyAlgorithm { get; }
  • public string CurrentKeyExchangeAlgorithm { get; }
  • public string CurrentServerCompressionAlgorithm { get; }
  • public string CurrentServerEncryption { get; }
  • public string CurrentServerHmacAlgorithm { get; }
  • public Encoding Encoding { get; set; }
  • public IDictionary<string, CipherInfo> Encryptions { get; }
  • public IDictionary<string, HashInfo> HmacAlgorithms { get; }
  • public string Host { get; }
  • public IDictionary<string, Func<byte[], KeyHostAlgorithm>> HostKeyAlgorithms { get; }
  • public bool IsAuthenticated { get; }
  • public IDictionary<string, Type> KeyExchangeAlgorithms { get; }
  • public int MaxSessions { get; set; }
  • public int Port { get; }
  • public string ProxyHost { get; }
  • public string ProxyPassword { get; }
  • public int ProxyPort { get; }
  • public ProxyTypes ProxyType { get; }
  • public string ProxyUsername { get; }
  • public int RetryAttempts { get; set; }
  • public string ServerVersion { get; }
  • public TimeSpan Timeout { get; set; }
  • public string Username { get; }
  • public event EventHandler<AuthenticationBannerEventArgs> AuthenticationBanner
  • public ConnectionInfo(string host, string username, AuthenticationMethod[] authenticationMethods)
  • public ConnectionInfo(string host, int port, string username, AuthenticationMethod[] authenticationMethods)
  • public ConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, AuthenticationMethod[] authenticationMethods)
  • public bool Authenticate(Session session)
• public class ExpectAction
  • public Action<string> Action { get; }
  • public Regex Expect { get; }
  • public ExpectAction(Regex expect, Action<string> action)
  • public ExpectAction(string expect, Action<string> action)
• public class ExpectAsyncResult : AsyncResult<string>
• public static class Extensions
• public abstract class ForwardedPort
  • public bool IsStarted { get; protected set; }
  • public event EventHandler<ExceptionEventArgs> Exception
  • public event EventHandler<PortForwardEventArgs> RequestReceived
  • protected ForwardedPort()
  • protected void RaiseExceptionEvent(Exception execption)
  • protected void RaiseRequestReceived(string host, uint port)
  • public virtual void Start()
  • public virtual void Stop()
• public class ForwardedPortDynamic : ForwardedPort, IDisposable
  • public string BoundHost { get; protected set; }
  • public uint BoundPort { get; protected set; }
  • public ForwardedPortDynamic(uint port)
  • public ForwardedPortDynamic(string host, uint port)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class ForwardedPortLocal : ForwardedPort, IDisposable
  • public string BoundHost { get; protected set; }
  • public uint BoundPort { get; protected set; }
  • public string Host { get; protected set; }
  • public uint Port { get; protected set; }
  • public ForwardedPortLocal(uint boundPort, string host, uint port)
  • public ForwardedPortLocal(string boundHost, uint boundPort, string host, uint port)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class ForwardedPortRemote : ForwardedPort, IDisposable
  • public string BoundHost { get; }
  • public IPAddress BoundHostAddress { get; protected set; }
  • public uint BoundPort { get; protected set; }
  • public string Host { get; }
  • public IPAddress HostAddress { get; protected set; }
  • public uint Port { get; protected set; }
  • public ForwardedPortRemote(IPAddress boundHostAddress, uint boundPort, IPAddress hostAddress, uint port)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class HashInfo
  • public Func<byte[], HashAlgorithm> HashAlgorithm { get; }
  • public int KeySize { get; }
  • public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash)
• public class KeyboardInteractiveAuthenticationMethod : AuthenticationMethod, IDisposable
  • public event EventHandler<AuthenticationPromptEventArgs> AuthenticationPrompt
  • public KeyboardInteractiveAuthenticationMethod(string username)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class KeyboardInteractiveConnectionInfo : ConnectionInfo, IDisposable
  • public event EventHandler<AuthenticationPromptEventArgs> AuthenticationPrompt
  • public KeyboardInteractiveConnectionInfo(string host, string username)
  • public KeyboardInteractiveConnectionInfo(string host, int port, string username)
  • public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort)
  • public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
  • public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort)
  • public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
  • public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
  • public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class MessageEventArgs<T> : EventArgs
  • public T Message { get; }
  • public MessageEventArgs(T message)
• public class NoneAuthenticationMethod : AuthenticationMethod, IDisposable
  • public NoneAuthenticationMethod(string username)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PasswordAuthenticationMethod : AuthenticationMethod, IDisposable
  • public event EventHandler<AuthenticationPasswordChangeEventArgs> PasswordExpired
  • public PasswordAuthenticationMethod(string username, string password)
  • public PasswordAuthenticationMethod(string username, byte[] password)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PasswordConnectionInfo : ConnectionInfo, IDisposable
  • public event EventHandler<AuthenticationPasswordChangeEventArgs> PasswordExpired
  • public PasswordConnectionInfo(string host, string username, string password)
  • public PasswordConnectionInfo(string host, int port, string username, string password)
  • public PasswordConnectionInfo(string host, int port, string username, string password, ProxyTypes proxyType, string proxyHost, int proxyPort)
  • public PasswordConnectionInfo(string host, int port, string username, string password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
  • public PasswordConnectionInfo(string host, string username, string password, ProxyTypes proxyType, string proxyHost, int proxyPort)
  • public PasswordConnectionInfo(string host, string username, string password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
  • public PasswordConnectionInfo(string host, string username, string password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
  • public PasswordConnectionInfo(string host, string username, byte[] password)
  • public PasswordConnectionInfo(string host, int port, string username, byte[] password)
  • public PasswordConnectionInfo(string host, int port, string username, byte[] password, ProxyTypes proxyType, string proxyHost, int proxyPort)
  • public PasswordConnectionInfo(string host, int port, string username, byte[] password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
  • public PasswordConnectionInfo(string host, string username, byte[] password, ProxyTypes proxyType, string proxyHost, int proxyPort)
  • public PasswordConnectionInfo(string host, string username, byte[] password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
  • public PasswordConnectionInfo(string host, string username, byte[] password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
  • public PasswordConnectionInfo(string host, int port, string username, byte[] password, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PrivateKeyAuthenticationMethod : AuthenticationMethod, IDisposable
  • public ICollection<PrivateKeyFile> KeyFiles { get; }
  • public PrivateKeyAuthenticationMethod(string username, PrivateKeyFile[] keyFiles)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PrivateKeyConnectionInfo : ConnectionInfo, IDisposable
  • public ICollection<PrivateKeyFile> KeyFiles { get; }
  • public PrivateKeyConnectionInfo(string host, string username, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, PrivateKeyFile[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, PrivateKeyFile[] keyFiles)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PrivateKeyFile : IDisposable
  • public HostAlgorithm HostKey { get; }
  • public PrivateKeyFile(Stream privateKey)
  • public PrivateKeyFile(string fileName)
  • public PrivateKeyFile(string fileName, string passPhrase)
  • public PrivateKeyFile(Stream privateKey, string passPhrase)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public enum ProxyTypes
  • Http = 3
  • None = 0
  • Socks4 = 1
  • Socks5 = 2
• public class ScpClient : BaseClient
  • public uint BufferSize { get; set; }
  • public TimeSpan OperationTimeout { get; set; }
  • public event EventHandler<ScpDownloadEventArgs> Downloading
  • public event EventHandler<ScpUploadEventArgs> Uploading
  • public ScpClient(ConnectionInfo connectionInfo)
  • public ScpClient(string host, int port, string username, string password)
  • public ScpClient(string host, string username, string password)
  • public ScpClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public ScpClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public void Download(string filename, Stream destination)
  • public void Upload(Stream source, string path)
• public class Session : IDisposable
  • protected const int MAXIMUM_PACKET_SIZE = 35000
  • protected const int MAXIMUM_PAYLOAD_SIZE = 32768
  • public Message ClientInitMessage { get; }
  • public string ClientVersion { get; }
  • public ConnectionInfo ConnectionInfo { get; }
  • public bool IsConnected { get; }
  • public string ServerVersion { get; }
  • public byte[] SessionId { get; }
  • public SemaphoreLight SessionSemaphore { get; }
  • public event EventHandler<EventArgs> Disconnected
  • public event EventHandler<ExceptionEventArgs> ErrorOccured
  • public event EventHandler<HostKeyEventArgs> HostKeyReceived
  • public void Connect()
  • public void Disconnect()
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • protected virtual void OnChannelCloseReceived(ChannelCloseMessage message)
  • protected virtual void OnChannelDataReceived(ChannelDataMessage message)
  • protected virtual void OnChannelEofReceived(ChannelEofMessage message)
  • protected virtual void OnChannelExtendedDataReceived(ChannelExtendedDataMessage message)
  • protected virtual void OnChannelFailureReceived(ChannelFailureMessage message)
  • protected virtual void OnChannelOpenConfirmationReceived(ChannelOpenConfirmationMessage message)
  • protected virtual void OnChannelOpenFailureReceived(ChannelOpenFailureMessage message)
  • protected virtual void OnChannelOpenReceived(ChannelOpenMessage message)
  • protected virtual void OnChannelRequestReceived(ChannelRequestMessage message)
  • protected virtual void OnChannelSuccessReceived(ChannelSuccessMessage message)
  • protected virtual void OnChannelWindowAdjustReceived(ChannelWindowAdjustMessage message)
  • protected virtual void OnDebugReceived(DebugMessage message)
  • protected virtual void OnDisconnectReceived(DisconnectMessage message)
  • protected virtual void OnGlobalRequestReceived(GlobalRequestMessage message)
  • protected virtual void OnIgnoreReceived(IgnoreMessage message)
  • protected virtual void OnKeyExchangeInitReceived(KeyExchangeInitMessage message)
  • protected virtual void OnMessageReceived(Message message)
  • protected virtual void OnNewKeysReceived(NewKeysMessage message)
  • protected virtual void OnRequestFailureReceived(RequestFailureMessage message)
  • protected virtual void OnRequestSuccessReceived(RequestSuccessMessage message)
  • protected virtual void OnServiceAcceptReceived(ServiceAcceptMessage message)
  • protected virtual void OnServiceRequestReceived(ServiceRequestMessage message)
  • protected virtual void OnUnimplementedReceived(UnimplementedMessage message)
  • protected virtual void OnUserAuthenticationBannerReceived(BannerMessage message)
  • protected virtual void OnUserAuthenticationFailureReceived(FailureMessage message)
  • protected virtual void OnUserAuthenticationRequestReceived(RequestMessage message)
  • protected virtual void OnUserAuthenticationSuccessReceived(SuccessMessage message)
  • public void RegisterMessage(string messageName)
  • public void UnRegisterMessage(string messageName)
• public class SftpClient : BaseClient
  • public uint BufferSize { get; set; }
  • public TimeSpan OperationTimeout { get; set; }
  • public int ProtocolVersion { get; }
  • public string WorkingDirectory { get; }
  • public SftpClient(ConnectionInfo connectionInfo)
  • public SftpClient(string host, int port, string username, string password)
  • public SftpClient(string host, string username, string password)
  • public SftpClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public SftpClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public void AppendAllLines(string path, IEnumerable<string> contents)
  • public void AppendAllLines(string path, IEnumerable<string> contents, Encoding encoding)
  • public void AppendAllText(string path, string contents)
  • public void AppendAllText(string path, string contents, Encoding encoding)
  • public StreamWriter AppendText(string path)
  • public StreamWriter AppendText(string path, Encoding encoding)
  • public IAsyncResult BeginDownloadFile(string path, Stream output)
  • public IAsyncResult BeginDownloadFile(string path, Stream output, AsyncCallback asyncCallback)
  • public IAsyncResult BeginDownloadFile(string path, Stream output, AsyncCallback asyncCallback, object state, Action<ulong> downloadCallback = null)
  • public IAsyncResult BeginListDirectory(string path, AsyncCallback asyncCallback, object state, Action<int> listCallback = null)
  • public IAsyncResult BeginUploadFile(Stream input, string path)
  • public IAsyncResult BeginUploadFile(Stream input, string path, AsyncCallback asyncCallback)
  • public IAsyncResult BeginUploadFile(Stream input, string path, AsyncCallback asyncCallback, object state, Action<ulong> uploadCallback = null)
  • public IAsyncResult BeginUploadFile(Stream input, string path, bool canOverride, AsyncCallback asyncCallback, object state, Action<ulong> uploadCallback = null)
  • public void ChangeDirectory(string path)
  • public void ChangePermissions(string path, short mode)
  • public SftpFileStream Create(string path)
  • public SftpFileStream Create(string path, int bufferSize)
  • public void CreateDirectory(string path)
  • public StreamWriter CreateText(string path)
  • public StreamWriter CreateText(string path, Encoding encoding)
  • public void Delete(string path)
  • public void DeleteDirectory(string path)
  • public void DeleteFile(string path)
  • public void DownloadFile(string path, Stream output, Action<ulong> downloadCallback = null)
  • public void EndDownloadFile(IAsyncResult asyncResult)
  • public IEnumerable<SftpFile> EndListDirectory(IAsyncResult asyncResult)
  • public void EndUploadFile(IAsyncResult asyncResult)
  • public bool Exists(string path)
  • public SftpFile Get(string path)
  • public SftpFileAttributes GetAttributes(string path)
  • public DateTime GetLastAccessTime(string path)
  • public DateTime GetLastAccessTimeUtc(string path)
  • public DateTime GetLastWriteTime(string path)
  • public DateTime GetLastWriteTimeUtc(string path)
  • public SftpFileSytemInformation GetStatus(string path)
  • public IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback = null)
  • public SftpFileStream Open(string path, FileMode mode)
  • public SftpFileStream Open(string path, FileMode mode, FileAccess access)
  • public SftpFileStream OpenRead(string path)
  • public StreamReader OpenText(string path)
  • public SftpFileStream OpenWrite(string path)
  • public byte[] ReadAllBytes(string path)
  • public string[] ReadAllLines(string path)
  • public string[] ReadAllLines(string path, Encoding encoding)
  • public string ReadAllText(string path)
  • public string ReadAllText(string path, Encoding encoding)
  • public IEnumerable<string> ReadLines(string path)
  • public IEnumerable<string> ReadLines(string path, Encoding encoding)
  • public void RenameFile(string oldPath, string newPath)
  • public void RenameFile(string oldPath, string newPath, bool isPosix)
  • public void SetAttributes(string path, SftpFileAttributes fileAttributes)
  • public void SetLastAccessTime(string path, DateTime lastAccessTime)
  • public void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
  • public void SetLastWriteTime(string path, DateTime lastWriteTime)
  • public void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
  • public void SymbolicLink(string path, string linkPath)
  • public void UploadFile(Stream input, string path, Action<ulong> uploadCallback = null)
  • public void UploadFile(Stream input, string path, bool canOverride, Action<ulong> uploadCallback = null)
  • public void WriteAllBytes(string path, byte[] bytes)
  • public void WriteAllLines(string path, IEnumerable<string> contents)
  • public void WriteAllLines(string path, string[] contents)
  • public void WriteAllLines(string path, IEnumerable<string> contents, Encoding encoding)
  • public void WriteAllLines(string path, string[] contents, Encoding encoding)
  • public void WriteAllText(string path, string contents)
  • public void WriteAllText(string path, string contents, Encoding encoding)
• public class Shell : IDisposable
  • public bool IsStarted { get; }
  • public event EventHandler<ExceptionEventArgs> ErrorOccurred
  • public event EventHandler<EventArgs> Started
  • public event EventHandler<EventArgs> Starting
  • public event EventHandler<EventArgs> Stopped
  • public event EventHandler<EventArgs> Stopping
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public void Start()
  • public void Stop()
• public class ShellStream : Stream
  • public bool DataAvailable { get; }
  • public event EventHandler<ShellDataEventArgs> DataReceived
  • public event EventHandler<ExceptionEventArgs> ErrorOccurred
  • public IAsyncResult BeginExpect(ExpectAction[] expectActions)
  • public IAsyncResult BeginExpect(AsyncCallback callback, ExpectAction[] expectActions)
  • public IAsyncResult BeginExpect(AsyncCallback callback, object state, ExpectAction[] expectActions)
  • public IAsyncResult BeginExpect(TimeSpan timeout, AsyncCallback callback, object state, ExpectAction[] expectActions)
  • public string EndExpect(IAsyncResult asyncResult)
  • public void Expect(ExpectAction[] expectActions)
  • public void Expect(TimeSpan timeout, ExpectAction[] expectActions)
  • public string Expect(string text)
  • public string Expect(string text, TimeSpan timeout)
  • public string Expect(Regex regex)
  • public string Expect(Regex regex, TimeSpan timeout)
  • public string Read()
  • public string ReadLine()
  • public string ReadLine(TimeSpan timeout)
  • protected void WaitHandle(WaitHandle waitHandle)
  • public void Write(string text)
  • public void WriteLine(string line)
• public class SshClient : BaseClient
  • public IEnumerable<ForwardedPort> ForwardedPorts { get; }
  • public SshClient(ConnectionInfo connectionInfo)
  • public SshClient(string host, int port, string username, string password)
  • public SshClient(string host, string username, string password)
  • public SshClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public SshClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public void AddForwardedPort(ForwardedPort port)
  • public SshCommand CreateCommand(string commandText)
  • public SshCommand CreateCommand(string commandText, Encoding encoding)
  • public Shell CreateShell(Stream input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes, int bufferSize)
  • public Shell CreateShell(Stream input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes)
  • public Shell CreateShell(Stream input, Stream output, Stream extendedOutput)
  • public Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes, int bufferSize)
  • public Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes)
  • public Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput)
  • public ShellStream CreateShellStream(string terminalName, uint columns, uint rows, uint width, uint height, int bufferSize)
  • public ShellStream CreateShellStream(string terminalName, uint columns, uint rows, uint width, uint height, int bufferSize, IDictionary<TerminalModes, uint> terminalModeValues)
  • public void RemoveForwardedPort(ForwardedPort port)
  • public SshCommand RunCommand(string commandText)
• public class SshCommand : IDisposable
  • public string CommandText { get; }
  • public TimeSpan CommandTimeout { get; set; }
  • public string Error { get; }
  • public int ExitStatus { get; }
  • public Stream ExtendedOutputStream { get; }
  • public Stream OutputStream { get; }
  • public string Result { get; }
  • public IAsyncResult BeginExecute()
  • public IAsyncResult BeginExecute(AsyncCallback callback)
  • public IAsyncResult BeginExecute(AsyncCallback callback, object state)
  • public IAsyncResult BeginExecute(string commandText, AsyncCallback callback, object state)
  • public void CancelAsync()
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public string EndExecute(IAsyncResult asyncResult)
  • public string Execute()
  • public string Execute(string commandText)

Renci.SshNet.Common

• public class ASCIIEncoding : Encoding
  • public ASCIIEncoding()
• public abstract class AsyncResult : IAsyncResult
  • public object AsyncState { get; }
  • public WaitHandle AsyncWaitHandle { get; }
  • public bool CompletedSynchronously { get; }
  • public bool EndInvokeCalled { get; }
  • public bool IsCompleted { get; }
  • public AsyncResult(AsyncCallback asyncCallback, object state)
  • public void EndInvoke()
  • public void SetAsCompleted(Exception exception, bool completedSynchronously)
• public abstract class AsyncResult<TResult> : AsyncResult
  • public AsyncResult(AsyncCallback asyncCallback, object state)
  • public TResult EndInvoke()
  • public void SetAsCompleted(TResult result, bool completedSynchronously)
• public class AuthenticationBannerEventArgs : AuthenticationEventArgs
  • public string BannerMessage { get; }
  • public string Language { get; }
  • public AuthenticationBannerEventArgs(string username, string message, string language)
• public abstract class AuthenticationEventArgs : EventArgs
  • public string Username { get; }
  • public AuthenticationEventArgs(string username)
• public class AuthenticationPasswordChangeEventArgs : AuthenticationEventArgs
  • public byte[] NewPassword { get; set; }
  • public AuthenticationPasswordChangeEventArgs(string username)
• public class AuthenticationPrompt
  • public int Id { get; }
  • public bool IsEchoed { get; }
  • public string Request { get; }
  • public string Response { get; set; }
  • public AuthenticationPrompt(int id, bool isEchoed, string request)
• public class AuthenticationPromptEventArgs : AuthenticationEventArgs
  • public string Instruction { get; }
  • public string Language { get; }
  • public IEnumerable<AuthenticationPrompt> Prompts { get; }
  • public AuthenticationPromptEventArgs(string username, string instruction, string language, IEnumerable<AuthenticationPrompt> prompts)
• public struct BigInteger : IComparable, IFormattable, IComparable<BigInteger>, IEquatable<BigInteger>
  • public static BigInteger MinusOne { get; }
  • public static BigInteger One { get; }
  • public static BigInteger Zero { get; }
  • public int BitLength { get; }
  • public bool IsEven { get; }
  • public bool IsOne { get; }
  • public bool IsPowerOfTwo { get; }
  • public bool IsZero { get; }
  • public int Sign { get; }
  • public BigInteger(short sign, uint[] data)
  • public BigInteger(int value)
  • public BigInteger(uint value)
  • public BigInteger(long value)
  • public BigInteger(ulong value)
  • public BigInteger(double value)
  • public BigInteger(float value)
  • public BigInteger(decimal value)
  • public BigInteger(byte[] value)
  • public static BigInteger Abs(BigInteger value)
  • public static BigInteger Add(BigInteger left, BigInteger right)
  • public static int Compare(BigInteger left, BigInteger right)
  • public static BigInteger Divide(BigInteger dividend, BigInteger divisor)
  • public static BigInteger DivRem(BigInteger dividend, BigInteger divisor, out BigInteger remainder)
  • public static BigInteger GreatestCommonDivisor(BigInteger left, BigInteger right)
  • public static double Log(BigInteger value, double baseValue)
  • public static double Log(BigInteger value)
  • public static double Log10(BigInteger value)
  • public static BigInteger Max(BigInteger left, BigInteger right)
  • public static BigInteger Min(BigInteger left, BigInteger right)
  • public static BigInteger ModInverse(BigInteger bi, BigInteger modulus)
  • public static BigInteger ModPow(BigInteger value, BigInteger exponent, BigInteger modulus)
  • public static BigInteger Multiply(BigInteger left, BigInteger right)
  • public static BigInteger Negate(BigInteger value)
  • public static BigInteger op_Addition(BigInteger left, BigInteger right)
  • public static BigInteger op_BitwiseAnd(BigInteger left, BigInteger right)
  • public static BigInteger op_BitwiseOr(BigInteger left, BigInteger right)
  • public static BigInteger op_Decrement(BigInteger value)
  • public static BigInteger op_Division(BigInteger dividend, BigInteger divisor)
  • public static bool op_Equality(BigInteger left, BigInteger right)
  • public static bool op_Equality(BigInteger left, long right)
  • public static bool op_Equality(long left, BigInteger right)
  • public static bool op_Equality(BigInteger left, ulong right)
  • public static bool op_Equality(ulong left, BigInteger right)
  • public static BigInteger op_ExclusiveOr(BigInteger left, BigInteger right)
  • public static int op_Explicit(BigInteger value)
  • public static uint op_Explicit(BigInteger value)
  • public static short op_Explicit(BigInteger value)
  • public static ushort op_Explicit(BigInteger value)
  • public static byte op_Explicit(BigInteger value)
  • public static sbyte op_Explicit(BigInteger value)
  • public static long op_Explicit(BigInteger value)
  • public static ulong op_Explicit(BigInteger value)
  • public static double op_Explicit(BigInteger value)
  • public static float op_Explicit(BigInteger value)
  • public static decimal op_Explicit(BigInteger value)
  • public static BigInteger op_Explicit(double value)
  • public static BigInteger op_Explicit(float value)
  • public static BigInteger op_Explicit(decimal value)
  • public static bool op_GreaterThan(BigInteger left, BigInteger right)
  • public static bool op_GreaterThan(BigInteger left, long right)
  • public static bool op_GreaterThan(long left, BigInteger right)
  • public static bool op_GreaterThan(BigInteger left, ulong right)
  • public static bool op_GreaterThan(ulong left, BigInteger right)
  • public static bool op_GreaterThanOrEqual(BigInteger left, BigInteger right)
  • public static bool op_GreaterThanOrEqual(BigInteger left, long right)
  • public static bool op_GreaterThanOrEqual(long left, BigInteger right)
  • public static bool op_GreaterThanOrEqual(BigInteger left, ulong right)
  • public static bool op_GreaterThanOrEqual(ulong left, BigInteger right)
  • public static BigInteger op_Implicit(int value)
  • public static BigInteger op_Implicit(uint value)
  • public static BigInteger op_Implicit(short value)
  • public static BigInteger op_Implicit(ushort value)
  • public static BigInteger op_Implicit(byte value)
  • public static BigInteger op_Implicit(sbyte value)
  • public static BigInteger op_Implicit(long value)
  • public static BigInteger op_Implicit(ulong value)
  • public static BigInteger op_Increment(BigInteger value)
  • public static bool op_Inequality(BigInteger left, BigInteger right)
  • public static bool op_Inequality(BigInteger left, long right)
  • public static bool op_Inequality(long left, BigInteger right)
  • public static bool op_Inequality(BigInteger left, ulong right)
  • public static bool op_Inequality(ulong left, BigInteger right)
  • public static BigInteger op_LeftShift(BigInteger value, int shift)
  • public static bool op_LessThan(BigInteger left, BigInteger right)
  • public static bool op_LessThan(BigInteger left, long right)
  • public static bool op_LessThan(long left, BigInteger right)
  • public static bool op_LessThan(BigInteger left, ulong right)
  • public static bool op_LessThan(ulong left, BigInteger right)
  • public static bool op_LessThanOrEqual(BigInteger left, BigInteger right)
  • public static bool op_LessThanOrEqual(BigInteger left, long right)
  • public static bool op_LessThanOrEqual(long left, BigInteger right)
  • public static bool op_LessThanOrEqual(BigInteger left, ulong right)
  • public static bool op_LessThanOrEqual(ulong left, BigInteger right)
  • public static BigInteger op_Modulus(BigInteger dividend, BigInteger divisor)
  • public static BigInteger op_Multiply(BigInteger left, BigInteger right)
  • public static BigInteger op_OnesComplement(BigInteger value)
  • public static BigInteger op_RightShift(BigInteger value, int shift)
  • public static BigInteger op_Subtraction(BigInteger left, BigInteger right)
  • public static BigInteger op_UnaryNegation(BigInteger value)
  • public static BigInteger op_UnaryPlus(BigInteger value)
  • public static BigInteger Parse(string value, NumberStyles style, IFormatProvider provider)
  • public static BigInteger Parse(string value, IFormatProvider provider)
  • public static BigInteger Parse(string value, NumberStyles style)
  • public static BigInteger PositiveMod(BigInteger dividend, BigInteger divisor)
  • public static BigInteger Pow(BigInteger value, int exponent)
  • public static BigInteger Random(int bitLength)
  • public static BigInteger Remainder(BigInteger dividend, BigInteger divisor)
  • public static BigInteger Subtract(BigInteger left, BigInteger right)
  • public static bool TryParse(string value, NumberStyles style, CultureInfo cultureInfo, out BigInteger result)
  • public static bool TryParse(string value, out BigInteger result)
  • public int CompareTo(object obj)
  • public int CompareTo(BigInteger other)
  • public int CompareTo(ulong other)
  • public int CompareTo(long other)
  • public bool Equals(BigInteger other)
  • public bool Equals(long other)
  • public bool Equals(ulong other)
  • public byte[] ToByteArray()
  • public string ToString(IFormatProvider provider)
  • public string ToString(string format)
  • public string ToString(string format, IFormatProvider provider)
• public class DerData
  • public bool IsEndOfData { get; }
  • public DerData()
  • public DerData(byte[] data)
  • public byte[] Encode()
  • public BigInteger ReadBigInteger()
  • public int ReadInteger()
  • public void Write(bool data)
  • public void Write(uint data)
  • public void Write(BigInteger data)
  • public void Write(byte[] data)
  • public void Write(ObjectIdentifier identifier)
  • public void Write(DerData data)
  • public void WriteNull()
• public class ExceptionEventArgs : EventArgs
  • public Exception Exception { get; }
  • public ExceptionEventArgs(Exception exception)
• public static class Extensions
• public class HostKeyEventArgs : EventArgs
  • public bool CanTrust { get; set; }
  • public byte[] FingerPrint { get; }
  • public byte[] HostKey { get; }
  • public string HostKeyName { get; }
  • public int KeyLength { get; }
  • public HostKeyEventArgs(KeyHostAlgorithm host)
• public struct ObjectIdentifier
  • public ulong[] Identifiers { get; }
  • public ObjectIdentifier(ulong[] identifiers)
• public class PipeStream : Stream
  • public bool BlockLastReadBuffer { get; set; }
  • public long MaxBufferLength { get; set; }
  • public PipeStream()
• public class PortForwardEventArgs : EventArgs
  • public string OriginatorHost { get; }
  • public uint OriginatorPort { get; }
• public class ProxyException : SshException
  • public ProxyException()
  • public ProxyException(string message)
  • public ProxyException(string message, Exception innerException)
• public class ScpDownloadEventArgs : EventArgs
  • public long Downloaded { get; }
  • public string Filename { get; }
  • public long Size { get; }
  • public ScpDownloadEventArgs(string filename, long size, long downloaded)
• public class ScpException : SshException
  • public ScpException()
  • public ScpException(string message)
  • public ScpException(string message, Exception innerException)
• public class ScpUploadEventArgs : EventArgs
  • public string Filename { get; }
  • public long Size { get; }
  • public long Uploaded { get; }
  • public ScpUploadEventArgs(string filename, long size, long uploaded)
• public class SemaphoreLight
  • public int CurrentCount { get; }
  • public SemaphoreLight(int initialCount)
  • public int Release()
  • public int Release(int releaseCount)
  • public void Wait()
• public class SftpPathNotFoundException : SshException
  • public SftpPathNotFoundException()
  • public SftpPathNotFoundException(string message)
  • public SftpPathNotFoundException(string message, Exception innerException)
• public class SftpPermissionDeniedException : SshException
  • public SftpPermissionDeniedException()
  • public SftpPermissionDeniedException(string message)
  • public SftpPermissionDeniedException(string message, Exception innerException)
• public class ShellDataEventArgs : EventArgs
  • public byte[] Data { get; }
  • public string Line { get; }
  • public ShellDataEventArgs(byte[] data)
  • public ShellDataEventArgs(string line)
• public class SshAuthenticationException : SshException
  • public SshAuthenticationException()
  • public SshAuthenticationException(string message)
  • public SshAuthenticationException(string message, Exception innerException)
• public class SshConnectionException : SshException
  • public DisconnectReason DisconnectReason { get; }
  • public SshConnectionException()
  • public SshConnectionException(string message)
  • public SshConnectionException(string message, DisconnectReason disconnectReasonCode)
  • public SshConnectionException(string message, DisconnectReason disconnectReasonCode, Exception inner)
  • public SshConnectionException(string message, Exception innerException)
• public abstract class SshData
  • public bool IsEndOfData { get; }
  • protected virtual int ZeroReaderIndex { get; }
  • protected SshData()
  • public virtual byte[] GetBytes()
  • public void Load(byte[] value)
  • protected void LoadBytes(byte[] bytes)
  • protected abstract void LoadData()
  • protected string ReadAsciiString()
  • protected BigInteger ReadBigInt()
  • protected byte[] ReadBinaryString()
  • protected bool ReadBoolean()
  • protected byte ReadByte()
  • protected byte[] ReadBytes()
  • protected byte[] ReadBytes(int length)
  • protected IDictionary<string, string> ReadExtensionPair()
  • protected long ReadInt64()
  • protected string[] ReadNamesList()
  • protected string ReadString()
  • protected string ReadString(Encoding encoding)
  • protected ushort ReadUInt16()
  • protected uint ReadUInt32()
  • protected ulong ReadUInt64()
  • protected void ResetReader()
  • protected abstract void SaveData()
  • protected void Write(IEnumerable<byte> data)
  • protected void Write(byte data)
  • protected void Write(bool data)
  • protected void Write(ushort data)
  • protected void Write(uint data)
  • protected void Write(ulong data)
  • protected void Write(long data)
  • protected void Write(string data)
  • protected void Write(string data, Encoding encoding)
  • protected void Write(BigInteger data)
  • protected void Write(string[] data)
  • protected void Write(IDictionary<string, string> data)
  • protected void WriteAscii(string data)
  • protected void WriteBinaryString(byte[] data)
• public class SshException : Exception
  • public SshException()
  • public SshException(string message)
  • public SshException(string message, Exception inner)
• public class SshOperationTimeoutException : SshException
  • public SshOperationTimeoutException()
  • public SshOperationTimeoutException(string message)
  • public SshOperationTimeoutException(string message, Exception innerException)
• public class SshPassPhraseNullOrEmptyException : SshException
  • public SshPassPhraseNullOrEmptyException()
  • public SshPassPhraseNullOrEmptyException(string message)
  • public SshPassPhraseNullOrEmptyException(string message, Exception innerException)
• public enum TerminalModes
  • CS7 = 90
  • CS8 = 91
  • ECHO = 53
  • ECHOCTL = 60
  • ECHOE = 54
  • ECHOK = 55
  • ECHOKE = 61
  • ECHONL = 56
  • ICANON = 51
  • ICRNL = 36
  • IEXTEN = 59
  • IGNCR = 35
  • IGNPAR = 30
  • IMAXBEL = 41
  • INLCR = 34
  • INPCK = 32
  • ISIG = 50
  • ISTRIP = 33
  • IUCLC = 37
  • IXANY = 39
  • IXOFF = 40
  • IXON = 38
  • NOFLSH = 57
  • OCRNL = 73
  • OLCUC = 71
  • ONLCR = 72
  • ONLRET = 75
  • ONOCR = 74
  • OPOST = 70
  • PARENB = 92
  • PARMRK = 31
  • PARODD = 93
  • PENDIN = 62
  • TOSTOP = 58
  • TTY_OP_END = 0
  • TTY_OP_ISPEED = 128
  • TTY_OP_OSPEED = 129
  • VDISCARD = 18
  • VDSUSP = 11
  • VEOF = 5
  • VEOL = 6
  • VEOL2 = 7
  • VERASE = 3
  • VFLUSH = 15
  • VINTR = 1
  • VKILL = 4
  • VLNEXT = 14
  • VQUIT = 2
  • VREPRINT = 12
  • VSTART = 8
  • VSTATUS = 17
  • VSTOP = 9
  • VSUSP = 10
  • VSWTCH = 16
  • VWERASE = 13
  • XCASE = 52

Renci.SshNet.Compression

• public enum CompressionMode
  • Compress = 0
  • Decompress = 1
• public abstract class Compressor : Algorithm, IDisposable
  • protected bool IsActive { get; protected set; }
  • protected Session Session { get; }
  • public Compressor()
  • public virtual byte[] Compress(byte[] data)
  • public virtual byte[] Decompress(byte[] data)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public virtual void Init(Session session)
• public class ZlibOpenSsh : Compressor
  • public ZlibOpenSsh()
• public class ZlibStream
  • public ZlibStream(Stream stream, CompressionMode mode)
  • public void Write(byte[] buffer, int offset, int count)

Renci.SshNet.Messages

• public abstract class Message : SshData
  • protected Message()
• public sealed class MessageAttribute : Attribute
  • public string Name { get; set; }
  • public byte Number { get; set; }
  • public MessageAttribute(string name, byte number)
• public enum ServiceName
  • Connection = 1
  • UserAuthentication = 0

Renci.SshNet.Messages.Authentication

• public class BannerMessage : Message
  • public string Language { get; }
  • public string Message { get; }
  • public BannerMessage()
• public class FailureMessage : Message
  • public string[] AllowedAuthentications { get; set; }
  • public string Message { get; }
  • public bool PartialSuccess { get; }
  • public FailureMessage()
• public class RequestMessage : Message
  • public virtual string MethodName { get; }
  • public ServiceName ServiceName { get; }
  • public string Username { get; }
  • public RequestMessage(ServiceName serviceName, string username)
• public class RequestMessagePublicKey : RequestMessage
  • public string PublicKeyAlgorithmName { get; }
  • public byte[] PublicKeyData { get; }
  • public byte[] Signature { get; set; }
  • public RequestMessagePublicKey(ServiceName serviceName, string username, string keyAlgorithmName, byte[] keyData)
  • public RequestMessagePublicKey(ServiceName serviceName, string username, string keyAlgorithmName, byte[] keyData, byte[] signature)
• public class SuccessMessage : Message
  • public SuccessMessage()

Renci.SshNet.Messages.Connection

• public class ChannelCloseMessage : ChannelMessage
  • public ChannelCloseMessage()
  • public ChannelCloseMessage(uint localChannelNumber)
• public class ChannelDataMessage : ChannelMessage
  • public byte[] Data { get; protected set; }
  • public ChannelDataMessage()
  • public ChannelDataMessage(uint localChannelNumber, byte[] data)
• public class ChannelEofMessage : ChannelMessage
  • public ChannelEofMessage()
  • public ChannelEofMessage(uint localChannelNumber)
• public class ChannelExtendedDataMessage : ChannelMessage
  • public byte[] Data { get; }
  • public uint DataTypeCode { get; }
  • public ChannelExtendedDataMessage()
  • public ChannelExtendedDataMessage(uint localChannelNumber, uint dataTypeCode, byte[] data)
• public class ChannelFailureMessage : ChannelMessage
  • public ChannelFailureMessage()
  • public ChannelFailureMessage(uint localChannelNumber)
• public abstract class ChannelMessage : Message
  • public uint LocalChannelNumber { get; protected set; }
  • protected ChannelMessage()
• public class ChannelOpenConfirmationMessage : ChannelMessage
  • public uint InitialWindowSize { get; }
  • public uint MaximumPacketSize { get; }
  • public uint RemoteChannelNumber { get; }
  • public ChannelOpenConfirmationMessage()
  • public ChannelOpenConfirmationMessage(uint localChannelNumber, uint initialWindowSize, uint maximumPacketSize, uint remoteChannelNumber)
• public class ChannelOpenFailureMessage : ChannelMessage
  • public string Description { get; }
  • public string Language { get; }
  • public uint ReasonCode { get; }
  • public ChannelOpenFailureMessage()
  • public ChannelOpenFailureMessage(uint localChannelNumber, string description, uint reasonCode)
• public abstract class ChannelOpenInfo : SshData
  • public abstract string ChannelType { get; }
  • protected ChannelOpenInfo()
• public class ChannelOpenMessage : ChannelMessage
  • public string ChannelType { get; }
  • public ChannelOpenInfo Info { get; }
  • public uint InitialWindowSize { get; }
  • public uint MaximumPacketSize { get; }
  • public ChannelOpenMessage()
  • public ChannelOpenMessage(uint channelNumber, uint initialWindowSize, uint maximumPacketSize, ChannelOpenInfo info)
• public class ChannelRequestMessage : ChannelMessage
  • public byte[] RequestData { get; }
  • public string RequestName { get; }
  • public ChannelRequestMessage()
  • public ChannelRequestMessage(uint localChannelName, RequestInfo info)
• public class ChannelSuccessMessage : ChannelMessage
  • public ChannelSuccessMessage()
  • public ChannelSuccessMessage(uint localChannelNumber)
• public class ChannelWindowAdjustMessage : ChannelMessage
  • public uint BytesToAdd { get; }
  • public ChannelWindowAdjustMessage()
  • public ChannelWindowAdjustMessage(uint localChannelNumber, uint bytesToAdd)
• public class EndOfWriteRequestInfo : RequestInfo
  • public const string NAME = "eow@openssh.com"
  • public EndOfWriteRequestInfo()
• public class GlobalRequestMessage : Message
  • public string AddressToBind { get; }
  • public uint PortToBind { get; }
  • public GlobalRequestName RequestName { get; }
  • public bool WantReply { get; }
  • public GlobalRequestMessage()
  • public GlobalRequestMessage(GlobalRequestName requestName, bool wantReply)
  • public GlobalRequestMessage(GlobalRequestName requestName, bool wantReply, string addressToBind, uint portToBind)
• public enum GlobalRequestName
  • CancelTcpIpForward = 1
  • TcpIpForward = 0
• public class KeepAliveRequestInfo : RequestInfo
  • public const string NAME = "keepalive@openssh.com"
  • public KeepAliveRequestInfo()
• public class RequestFailureMessage : Message
  • public RequestFailureMessage()
• public abstract class RequestInfo : SshData
  • public abstract string RequestName { get; }
  • public bool WantReply { get; protected set; }
  • protected RequestInfo()
• public class RequestSuccessMessage : Message
  • public uint? BoundPort { get; }
  • public RequestSuccessMessage()
  • public RequestSuccessMessage(uint boundPort)

Renci.SshNet.Messages.Transport

• public class DebugMessage : Message
  • public bool IsAlwaysDisplay { get; }
  • public string Language { get; }
  • public string Message { get; }
  • public DebugMessage()
• public class DisconnectMessage : Message, IKeyExchangedAllowed
  • public string Description { get; }
  • public string Language { get; }
  • public DisconnectReason ReasonCode { get; }
  • public DisconnectMessage()
  • public DisconnectMessage(DisconnectReason reasonCode, string message)
• public enum DisconnectReason
  • AuthenticationCanceledByUser = 13
  • ByApplication = 11
  • CompressionError = 6
  • ConnectionLost = 10
  • HostKeyNotVerifiable = 9
  • HostNotAllowedToConnect = 1
  • IllegalUserName = 15
  • KeyExchangeFailed = 3
  • MacError = 5
  • NoMoreAuthenticationMethodsAvailable = 14
  • None = 0
  • ProtocolError = 2
  • ProtocolVersionNotSupported = 8
  • Reserved = 4
  • ServiceNotAvailable = 7
  • TooManyConnections = 12
• public class IgnoreMessage : Message
  • public byte[] Data { get; }
  • public IgnoreMessage()
  • public IgnoreMessage(byte[] data)
• public interface IKeyExchangedAllowed
• public class KeyExchangeDhGroupExchangeGroup : Message
  • public BigInteger SafePrime { get; }
  • public BigInteger SubGroup { get; }
  • public KeyExchangeDhGroupExchangeGroup()
• public class KeyExchangeDhReplyMessage : Message
  • public BigInteger F { get; }
  • public byte[] HostKey { get; }
  • public byte[] Signature { get; }
  • public KeyExchangeDhReplyMessage()
• public class KeyExchangeEcdhReplyMessage : Message
  • public byte[] KS { get; }
  • public byte[] QS { get; }
  • public byte[] Signature { get; }
  • public KeyExchangeEcdhReplyMessage()
• public class KeyExchangeInitMessage : Message, IKeyExchangedAllowed
  • public string[] CompressionAlgorithmsClientToServer { get; set; }
  • public string[] CompressionAlgorithmsServerToClient { get; set; }
  • public byte[] Cookie { get; }
  • public string[] EncryptionAlgorithmsClientToServer { get; set; }
  • public string[] EncryptionAlgorithmsServerToClient { get; set; }
  • public bool FirstKexPacketFollows { get; set; }
  • public string[] KeyExchangeAlgorithms { get; set; }
  • public string[] LanguagesClientToServer { get; set; }
  • public string[] LanguagesServerToClient { get; set; }
  • public string[] MacAlgorithmsClientToServer { get; set; }
  • public string[] MacAlgorithmsServerToClient { get; set; }
  • public uint Reserved { get; set; }
  • public string[] ServerHostKeyAlgorithms { get; set; }
  • public KeyExchangeInitMessage()
• public class NewKeysMessage : Message, IKeyExchangedAllowed
  • public NewKeysMessage()
• public class ServiceAcceptMessage : Message
  • public ServiceName ServiceName { get; }
  • public ServiceAcceptMessage()
• public class ServiceRequestMessage : Message
  • public ServiceName ServiceName { get; }
  • public ServiceRequestMessage(ServiceName serviceName)
• public class UnimplementedMessage : Message
  • public UnimplementedMessage()

Renci.SshNet.Security

• public abstract class Algorithm
  • public abstract string Name { get; }
  • protected Algorithm()
• public class CertificateHostAlgorithm : HostAlgorithm
  • public CertificateHostAlgorithm(string name)
• public class DsaKey : Key, IDisposable
  • public BigInteger G { get; }
  • public BigInteger P { get; }
  • public BigInteger Q { get; }
  • public BigInteger X { get; }
  • public BigInteger Y { get; }
  • public DsaKey()
  • public DsaKey(byte[] data)
  • public DsaKey(BigInteger p, BigInteger q, BigInteger g, BigInteger y, BigInteger x)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public abstract class HostAlgorithm
  • public abstract byte[] Data { get; }
  • public string Name { get; }
  • public HostAlgorithm(string name)
  • public abstract byte[] Sign(byte[] data)
  • public abstract bool VerifySignature(byte[] data, byte[] signature)
• public abstract class Key
  • protected BigInteger[] _privateKey
  • protected abstract DigitalSignature DigitalSignature { get; }
  • public abstract int KeyLength { get; }
  • public abstract BigInteger[] Public { get; set; }
  • public Key(byte[] data)
  • public Key()
  • public byte[] Sign(byte[] data)
  • public bool VerifySignature(byte[] data, byte[] signature)
• public abstract class KeyExchange : Algorithm, IDisposable
  • public byte[] ExchangeHash { get; }
  • protected Session Session { get; }
  • public BigInteger SharedKey { get; protected set; }
  • public event EventHandler<HostKeyEventArgs> HostKeyReceived
  • protected KeyExchange()
  • protected abstract byte[] CalculateHash()
  • protected bool CanTrustHostKey(KeyHostAlgorithm host)
  • public Cipher CreateClientCipher()
  • public HashAlgorithm CreateClientHash()
  • public Compressor CreateCompressor()
  • public Compressor CreateDecompressor()
  • public Cipher CreateServerCipher()
  • public HashAlgorithm CreateServerHash()
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • public virtual void Finish()
  • protected virtual byte[] Hash(byte[] hashData)
  • protected void SendMessage(Message message)
  • public virtual void Start(Session session, KeyExchangeInitMessage message)
  • protected abstract bool ValidateExchangeHash()
• public abstract class KeyExchangeDiffieHellman : KeyExchange
  • protected BigInteger _clientExchangeValue
  • protected byte[] _clientPayload
  • protected BigInteger _group
  • protected byte[] _hostKey
  • protected BigInteger _prime
  • protected BigInteger _randomValue
  • protected BigInteger _serverExchangeValue
  • protected byte[] _serverPayload
  • protected byte[] _signature
  • protected KeyExchangeDiffieHellman()
  • protected virtual void HandleServerDhReply(byte[] hostKey, BigInteger serverExchangeValue, byte[] signature)
  • protected void PopulateClientExchangeValue()
• public class KeyExchangeDiffieHellmanGroup1Sha1 : KeyExchangeDiffieHellmanGroupSha1
  • public KeyExchangeDiffieHellmanGroup1Sha1()
• public class KeyExchangeDiffieHellmanGroupExchangeSha256 : KeyExchangeDiffieHellman
  • public KeyExchangeDiffieHellmanGroupExchangeSha256()
• public abstract class KeyExchangeDiffieHellmanGroupSha1 : KeyExchangeDiffieHellman
  • public abstract BigInteger GroupPrime { get; }
  • protected KeyExchangeDiffieHellmanGroupSha1()
• public class KeyExchangeEllipticCurveDiffieHellman : KeyExchange
  • protected BigInteger _clientExchangeValue
  • protected byte[] _clientPayload
  • protected byte[] _hostKey
  • protected BigInteger _randomValue
  • protected BigInteger _serverExchangeValue
  • protected byte[] _serverPayload
  • protected byte[] _signature
  • public KeyExchangeEllipticCurveDiffieHellman()
  • protected virtual void HandleServerEcdhReply()
• public class KeyHostAlgorithm : HostAlgorithm
  • public Key Key { get; }
  • public KeyHostAlgorithm(string name, Key key)
  • public KeyHostAlgorithm(string name, Key key, byte[] data)
• public class RsaKey : Key, IDisposable
  • public BigInteger D { get; }
  • public BigInteger DP { get; }
  • public BigInteger DQ { get; }
  • public BigInteger Exponent { get; }
  • public BigInteger InverseQ { get; }
  • public BigInteger Modulus { get; }
  • public BigInteger P { get; }
  • public BigInteger Q { get; }
  • public RsaKey()
  • public RsaKey(byte[] data)
  • public RsaKey(BigInteger modulus, BigInteger exponent, BigInteger d, BigInteger p, BigInteger q, BigInteger inverseQ)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)

Renci.SshNet.Security.Cryptography

• public abstract class AsymmetricCipher : Cipher
  • protected AsymmetricCipher()
• public abstract class BlockCipher : SymmetricCipher
  • protected readonly byte _blockSize
  • public byte BlockSize { get; }
  • protected BlockCipher(byte[] key, byte blockSize, CipherMode mode, CipherPadding padding)
• public abstract class Cipher
  • public abstract byte MinimumSize { get; }
  • protected Cipher()
  • protected static uint BigEndianToUInt32(byte[] buffer)
  • protected static uint BigEndianToUInt32(byte[] buffer, int offset)
  • protected static ulong BigEndianToUInt64(byte[] buffer)
  • protected static ulong BigEndianToUInt64(byte[] buffer, int offset)
  • protected static uint LittleEndianToUInt32(byte[] buffer)
  • protected static uint LittleEndianToUInt32(byte[] buffer, int offset)
  • protected static ulong LittleEndianToUInt64(byte[] buffer)
  • protected static ulong LittleEndianToUInt64(byte[] buffer, int offset)
  • protected static void UInt32ToBigEndian(uint number, byte[] buffer)
  • protected static void UInt32ToBigEndian(uint number, byte[] buffer, int offset)
  • protected static void UInt32ToLittleEndian(uint number, byte[] buffer)
  • protected static void UInt32ToLittleEndian(uint number, byte[] buffer, int offset)
  • protected static void UInt64ToBigEndian(ulong number, byte[] buffer)
  • protected static void UInt64ToBigEndian(ulong number, byte[] buffer, int offset)
  • protected static void UInt64ToLittleEndian(ulong number, byte[] buffer)
  • protected static void UInt64ToLittleEndian(ulong number, byte[] buffer, int offset)
  • public abstract byte[] Decrypt(byte[] input)
  • public abstract byte[] Encrypt(byte[] input)
• public abstract class CipherDigitalSignature : DigitalSignature
  • public CipherDigitalSignature(ObjectIdentifier oid, AsymmetricCipher cipher)
  • protected byte[] DerEncode(byte[] hashData)
  • protected abstract byte[] Hash(byte[] input)
• public abstract class DigitalSignature
  • protected DigitalSignature()
  • public abstract byte[] Sign(byte[] input)
  • public abstract bool Verify(byte[] input, byte[] signature)
• public class DsaDigitalSignature : DigitalSignature, IDisposable
  • public DsaDigitalSignature(DsaKey key)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class HMac<T> : KeyedHashAlgorithm where T : HashAlgorithm
  • protected int BlockSize { get; }
  • public HMac(byte[] key, int hashSizeValue)
  • public HMac(byte[] key)
• public sealed class MD5Hash : HashAlgorithm
  • public MD5Hash()
• public sealed class RIPEMD160Hash : HashAlgorithm
  • public RIPEMD160Hash()
• public class RsaDigitalSignature : CipherDigitalSignature, IDisposable
  • public RsaDigitalSignature(RsaKey rsaKey)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public sealed class SHA1Hash : HashAlgorithm
  • public SHA1Hash()
• public class SHA256Hash : HashAlgorithm
  • public SHA256Hash()
• public abstract class SHA2HashBase : HashAlgorithm
  • protected ulong H1
  • protected ulong H2
  • protected ulong H3
  • protected ulong H4
  • protected ulong H5
  • protected ulong H6
  • protected ulong H7
  • protected ulong H8
  • public SHA2HashBase()
  • protected static uint BE_To_UInt32(byte[] bs, int off)
  • protected static uint BE_To_UInt32(byte[] bs)
  • protected static ulong BE_To_UInt64(byte[] bs)
  • protected static ulong BE_To_UInt64(byte[] bs, int off)
  • protected static void UInt32_To_BE(uint n, byte[] bs, int off)
  • protected static void UInt64_To_BE(ulong n, byte[] bs, int off)
  • protected void Finish()
• public class SHA384Hash : SHA2HashBase
  • public SHA384Hash()
• public class SHA512Hash : SHA2HashBase
  • public SHA512Hash()
• public abstract class StreamCipher : SymmetricCipher
  • protected StreamCipher(byte[] key)
• public abstract class SymmetricCipher : Cipher
  • protected byte[] Key { get; }
  • protected SymmetricCipher(byte[] key)
  • public abstract int DecryptBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
  • public abstract int EncryptBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)

Renci.SshNet.Security.Cryptography.Ciphers

• public sealed class AesCipher : BlockCipher
  • public AesCipher(byte[] key, CipherMode mode, CipherPadding padding)
• public sealed class Arc4Cipher : StreamCipher
  • public Arc4Cipher(byte[] key, bool dischargeFirstBytes)
• public sealed class BlowfishCipher : BlockCipher
  • public BlowfishCipher(byte[] key, CipherMode mode, CipherPadding padding)
• public sealed class CastCipher : BlockCipher
  • public CastCipher(byte[] key, CipherMode mode, CipherPadding padding)
• public abstract class CipherMode
  • protected int _blockSize
  • protected BlockCipher Cipher
  • protected byte[] IV
  • protected CipherMode(byte[] iv)
  • public abstract int DecryptBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
  • public abstract int EncryptBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
• public abstract class CipherPadding
  • protected CipherPadding()
  • public abstract byte[] Pad(int blockSize, byte[] input)
• public class DesCipher : BlockCipher
  • public DesCipher(byte[] key, CipherMode mode, CipherPadding padding)
  • protected static void DesFunc(int[] wKey, byte[] input, int inOff, byte[] outBytes, int outOff)
  • protected int[] GenerateWorkingKey(bool encrypting, byte[] key)
  • protected virtual void ValidateKey()
• public class RsaCipher : AsymmetricCipher
  • public RsaCipher(RsaKey key)
• public sealed class SerpentCipher : BlockCipher
  • public SerpentCipher(byte[] key, CipherMode mode, CipherPadding padding)
• public sealed class TripleDesCipher : DesCipher
  • public TripleDesCipher(byte[] key, CipherMode mode, CipherPadding padding)
• public sealed class TwofishCipher : BlockCipher
  • public TwofishCipher(byte[] key, CipherMode mode, CipherPadding padding)

Renci.SshNet.Security.Cryptography.Ciphers.Modes

• public class CbcCipherMode : CipherMode
  • public CbcCipherMode(byte[] iv)
• public class CfbCipherMode : CipherMode
  • public CfbCipherMode(byte[] iv)
• public class CtrCipherMode : CipherMode
  • public CtrCipherMode(byte[] iv)
• public class OfbCipherMode : CipherMode
  • public OfbCipherMode(byte[] iv)

Renci.SshNet.Security.Cryptography.Ciphers.Paddings

• public class PKCS7Padding : CipherPadding
  • public PKCS7Padding()

Renci.SshNet.Sftp

• public class SftpDownloadAsyncResult : AsyncResult
  • public ulong DownloadedBytes { get; }
  • public bool IsDownloadCanceled { get; set; }
  • public SftpDownloadAsyncResult(AsyncCallback asyncCallback, object state)
• public class SftpFile
  • public SftpFileAttributes Attributes { get; }
  • public IDictionary<string, string> Extensions { get; }
  • public string FullName { get; }
  • public bool GroupCanExecute { get; set; }
  • public bool GroupCanRead { get; set; }
  • public bool GroupCanWrite { get; set; }
  • public int GroupId { get; set; }
  • public bool IsBlockDevice { get; }
  • public bool IsCharacterDevice { get; }
  • public bool IsDirectory { get; }
  • public bool IsNamedPipe { get; }
  • public bool IsRegularFile { get; }
  • public bool IsSocket { get; }
  • public bool IsSymbolicLink { get; }
  • public DateTime LastAccessTime { get; set; }
  • public DateTime LastAccessTimeUtc { get; set; }
  • public DateTime LastWriteTime { get; set; }
  • public DateTime LastWriteTimeUtc { get; set; }
  • public long Length { get; }
  • public string Name { get; }
  • public bool OthersCanExecute { get; set; }
  • public bool OthersCanRead { get; set; }
  • public bool OthersCanWrite { get; set; }
  • public bool OwnerCanExecute { get; set; }
  • public bool OwnerCanRead { get; set; }
  • public bool OwnerCanWrite { get; set; }
  • public int UserId { get; set; }
  • public void Delete()
  • public void MoveTo(string destFileName)
  • public void SetPermissions(short mode)
  • public void UpdateStatus()
• public class SftpFileAttributes
  • public IDictionary<string, string> Extensions { get; }
  • public bool GroupCanExecute { get; set; }
  • public bool GroupCanRead { get; set; }
  • public bool GroupCanWrite { get; set; }
  • public int GroupId { get; set; }
  • public bool IsBlockDevice { get; }
  • public bool IsCharacterDevice { get; }
  • public bool IsDirectory { get; }
  • public bool IsNamedPipe { get; }
  • public bool IsRegularFile { get; }
  • public bool IsSocket { get; }
  • public bool IsSymbolicLink { get; }
  • public DateTime LastAccessTime { get; set; }
  • public DateTime LastWriteTime { get; set; }
  • public bool OthersCanExecute { get; set; }
  • public bool OthersCanRead { get; set; }
  • public bool OthersCanWrite { get; set; }
  • public bool OwnerCanExecute { get; set; }
  • public bool OwnerCanRead { get; set; }
  • public bool OwnerCanWrite { get; set; }
  • public long Size { get; set; }
  • public int UserId { get; set; }
  • public void SetPermissions(short mode)
• public class SftpFileStream : Stream
  • public virtual byte[] Handle { get; }
  • public virtual bool IsAsync { get; }
  • public string Name { get; }
  • public TimeSpan Timeout { get; set; }
• public class SftpFileSytemInformation
  • public ulong AvailableBlocks { get; }
  • public ulong AvailableNodes { get; }
  • public ulong BlockSize { get; }
  • public ulong FreeBlocks { get; }
  • public ulong FreeNodes { get; }
  • public bool IsReadOnly { get; }
  • public ulong MaxNameLenght { get; }
  • public ulong Sid { get; }
  • public bool SupportsSetUid { get; }
  • public ulong TotalBlocks { get; }
  • public ulong TotalNodes { get; }
• public class SftpListDirectoryAsyncResult : AsyncResult<IEnumerable<SftpFile>>
  • public int FilesRead { get; }
  • public SftpListDirectoryAsyncResult(AsyncCallback asyncCallback, object state)
• public class SftpUploadAsyncResult : AsyncResult
  • public bool IsUploadCanceled { get; set; }
  • public ulong UploadedBytes { get; }
  • public SftpUploadAsyncResult(AsyncCallback asyncCallback, object state)
• public abstract class SubsystemSession : IDisposable
  • protected TimeSpan _operationTimeout
  • protected uint ChannelNumber { get; }
  • protected Encoding Encoding { get; }
  • public event EventHandler<EventArgs> Disconnected
  • public event EventHandler<ExceptionEventArgs> ErrorOccurred
  • public SubsystemSession(Session session, string subsystemName, TimeSpan operationTimeout, Encoding encoding)
  • public void Connect()
  • public void Disconnect()
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • protected abstract void OnChannelOpen()
  • protected abstract void OnDataReceived(uint dataTypeCode, byte[] data)
  • protected void RaiseError(Exception error)
  • public void SendData(byte[] data)