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

---

API Differences between 2024.1.0 and 2013.1.27

406 Additions 191 Removals

Renci.SshNet

• public abstract class AuthenticationMethod : IAuthenticationMethod
  • public IEnumerable<string> AllowedAuthentications { get; protected set; }
  • public string ErrorMessage { get; }
  • public string[] AllowedAuthentications { get; protected set; }
• public abstract class BaseClient : IBaseClient, IDisposable
  • protected Session Session { get; }
  • public BaseClient(ConnectionInfo connectionInfo)
  • public event EventHandler<SshIdentificationEventArgs> ServerIdentificationReceived
  • protected BaseClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo)
  • protected void CheckDisposed()
  • public Task ConnectAsync(CancellationToken cancellationToken)
• public class CipherInfo
  • public bool IsAead { get; }
  • public CipherInfo(int keySize, Func<byte[], byte[], Cipher> cipher)
  • public CipherInfo(int keySize, Func<byte[], byte[], Cipher> cipher, bool isAead = false)
• public class CommandAsyncResult : IAsyncResult
• public class ConnectionInfo : IConnectionInfoInternal, IConnectionInfo
  • public IEnumerable<AuthenticationMethod> AuthenticationMethods { get; }
  • public IList<AuthenticationMethod> AuthenticationMethods { get; }
  • public TimeSpan ChannelCloseTimeout { get; set; }
  • public IDictionary<string, Type> CompressionAlgorithms { get; }
  • public IDictionary<string, Func<Compressor>> CompressionAlgorithms { get; }
  • public IDictionary<string, Type> KeyExchangeAlgorithms { get; }
  • public IDictionary<string, Func<IKeyExchange>> KeyExchangeAlgorithms { get; }
  • public bool Authenticate(Session session)
• public class ExpectAsyncResult : AsyncResult<string>
• public static class Extensions
• public abstract class ForwardedPort : IForwardedPort, IDisposable
  • public event EventHandler Closing
  • protected abstract void CheckDisposed()
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
  • protected abstract void StartPort()
  • protected virtual void StopPort(TimeSpan timeout)
• public class ForwardedPortDynamic : ForwardedPort
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class ForwardedPortLocal : ForwardedPort
  • public ForwardedPortLocal(string boundHost, string host, uint port)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class ForwardedPortRemote : ForwardedPort
  • public IPAddress BoundHostAddress { get; }
  • public IPAddress HostAddress { get; }
  • public ForwardedPortRemote(IPAddress boundHostAddress, uint boundPort, IPAddress hostAddress, uint port)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class HashInfo
  • public bool IsEncryptThenMAC { get; }
  • public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash)
  • public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash, bool isEncryptThenMAC = false)
• public interface IBaseClient : IDisposable
  • ConnectionInfo ConnectionInfo { get; }
  • bool IsConnected { get; }
  • TimeSpan KeepAliveInterval { get; set; }
  • event EventHandler<ExceptionEventArgs> ErrorOccurred
  • event EventHandler<HostKeyEventArgs> HostKeyReceived
  • void Connect()
  • Task ConnectAsync(CancellationToken cancellationToken)
  • void Disconnect()
  • void SendKeepAlive()
• public interface IForwardedPort : IDisposable
  • event EventHandler Closing
• public interface IPrivateKeySource
  • IReadOnlyCollection<HostAlgorithm> HostKeyAlgorithms { get; }
• public interface IRemotePathTransformation
  • string Transform(string path)
• public interface ISftpClient : IBaseClient, IDisposable
  • uint BufferSize { get; set; }
  • TimeSpan OperationTimeout { get; set; }
  • int ProtocolVersion { get; }
  • string WorkingDirectory { get; }
  • void AppendAllLines(string path, IEnumerable<string> contents)
  • void AppendAllLines(string path, IEnumerable<string> contents, Encoding encoding)
  • void AppendAllText(string path, string contents)
  • void AppendAllText(string path, string contents, Encoding encoding)
  • StreamWriter AppendText(string path)
  • StreamWriter AppendText(string path, Encoding encoding)
  • IAsyncResult BeginDownloadFile(string path, Stream output)
  • IAsyncResult BeginDownloadFile(string path, Stream output, AsyncCallback asyncCallback)
  • IAsyncResult BeginDownloadFile(string path, Stream output, AsyncCallback asyncCallback, object state, Action<ulong> downloadCallback = null)
  • IAsyncResult BeginListDirectory(string path, AsyncCallback asyncCallback, object state, Action<int> listCallback = null)
  • IAsyncResult BeginSynchronizeDirectories(string sourcePath, string destinationPath, string searchPattern, AsyncCallback asyncCallback, object state)
  • IAsyncResult BeginUploadFile(Stream input, string path)
  • IAsyncResult BeginUploadFile(Stream input, string path, AsyncCallback asyncCallback)
  • IAsyncResult BeginUploadFile(Stream input, string path, AsyncCallback asyncCallback, object state, Action<ulong> uploadCallback = null)
  • IAsyncResult BeginUploadFile(Stream input, string path, bool canOverride, AsyncCallback asyncCallback, object state, Action<ulong> uploadCallback = null)
  • void ChangeDirectory(string path)
  • void ChangePermissions(string path, short mode)
  • SftpFileStream Create(string path)
  • SftpFileStream Create(string path, int bufferSize)
  • void CreateDirectory(string path)
  • StreamWriter CreateText(string path)
  • StreamWriter CreateText(string path, Encoding encoding)
  • void Delete(string path)
  • void DeleteDirectory(string path)
  • void DeleteFile(string path)
  • Task DeleteFileAsync(string path, CancellationToken cancellationToken)
  • void DownloadFile(string path, Stream output, Action<ulong> downloadCallback = null)
  • void EndDownloadFile(IAsyncResult asyncResult)
  • IEnumerable<ISftpFile> EndListDirectory(IAsyncResult asyncResult)
  • IEnumerable<FileInfo> EndSynchronizeDirectories(IAsyncResult asyncResult)
  • void EndUploadFile(IAsyncResult asyncResult)
  • bool Exists(string path)
  • ISftpFile Get(string path)
  • SftpFileAttributes GetAttributes(string path)
  • DateTime GetLastAccessTime(string path)
  • DateTime GetLastAccessTimeUtc(string path)
  • DateTime GetLastWriteTime(string path)
  • DateTime GetLastWriteTimeUtc(string path)
  • SftpFileSystemInformation GetStatus(string path)
  • Task<SftpFileSystemInformation> GetStatusAsync(string path, CancellationToken cancellationToken)
  • IEnumerable<ISftpFile> ListDirectory(string path, Action<int> listCallback = null)
  • IAsyncEnumerable<ISftpFile> ListDirectoryAsync(string path, CancellationToken cancellationToken)
  • SftpFileStream Open(string path, FileMode mode)
  • SftpFileStream Open(string path, FileMode mode, FileAccess access)
  • Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
  • SftpFileStream OpenRead(string path)
  • StreamReader OpenText(string path)
  • SftpFileStream OpenWrite(string path)
  • byte[] ReadAllBytes(string path)
  • string[] ReadAllLines(string path)
  • string[] ReadAllLines(string path, Encoding encoding)
  • string ReadAllText(string path)
  • string ReadAllText(string path, Encoding encoding)
  • IEnumerable<string> ReadLines(string path)
  • IEnumerable<string> ReadLines(string path, Encoding encoding)
  • void RenameFile(string oldPath, string newPath)
  • void RenameFile(string oldPath, string newPath, bool isPosix)
  • Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken)
  • void SetAttributes(string path, SftpFileAttributes fileAttributes)
  • void SetLastAccessTime(string path, DateTime lastAccessTime)
  • void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
  • void SetLastWriteTime(string path, DateTime lastWriteTime)
  • void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
  • void SymbolicLink(string path, string linkPath)
  • IEnumerable<FileInfo> SynchronizeDirectories(string sourcePath, string destinationPath, string searchPattern)
  • void UploadFile(Stream input, string path, Action<ulong> uploadCallback = null)
  • void UploadFile(Stream input, string path, bool canOverride, Action<ulong> uploadCallback = null)
  • void WriteAllBytes(string path, byte[] bytes)
  • void WriteAllLines(string path, IEnumerable<string> contents)
  • void WriteAllLines(string path, IEnumerable<string> contents, Encoding encoding)
  • void WriteAllLines(string path, string[] contents)
  • void WriteAllLines(string path, string[] contents, Encoding encoding)
  • void WriteAllText(string path, string contents)
  • void WriteAllText(string path, string contents, Encoding encoding)
• public class NetConfClient : BaseClient
  • public NetConfClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public NetConfClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public NetConfClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public NetConfClient(string host, string username, IPrivateKeySource[] keyFiles)
• public class PrivateKeyAuthenticationMethod : AuthenticationMethod, IDisposable
  • public ICollection<PrivateKeyFile> KeyFiles { get; }
  • public PrivateKeyAuthenticationMethod(string username, PrivateKeyFile[] keyFiles)
  • public ICollection<IPrivateKeySource> KeyFiles { get; }
  • public PrivateKeyAuthenticationMethod(string username, IPrivateKeySource[] keyFiles)
• public class PrivateKeyConnectionInfo : ConnectionInfo, IDisposable
  • public ICollection<PrivateKeyFile> KeyFiles { get; }
  • public ICollection<IPrivateKeySource> KeyFiles { get; }
  • 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 PrivateKeyConnectionInfo(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, IPrivateKeySource[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, IPrivateKeySource[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, IPrivateKeySource[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, IPrivateKeySource[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, IPrivateKeySource[] keyFiles)
  • public PrivateKeyConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, IPrivateKeySource[] keyFiles)
• public class PrivateKeyFile : IPrivateKeySource, IDisposable
  • public HostAlgorithm HostKey { get; }
  • public IReadOnlyCollection<HostAlgorithm> HostKeyAlgorithms { get; }
  • public Key Key { get; }
  • public PrivateKeyFile(Key key)
• public static class RemotePathTransformation
  • public static IRemotePathTransformation DoubleQuote { get; }
  • public static IRemotePathTransformation None { get; }
  • public static IRemotePathTransformation ShellQuote { get; }
• public class ScpClient : BaseClient
  • public IRemotePathTransformation RemotePathTransformation { get; set; }
  • 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 ScpClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public ScpClient(string host, string username, IPrivateKeySource[] keyFiles)
  • public void Download(string filename, Stream destination)
  • public void Upload(FileSystemInfo fileSystemInfo, string path)
  • public void Upload(FileInfo fileInfo, string path)
  • public void Upload(DirectoryInfo directoryInfo, string path)
• public class Session : ISession, IDisposable
  • protected const int MAXIMUM_PACKET_SIZE = 35000
  • protected const int MAXIMUM_PAYLOAD_SIZE = 32768
  • public SemaphoreLight SessionSemaphore { get; }
  • public SemaphoreSlim SessionSemaphore { get; }
  • public event EventHandler<MessageEventArgs<ChannelCloseMessage>> ChannelCloseReceived
  • public event EventHandler<MessageEventArgs<ChannelDataMessage>> ChannelDataReceived
  • public event EventHandler<MessageEventArgs<ChannelEofMessage>> ChannelEofReceived
  • public event EventHandler<MessageEventArgs<ChannelExtendedDataMessage>> ChannelExtendedDataReceived
  • public event EventHandler<MessageEventArgs<ChannelFailureMessage>> ChannelFailureReceived
  • public event EventHandler<MessageEventArgs<ChannelOpenConfirmationMessage>> ChannelOpenConfirmationReceived
  • public event EventHandler<MessageEventArgs<ChannelOpenFailureMessage>> ChannelOpenFailureReceived
  • public event EventHandler<MessageEventArgs<ChannelOpenMessage>> ChannelOpenReceived
  • public event EventHandler<MessageEventArgs<ChannelRequestMessage>> ChannelRequestReceived
  • public event EventHandler<MessageEventArgs<ChannelSuccessMessage>> ChannelSuccessReceived
  • public event EventHandler<MessageEventArgs<ChannelWindowAdjustMessage>> ChannelWindowAdjustReceived
  • public event EventHandler<MessageEventArgs<RequestFailureMessage>> RequestFailureReceived
  • public event EventHandler<MessageEventArgs<RequestSuccessMessage>> RequestSuccessReceived
  • public event EventHandler<SshIdentificationEventArgs> ServerIdentificationReceived
  • public event EventHandler<MessageEventArgs<BannerMessage>> UserAuthenticationBannerReceived
  • public Task ConnectAsync(CancellationToken cancellationToken)
  • 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 class SftpClient : BaseClient, ISftpClient, IBaseClient, IDisposable
  • public SftpClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public SftpClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public SftpClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public SftpClient(string host, string username, IPrivateKeySource[] keyFiles)
  • public Task DeleteFileAsync(string path, CancellationToken cancellationToken)
  • public IEnumerable<SftpFile> EndListDirectory(IAsyncResult asyncResult)
  • public IEnumerable<ISftpFile> EndListDirectory(IAsyncResult asyncResult)
  • public SftpFile Get(string path)
  • public ISftpFile Get(string path)
  • public SftpFileSytemInformation GetStatus(string path)
  • public IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback = null)
  • public SftpFileSystemInformation GetStatus(string path)
  • public Task<SftpFileSystemInformation> GetStatusAsync(string path, CancellationToken cancellationToken)
  • public IEnumerable<ISftpFile> ListDirectory(string path, Action<int> listCallback = null)
  • public IAsyncEnumerable<ISftpFile> ListDirectoryAsync(string path, CancellationToken cancellationToken)
  • public Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
  • public Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken)
• public class ShellStream : Stream
  • public event EventHandler<EventArgs> Closed
  • public IAsyncResult BeginExpect(TimeSpan timeout, int lookback, AsyncCallback callback, object state, ExpectAction[] expectActions)
  • public void Expect(TimeSpan timeout, int lookback, ExpectAction[] expectActions)
  • public string Expect(string text, TimeSpan timeout)
  • public string Expect(string text, TimeSpan timeout, int lookback = -1)
  • public string Expect(Regex regex, TimeSpan timeout)
  • public string Expect(Regex regex, TimeSpan timeout, int lookback = -1)
  • protected void WaitHandle(WaitHandle waitHandle)
• public class SshClient : BaseClient
  • public SshClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public SshClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public SshClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public SshClient(string host, string username, IPrivateKeySource[] keyFiles)
  • public Shell CreateShellNoTerminal(Stream input, Stream output, Stream extendedOutput, int bufferSize = -1)
  • public ShellStream CreateShellStreamNoTerminal(int bufferSize = -1)
• public class SshCommand : IDisposable
  • public int ExitStatus { get; }
  • public string ExitSignal { get; }
  • public int? ExitStatus { get; }
  • public void CancelAsync()
  • public void CancelAsync(bool forceKill = false, int millisecondsTimeout = 500)
  • public Stream CreateInputStream()
  • public Task ExecuteAsync(CancellationToken cancellationToken = default)

Renci.SshNet.Abstractions

• public static class DiagnosticAbstraction
  • public static readonly TraceSource Source
  • public static void Log(string text, TraceEventType type = 16)

Renci.SshNet.Common

• public class ASCIIEncoding : Encoding
• public abstract class AsyncResult : IAsyncResult
  • public void EndInvoke()
• public class AuthenticationPromptEventArgs : AuthenticationEventArgs
  • public IEnumerable<AuthenticationPrompt> Prompts { get; }
  • public AuthenticationPromptEventArgs(string username, string instruction, string language, IEnumerable<AuthenticationPrompt> prompts)
  • public IReadOnlyList<AuthenticationPrompt> Prompts { get; }
  • public AuthenticationPromptEventArgs(string username, string instruction, string language, IReadOnlyList<AuthenticationPrompt> prompts)
• public struct BigInteger : IComparable, IFormattable, IComparable<BigInteger>, IEquatable<BigInteger>
  • public BigInteger(short sign, uint[] data)
  • public static BigInteger Parse(string value, NumberStyles style, IFormatProvider provider)
  • public static BigInteger Parse(string value, IFormatProvider provider)
  • public static BigInteger Parse(string value)
  • public static BigInteger Parse(string value, IFormatProvider provider)
  • public static BigInteger Parse(string value, NumberStyles style, IFormatProvider provider)
  • public static bool TryParse(string value, NumberStyles style, CultureInfo cultureInfo, out BigInteger result)
  • public static bool TryParse(string value, NumberStyles style, IFormatProvider provider, out BigInteger result)
  • public string ToString(IFormatProvider provider)
  • public string ToString(IFormatProvider provider)
• public class DerData
  • public DerData(byte[] data)
  • public DerData(byte[] data, bool construct = false)
  • public byte[] ReadBitString()
  • public byte ReadByte()
  • public byte[] ReadBytes(int length)
  • public int ReadLength()
  • public byte[] ReadObject()
  • public byte[] ReadOctetString()
  • public void WriteBitstring(byte[] data)
  • public void WriteBytes(IEnumerable<byte> data)
  • public void WriteObjectIdentifier(byte[] bytes)
• public class HostKeyEventArgs : EventArgs
  • public string FingerPrintMD5 { get; }
  • public string FingerPrintSHA256 { get; }
• public class NetConfServerException : SshException
  • protected NetConfServerException(SerializationInfo info, StreamingContext context)
• public class PipeStream : Stream
  • public bool BlockLastReadBuffer { get; set; }
  • public long MaxBufferLength { get; set; }
• public class ProxyException : SshException
  • protected ProxyException(SerializationInfo info, StreamingContext context)
• public class ScpException : SshException
  • protected ScpException(SerializationInfo info, StreamingContext context)
• public class SemaphoreLight
• public class SftpPathNotFoundException : SshException
  • protected SftpPathNotFoundException(SerializationInfo info, StreamingContext context)
• public class SftpPermissionDeniedException : SshException
  • protected SftpPermissionDeniedException(SerializationInfo info, StreamingContext context)
• public class SshAuthenticationException : SshException
  • protected SshAuthenticationException(SerializationInfo info, StreamingContext context)
• public class SshConnectionException : SshException
  • public SshConnectionException(string message, DisconnectReason disconnectReasonCode, Exception inner)
  • protected SshConnectionException(SerializationInfo info, StreamingContext context)
  • public SshConnectionException(string message, DisconnectReason disconnectReasonCode, Exception inner)
• public abstract class SshData
  • protected virtual int BufferCapacity { get; }
  • protected SshDataStream DataStream { get; }
  • protected virtual int ZeroReaderIndex { get; }
  • protected void LoadBytes(byte[] bytes)
  • public void Load(byte[] data, int offset, int count)
  • protected string ReadAsciiString()
  • protected BigInteger ReadBigInt()
  • protected byte[] ReadBinaryString()
  • protected byte[] ReadBinary()
  • protected IDictionary<string, string> ReadExtensionPair()
  • protected long ReadInt64()
  • protected Dictionary<string, string> ReadExtensionPair()
  • protected string ReadString()
  • protected void ResetReader()
  • protected void Write(IEnumerable<byte> data)
  • protected void Write(byte[] data)
  • protected void Write(byte[] buffer, int offset, int count)
  • protected void Write(ushort data)
  • protected void Write(long data)
  • protected void WriteAscii(string data)
  • protected void WriteBinary(byte[] buffer, int offset, int count)
  • protected virtual void WriteBytes(SshDataStream stream)
• public class SshDataStream : MemoryStream
  • public bool IsEndOfData { get; }
  • public SshDataStream(int capacity)
  • public SshDataStream(byte[] buffer)
  • public SshDataStream(byte[] buffer, int offset, int count)
  • public BigInteger ReadBigInt()
  • public byte[] ReadBinary()
  • public string ReadString(Encoding encoding = null)
  • public ushort ReadUInt16()
  • public uint ReadUInt32()
  • public ulong ReadUInt64()
  • public void Write(uint value)
  • public void Write(ulong value)
  • public void Write(BigInteger data)
  • public void Write(byte[] data)
  • public void Write(string s, Encoding encoding)
  • public void WriteBinary(byte[] buffer)
  • public void WriteBinary(byte[] buffer, int offset, int count)
• public class SshException : Exception
  • protected SshException(SerializationInfo info, StreamingContext context)
• public class SshIdentificationEventArgs : EventArgs
  • public SshIdentification SshIdentification { get; }
  • public SshIdentificationEventArgs(SshIdentification sshIdentification)
• public class SshOperationTimeoutException : SshException
  • protected SshOperationTimeoutException(SerializationInfo info, StreamingContext context)
• public class SshPassPhraseNullOrEmptyException : SshException
  • protected SshPassPhraseNullOrEmptyException(SerializationInfo info, StreamingContext context)
• public enum TerminalModes
  • IUTF8 = 42

Renci.SshNet.Compression

• public enum CompressionMode
• public abstract class Compressor : Algorithm, IDisposable
  • protected bool IsActive { get; protected set; }
  • protected Session Session { get; }
  • public Compressor()
  • protected Compressor(bool delayedCompression)
  • public virtual byte[] Compress(byte[] data, int offset, int length)
  • protected abstract byte[] CompressCore(byte[] data, int offset, int length)
  • public virtual byte[] Decompress(byte[] data, int offset, int length)
  • protected abstract byte[] DecompressCore(byte[] data, int offset, int length)
• public class ZlibOpenSsh : Compressor
• public class ZlibStream

Renci.SshNet.Connection

• public sealed class SshIdentification
  • public string Comments { get; }
  • public string ProtocolVersion { get; }
  • public string SoftwareVersion { get; }
  • public SshIdentification(string protocolVersion, string softwareVersion)
  • public SshIdentification(string protocolVersion, string softwareVersion, string comments)

Renci.SshNet.Messages

• public abstract class Message : SshData
  • public abstract string MessageName { get; }
  • public abstract byte MessageNumber { get; }
• public sealed class MessageAttribute : Attribute

Renci.SshNet.Messages.Authentication

• public abstract class RequestMessage : Message
  • public ServiceName ServiceName { get; }
  • public string Username { get; }
  • public RequestMessage(ServiceName serviceName, string username)
  • public byte[] ServiceName { get; }
  • public byte[] Username { get; }
  • protected RequestMessage(ServiceName serviceName, string username, string methodName)
• public class RequestMessagePublicKey : RequestMessage
  • public string PublicKeyAlgorithmName { get; }
  • public byte[] PublicKeyAlgorithmName { get; }

Renci.SshNet.Messages.Connection

• public class ChannelDataMessage : ChannelMessage
  • public int Offset { get; }
  • public int Size { get; }
  • public ChannelDataMessage(uint localChannelNumber, byte[] data, int offset, int size)
• public class ChannelExtendedDataMessage : ChannelMessage
  • public ChannelExtendedDataMessage(uint localChannelNumber)
  • public ChannelExtendedDataMessage(uint localChannelNumber, uint dataTypeCode, byte[] data)
• public abstract class ChannelMessage : Message
  • protected ChannelMessage(uint localChannelNumber)
• public class ChannelOpenFailureMessage : ChannelMessage
  • public ChannelOpenFailureMessage(uint localChannelNumber, string description, uint reasonCode, string language)
• public class ChannelOpenMessage : Message
  • public string ChannelType { get; }
  • public byte[] ChannelType { get; }
  • public uint LocalChannelNumber { get; protected set; }
• public class EndOfWriteRequestInfo : RequestInfo
  • public const string NAME = "eow@openssh.com"
  • public const string Name = "eow@openssh.com"
• public class GlobalRequestMessage : Message
  • public string AddressToBind { get; }
  • public uint PortToBind { get; }
  • public GlobalRequestName RequestName { get; }
  • public string RequestName { get; }
  • public GlobalRequestMessage(GlobalRequestName requestName, bool wantReply)
  • public GlobalRequestMessage(GlobalRequestName requestName, bool wantReply, string addressToBind, uint portToBind)
• public class KeepAliveRequestInfo : RequestInfo
  • public const string NAME = "keepalive@openssh.com"
  • public const string Name = "keepalive@openssh.com"

Renci.SshNet.Messages.Transport

• public class KeyExchangeDhReplyMessage : Message
  • public BigInteger F { get; }
  • public byte[] F { get; }
• public class KeyExchangeEcdhReplyMessage : Message
  • public byte[] KS { get; }
  • public byte[] QS { get; }
  • public byte[] Signature { get; }
  • public KeyExchangeEcdhReplyMessage()

Renci.SshNet.Security

• public class DsaKey : Key, IDisposable
  • public DsaKey()
  • public DsaKey(SshKeyData publicKeyData)
• public class EcdsaKey : Key, IDisposable
  • public ECDsa Ecdsa { get; }
  • public HashAlgorithmName HashAlgorithm { get; }
  • public byte[] PrivateKey { get; }
  • public EcdsaKey(SshKeyData publicKeyData)
  • public EcdsaKey(string curve, byte[] publickey, byte[] privatekey)
  • public EcdsaKey(byte[] data)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class ED25519Key : Key, IDisposable
  • public byte[] PrivateKey { get; }
  • public byte[] PublicKey { get; }
  • public ED25519Key(SshKeyData publicKeyData)
  • public ED25519Key(byte[] privateKeyData)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public interface IKeyExchange : IDisposable
  • byte[] ExchangeHash { get; }
  • string Name { get; }
  • event EventHandler<HostKeyEventArgs> HostKeyReceived
  • Cipher CreateClientCipher(out bool isAead)
  • HashAlgorithm CreateClientHash(out bool isEncryptThenMAC)
  • Compressor CreateCompressor()
  • Compressor CreateDecompressor()
  • Cipher CreateServerCipher(out bool isAead)
  • HashAlgorithm CreateServerHash(out bool isEncryptThenMAC)
  • void Finish()
  • void Start(Session session, KeyExchangeInitMessage message, bool sendClientInitMessage)
• public abstract class Key
  • protected BigInteger[] _privateKey
  • protected abstract DigitalSignature DigitalSignature { get; }
  • public string Comment { get; set; }
  • public Key(byte[] data)
• public abstract class KeyExchange : Algorithm, IKeyExchange, IDisposable
  • public BigInteger SharedKey { get; protected set; }
  • public byte[] SharedKey { get; protected set; }
  • public Cipher CreateClientCipher()
  • public HashAlgorithm CreateClientHash()
  • public Cipher CreateClientCipher(out bool isAead)
  • public HashAlgorithm CreateClientHash(out bool isEncryptThenMAC)
  • public Cipher CreateServerCipher()
  • public HashAlgorithm CreateServerHash()
  • public Cipher CreateServerCipher(out bool isAead)
  • public HashAlgorithm CreateServerHash(out bool isEncryptThenMAC)
  • public virtual void Start(Session session, KeyExchangeInitMessage message)
  • public virtual void Start(Session session, KeyExchangeInitMessage message, bool sendClientInitMessage)
• public abstract class KeyExchangeDiffieHellman : KeyExchange
• public class KeyExchangeDiffieHellmanGroup1Sha1 : KeyExchangeDiffieHellmanGroupSha1
• public class KeyExchangeDiffieHellmanGroupExchangeSha256 : KeyExchangeDiffieHellman
• public abstract class KeyExchangeDiffieHellmanGroupSha1 : KeyExchangeDiffieHellman
• public class KeyHostAlgorithm : HostAlgorithm
  • public DigitalSignature DigitalSignature { get; }
  • public KeyHostAlgorithm(string name, Key key, byte[] data)
  • public KeyHostAlgorithm(string name, Key key, DigitalSignature digitalSignature)
• public class RsaKey : Key, IDisposable
  • public RsaKey()
  • public RsaKey(SshKeyData publicKeyData)
• public sealed class SshKeyData : SshData
  • public BigInteger[] Keys { get; }
  • public string Name { get; }
  • public SshKeyData(byte[] data)
  • public SshKeyData(string name, BigInteger[] keys)

Renci.SshNet.Security.Cryptography

• public abstract class AsymmetricCipher : Cipher
• public abstract class BlockCipher : SymmetricCipher
  • protected readonly byte _blockSize
  • 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 Cipher
  • public virtual int TagSize { get; }
  • 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, int offset, int length)
  • public abstract byte[] Encrypt(byte[] input, int offset, int length)
• public abstract class CipherDigitalSignature : DigitalSignature
• public class HMac<T> : KeyedHashAlgorithm where T : HashAlgorithm
• public class MD5Hash : HashAlgorithm
• public class RIPEMD160Hash : HashAlgorithm
• public class EcdsaDigitalSignature : DigitalSignature, IDisposable
  • public EcdsaDigitalSignature(EcdsaKey key)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class ED25519DigitalSignature : DigitalSignature, IDisposable
  • public ED25519DigitalSignature(ED25519Key key)
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class HMACMD5 : HMACMD5
  • public HMACMD5(byte[] key)
  • public HMACMD5(byte[] key, int hashSize)
• public class HMACSHA1 : HMACSHA1
  • public HMACSHA1(byte[] key)
  • public HMACSHA1(byte[] key, int hashSize)
• public class HMACSHA256 : HMACSHA256
  • public HMACSHA256(byte[] key)
  • public HMACSHA256(byte[] key, int hashSize)
• public class HMACSHA384 : HMACSHA384
  • public HMACSHA384(byte[] key)
  • public HMACSHA384(byte[] key, int hashSize)
• public class HMACSHA512 : HMACSHA512
  • public HMACSHA512(byte[] key)
  • public HMACSHA512(byte[] key, int hashSize)
• public class RsaDigitalSignature : DigitalSignature, IDisposable
  • public RsaDigitalSignature(RsaKey rsaKey, HashAlgorithmName hashAlgorithmName)
• public class SHA1Hash : HashAlgorithm
• public class SHA256Hash : HashAlgorithm
• public abstract class SHA2HashBase : HashAlgorithm
• public class SHA384Hash : SHA2HashBase
• public class SHA512Hash : SHA2HashBase
• public abstract class SymmetricCipher : Cipher
  • 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, IDisposable
  • protected uint[,] DecryptionKey { get; }
  • protected uint[,] EncryptionKey { get; }
  • public AesCipher(byte[] key, CipherMode mode, CipherPadding padding)
  • public AesCipher(byte[] key, byte[] iv, AesCipherMode mode, bool pkcs7Padding = false)
  • public void Dispose(bool disposing)
  • public void Dispose()
• public enum AesCipherMode
  • CBC = 1
  • CFB = 4
  • CTR = 6
  • CTS = 5
  • ECB = 2
  • OFB = 3
• public sealed class Arc4Cipher : StreamCipher
  • public void Reset()
• public abstract class CipherPadding
  • public abstract byte[] Pad(int blockSize, byte[] input, int offset, int length)
  • public byte[] Pad(byte[] input, int paddinglength)
  • public abstract byte[] Pad(byte[] input, int offset, int length, int paddinglength)
• public class RsaCipher : AsymmetricCipher

Renci.SshNet.Sftp

• public interface ISftpFile
  • SftpFileAttributes Attributes { get; }
  • string FullName { get; }
  • bool GroupCanExecute { get; set; }
  • bool GroupCanRead { get; set; }
  • bool GroupCanWrite { get; set; }
  • int GroupId { get; set; }
  • bool IsBlockDevice { get; }
  • bool IsCharacterDevice { get; }
  • bool IsDirectory { get; }
  • bool IsNamedPipe { get; }
  • bool IsRegularFile { get; }
  • bool IsSocket { get; }
  • bool IsSymbolicLink { get; }
  • DateTime LastAccessTime { get; set; }
  • DateTime LastAccessTimeUtc { get; set; }
  • DateTime LastWriteTime { get; set; }
  • DateTime LastWriteTimeUtc { get; set; }
  • long Length { get; }
  • string Name { get; }
  • bool OthersCanExecute { get; set; }
  • bool OthersCanRead { get; set; }
  • bool OthersCanWrite { get; set; }
  • bool OwnerCanExecute { get; set; }
  • bool OwnerCanRead { get; set; }
  • bool OwnerCanWrite { get; set; }
  • int UserId { get; set; }
  • void Delete()
  • void MoveTo(string destFileName)
  • void SetPermissions(short mode)
  • void UpdateStatus()
• public sealed class SftpFile : ISftpFile
  • public IDictionary<string, string> Extensions { get; }
• public class SftpFileAttributes
  • public DateTime LastAccessTimeUtc { get; set; }
  • public DateTime LastWriteTimeUtc { get; set; }
  • public byte[] GetBytes()
• public class SftpFileStream : Stream
  • public virtual bool IsAsync { get; }
• public class SftpFileSytemInformation
• public class SftpFileSystemInformation
  • public ulong AvailableBlocks { get; }
  • public ulong AvailableNodes { get; }
  • public ulong BlockSize { get; }
  • public ulong FileSystemBlockSize { 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 abstract class SubsystemSession : IDisposable