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

---

API Differences between 2020.0.2 and 2025.1.0

358 Additions 185 Removals

Renci.SshNet

• public abstract class AuthenticationMethod : IAuthenticationMethod
  • protected virtual void Dispose(bool disposing)
  • public void Dispose()
• public abstract class BaseClient : IDisposable
  • public event EventHandler<SshIdentificationEventArgs> ServerIdentificationReceived
  • public Task ConnectAsync(CancellationToken cancellationToken)
• public class CipherInfo
  • public bool IsAead { get; }
  • public CipherInfo(int keySize, Func<byte[], byte[], Cipher> cipher, bool isAead = false)
  • 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 : IConnectionInfoInternal, IConnectionInfo
  • public IOrderedDictionary<string, Func<Compressor>> CompressionAlgorithms { get; }
  • public IDictionary<string, Type> CompressionAlgorithms { get; }
  • public IOrderedDictionary<string, CipherInfo> Encryptions { get; }
  • public IOrderedDictionary<string, HashInfo> HmacAlgorithms { get; }
  • public IDictionary<string, CipherInfo> Encryptions { get; }
  • public IDictionary<string, HashInfo> HmacAlgorithms { get; }
  • public IOrderedDictionary<string, Func<byte[], KeyHostAlgorithm>> HostKeyAlgorithms { get; }
  • public IDictionary<string, Func<byte[], KeyHostAlgorithm>> HostKeyAlgorithms { get; }
  • public IOrderedDictionary<string, Func<IKeyExchange>> KeyExchangeAlgorithms { get; }
  • public ILoggerFactory LoggerFactory { get; set; }
  • public IDictionary<string, Type> KeyExchangeAlgorithms { get; }
• public class ExpectAsyncResult : AsyncResult<string>
• public abstract class ForwardedPort : IForwardedPort
  • public event EventHandler Closing
  • public void Dispose()
• public class ForwardedPortDynamic : ForwardedPort
  • public void Dispose()
• public class ForwardedPortLocal : ForwardedPort, IDisposable
  • public void Dispose()
• public class ForwardedPortRemote : ForwardedPort, IDisposable
  • public void Dispose()
• public class HashInfo
  • public bool IsEncryptThenMAC { get; }
  • public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash, bool isEncryptThenMAC = false)
  • public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash)
• public interface IBaseClient : IDisposable
• public interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>
• public interface IPrivateKeySource
• public interface ISftpClient
  • Task ChangeDirectoryAsync(string path, CancellationToken cancellationToken = default)
  • Task CreateDirectoryAsync(string path, CancellationToken cancellationToken = default)
  • Task DeleteAsync(string path, CancellationToken cancellationToken = default)
  • Task DeleteDirectoryAsync(string path, CancellationToken cancellationToken = default)
  • Task DeleteFileAsync(string path, CancellationToken cancellationToken)
  • Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken = default)
  • IEnumerable<ISftpFile> EndListDirectory(IAsyncResult asyncResult)
  • IEnumerable<SftpFile> EndListDirectory(IAsyncResult asyncResult)
  • Task<bool> ExistsAsync(string path, CancellationToken cancellationToken = default)
  • ISftpFile Get(string path)
  • Task<ISftpFile> GetAsync(string path, CancellationToken cancellationToken)
  • SftpFile Get(string path)
  • Task<SftpFileAttributes> GetAttributesAsync(string path, CancellationToken cancellationToken)
  • 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)
  • SftpFileSytemInformation GetStatus(string path)
  • IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback = null)
  • Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
  • Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken)
  • void SetLastAccessTime(string path, DateTime lastAccessTime)
  • void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc)
  • void SetLastWriteTime(string path, DateTime lastWriteTime)
  • void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc)
  • Task UploadFileAsync(Stream input, string path, CancellationToken cancellationToken = default)
• public interface ISshClient : IBaseClient, IDisposable
• public class KeyboardInteractiveAuthenticationMethod : AuthenticationMethod, IDisposable
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class NetConfClient : BaseClient
  • public NetConfClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public NetConfClient(string host, string username, IPrivateKeySource[] keyFiles)
  • public NetConfClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public NetConfClient(string host, string username, PrivateKeyFile[] keyFiles)
• public class NoneAuthenticationMethod : AuthenticationMethod, IDisposable
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PasswordAuthenticationMethod : AuthenticationMethod, IDisposable
  • public void Dispose()
  • protected virtual void Dispose(bool disposing)
• public class PrivateKeyAuthenticationMethod : AuthenticationMethod, IDisposable
  • public ICollection<IPrivateKeySource> KeyFiles { get; }
  • public PrivateKeyAuthenticationMethod(string username, IPrivateKeySource[] keyFiles)
  • 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<IPrivateKeySource> KeyFiles { get; }
  • public PrivateKeyConnectionInfo(string host, string username, IPrivateKeySource[] 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 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 class PrivateKeyFile : IDisposable
  • public Certificate Certificate { get; }
  • public IReadOnlyCollection<HostAlgorithm> HostKeyAlgorithms { get; }
  • public Key Key { get; }
  • public PrivateKeyFile(Key key)
  • public HostAlgorithm HostKey { get; }
  • public PrivateKeyFile(string fileName, string passPhrase, string certificateFileName)
  • public PrivateKeyFile(Stream privateKey, string passPhrase, Stream certificate)
• public class ScpClient : BaseClient
  • public ScpClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public ScpClient(string host, string username, IPrivateKeySource[] keyFiles)
  • 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 Download(string filename, Stream destination)
• public class Session : ISession, IDisposable
  • public KeyExchangeInitMessage ClientInitMessage { get; }
  • public Message ClientInitMessage { get; }
  • public ILoggerFactory SessionLoggerFactory { get; }
  • public SemaphoreSlim SessionSemaphore { get; }
  • public SemaphoreLight SessionSemaphore { get; }
  • public event EventHandler<SshIdentificationEventArgs> ServerIdentificationReceived
  • public Task ConnectAsync(CancellationToken cancellationToken)
  • protected virtual void Dispose(bool disposing)
• public class SftpClient : BaseClient, ISftpClient
  • public SftpClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public SftpClient(string host, string username, IPrivateKeySource[] keyFiles)
  • public SftpClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public SftpClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public Task ChangeDirectoryAsync(string path, CancellationToken cancellationToken = default)
  • public Task CreateDirectoryAsync(string path, CancellationToken cancellationToken = default)
  • public Task DeleteAsync(string path, CancellationToken cancellationToken = default)
  • public Task DeleteDirectoryAsync(string path, CancellationToken cancellationToken = default)
  • public Task DeleteFileAsync(string path, CancellationToken cancellationToken)
  • public Task DownloadFileAsync(string path, Stream output, CancellationToken cancellationToken = default)
  • public IEnumerable<ISftpFile> EndListDirectory(IAsyncResult asyncResult)
  • public IEnumerable<SftpFile> EndListDirectory(IAsyncResult asyncResult)
  • public Task<bool> ExistsAsync(string path, CancellationToken cancellationToken = default)
  • public ISftpFile Get(string path)
  • public Task<ISftpFile> GetAsync(string path, CancellationToken cancellationToken)
  • public SftpFile Get(string path)
  • public Task<SftpFileAttributes> GetAttributesAsync(string path, CancellationToken cancellationToken)
  • 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 SftpFileSytemInformation GetStatus(string path)
  • public IEnumerable<SftpFile> ListDirectory(string path, Action<int> listCallback = null)
  • public Task<SftpFileStream> OpenAsync(string path, FileMode mode, FileAccess access, CancellationToken cancellationToken)
  • public Task RenameFileAsync(string oldPath, string newPath, CancellationToken cancellationToken)
  • public Task UploadFileAsync(Stream input, string path, CancellationToken cancellationToken = default)
• public class Shell : IDisposable
  • protected virtual void Dispose(bool disposing)
• public class ShellStream : Stream
  • public event EventHandler<EventArgs> Closed
  • public IAsyncResult BeginExpect(TimeSpan timeout, int lookback, AsyncCallback callback, object state, ExpectAction[] expectActions)
  • public void ChangeWindowSize(uint columns, uint rows, uint width, uint height)
  • public void Expect(TimeSpan timeout, int lookback, ExpectAction[] expectActions)
  • public string Expect(string text, TimeSpan timeout, int lookback = -1)
  • public string Expect(string text, TimeSpan timeout)
  • public string Expect(Regex regex, TimeSpan timeout, int lookback = -1)
  • public string Expect(Regex regex, TimeSpan timeout)
• public class SshClient : BaseClient
  • public SshClient(string host, int port, string username, IPrivateKeySource[] keyFiles)
  • public SshClient(string host, string username, IPrivateKeySource[] keyFiles)
  • public SshClient(string host, int port, string username, PrivateKeyFile[] keyFiles)
  • public SshClient(string host, string username, PrivateKeyFile[] keyFiles)
  • public Shell CreateShellNoTerminal(Stream input, Stream output, Stream extendedOutput, int bufferSize = -1)
  • public ShellStream CreateShellStreamNoTerminal(int bufferSize = -1)
• public class SshCommand : IDisposable
  • public string ExitSignal { get; }
  • public int? ExitStatus { get; }
  • public int ExitStatus { get; }
  • public void CancelAsync(bool forceKill = false, int millisecondsTimeout = 500)
  • public Stream CreateInputStream()
  • public void CancelAsync()
  • protected virtual void Dispose(bool disposing)
  • public Task ExecuteAsync(CancellationToken cancellationToken = default)
• public static class SshNetLoggingConfiguration

Renci.SshNet.Common

• public class AuthenticationPromptEventArgs : AuthenticationEventArgs
  • public IReadOnlyList<AuthenticationPrompt> Prompts { get; }
  • public AuthenticationPromptEventArgs(string username, string instruction, string language, IReadOnlyList<AuthenticationPrompt> prompts)
  • 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(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)
  • public static BigInteger Parse(string value, NumberStyles style)
  • public static BigInteger Parse(string value, IFormatProvider provider)
  • public static BigInteger Parse(string value, NumberStyles style, IFormatProvider provider)
  • 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, out BigInteger result)
  • public static bool TryParse(string value, NumberStyles style, IFormatProvider provider, 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(string format)
  • public string ToString(IFormatProvider provider)
  • public string ToString(string format, IFormatProvider provider)
• public class DerData
  • public bool IsEndOfData { get; }
  • public DerData()
  • public DerData(byte[] data, bool construct = false)
  • public byte[] Encode()
  • public BigInteger ReadBigInteger()
  • public byte[] ReadBitString()
  • public byte ReadByte()
  • public byte[] ReadBytes(int length)
  • public int ReadInteger()
  • public int ReadLength()
  • public byte[] ReadObject()
  • public byte[] ReadOctetString()
  • 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 WriteBitstring(byte[] data)
  • public void WriteBytes(IEnumerable<byte> data)
  • public void WriteNull()
  • public void WriteObjectIdentifier(byte[] bytes)
• public class HostKeyEventArgs : EventArgs
  • public Certificate Certificate { get; }
  • public string FingerPrintMD5 { get; }
  • public string FingerPrintSHA256 { get; }
• 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 class SftpException : SshException
• public class SemaphoreLight : IDisposable
  • public WaitHandle AvailableWaitHandle { get; }
  • public int CurrentCount { get; }
  • public SemaphoreLight(int initialCount)
  • public void Dispose()
  • protected void Dispose(bool disposing)
  • public int Release()
  • public int Release(int releaseCount)
  • public void Wait()
  • public bool Wait(int millisecondsTimeout)
  • public bool Wait(TimeSpan timeout)
• public class SftpPathNotFoundException : SshException
  • public string Path { get; }
  • public SftpPathNotFoundException(string message, string path)
  • public SftpPathNotFoundException(string message, string path, Exception innerException)
• public class SshConnectionException : SshException
  • public SshConnectionException(string message, Exception inner)
• public abstract class SshData
  • protected Dictionary<string, string> ReadExtensionPair()
  • protected IDictionary<string, string> ReadExtensionPair()
  • protected void Write(BigInteger data)
  • protected void Write(BigInteger data)
• public class SshDataStream : MemoryStream
  • public BigInteger ReadBigInt()
  • public BigInteger ReadBigInt()
  • public ushort ReadUInt16()
  • public void Write(BigInteger data)
  • public void Write(BigInteger data)
• public class SshIdentificationEventArgs : EventArgs

Renci.SshNet.Compression

• public enum CompressionMode
  • Compress = 0
  • Decompress = 1
• public abstract class Compressor : Algorithm, IDisposable
  • protected Compressor(bool delayedCompression)
  • protected bool IsActive { get; protected set; }
  • protected Session Session { get; }
  • protected Compressor()
  • protected abstract byte[] CompressCore(byte[] data, int offset, int length)
  • protected abstract byte[] DecompressCore(byte[] data, int offset, int length)
• public class Zlib : Compressor
• public class ZlibStream
  • public ZlibStream(Stream stream, CompressionMode mode)
  • public void Write(byte[] buffer, int offset, int count)

Renci.SshNet.Connection

• public sealed class SshIdentification

Renci.SshNet.Messages

• public abstract class Message : SshData
  • public abstract string MessageName { get; }
  • public abstract byte MessageNumber { get; }
• public sealed class MessageAttribute : Attribute
  • public string Name { get; set; }
  • public byte Number { get; set; }
  • public MessageAttribute(string name, byte number)

Renci.SshNet.Messages.Transport

• public class KeyExchangeDhGroupExchangeGroup : Message
  • public BigInteger SafePrime { get; }
  • public BigInteger SubGroup { get; }
  • public BigInteger SafePrime { get; }
  • public BigInteger SubGroup { get; }
• public class KeyExchangeHybridReplyMessage : Message

Renci.SshNet.Security

• public class Certificate
• public class CertificateHostAlgorithm : HostAlgorithm
  • public Certificate Certificate { get; }
  • public CertificateHostAlgorithm(string name, Key privateKey, Certificate certificate)
  • public CertificateHostAlgorithm(string name, Key privateKey, Certificate certificate, DigitalSignature digitalSignature)
  • public CertificateHostAlgorithm(string name, Certificate certificate, IReadOnlyDictionary<string, Func<byte[], KeyHostAlgorithm>> keyAlgorithms)
  • public CertificateHostAlgorithm(string name, Certificate certificate, DigitalSignature digitalSignature, IReadOnlyDictionary<string, Func<byte[], KeyHostAlgorithm>> keyAlgorithms)
  • 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 class EcdsaKey : Key, IDisposable
  • public byte[] PrivateKey { get; }
  • public EcdsaKey(SshKeyData publicKeyData)
  • public EcdsaKey()
• public class ED25519Key : Key, IDisposable
  • public ED25519Key(SshKeyData publicKeyData)
  • public ED25519Key(byte[] privateKeyData)
  • public ED25519Key()
  • public ED25519Key(byte[] pk, byte[] sk)
• public interface IKeyExchange : IDisposable
  • Cipher CreateClientCipher(out bool isAead)
  • HashAlgorithm CreateClientHash(out bool isEncryptThenMAC)
  • Cipher CreateClientCipher()
  • HashAlgorithm CreateClientHash()
  • Cipher CreateServerCipher(out bool isAead)
  • HashAlgorithm CreateServerHash(out bool isEncryptThenMAC)
  • Cipher CreateServerCipher()
  • HashAlgorithm CreateServerHash()
  • void Start(Session session, KeyExchangeInitMessage message, bool sendClientInitMessage)
  • void Start(Session session, KeyExchangeInitMessage message)
• public abstract class Key
  • public string Comment { get; set; }
  • protected BigInteger[] _privateKey
  • protected abstract DigitalSignature DigitalSignature { get; }
  • public abstract BigInteger[] Public { get; }
  • public abstract BigInteger[] Public { get; set; }
  • protected Key(byte[] data)
• public abstract class KeyExchange : Algorithm, IKeyExchange, IDisposable
  • public Cipher CreateClientCipher(out bool isAead)
  • public HashAlgorithm CreateClientHash(out bool isEncryptThenMAC)
  • public Cipher CreateClientCipher()
  • public HashAlgorithm CreateClientHash()
  • public Cipher CreateServerCipher(out bool isAead)
  • public HashAlgorithm CreateServerHash(out bool isEncryptThenMAC)
  • public Cipher CreateServerCipher()
  • public HashAlgorithm CreateServerHash()
  • public virtual void Start(Session session, KeyExchangeInitMessage message, bool sendClientInitMessage)
  • public virtual void Start(Session session, KeyExchangeInitMessage message)
• public class KeyExchangeDiffieHellman : KeyExchange
• public class KeyExchangeDiffieHellmanGroupExchange : KeyExchange
• public class KeyHostAlgorithm : HostAlgorithm
  • public DigitalSignature DigitalSignature { get; }
  • public KeyHostAlgorithm(string name, Key key, DigitalSignature digitalSignature)
  • 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(SshKeyData publicKeyData)
  • 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(BigInteger modulus, BigInteger exponent, BigInteger d, BigInteger p, BigInteger q, BigInteger inverseQ)
  • public RsaKey(BigInteger modulus, BigInteger exponent, BigInteger d, BigInteger p, BigInteger q, BigInteger inverseQ)
• public sealed class SshKeyData : SshData

Renci.SshNet.Security.Cryptography

• public abstract class AsymmetricCipher : Cipher
  • protected AsymmetricCipher()
• public abstract class BlockCipher : SymmetricCipher
  • protected BlockCipher(byte[] key, byte blockSize, CipherMode mode, IBlockCipherPadding padding)
  • 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)
  • protected BlockCipher(byte[] key, byte blockSize, CipherMode mode, CipherPadding padding)
• public abstract class Cipher
  • public virtual int TagSize { get; }
• public abstract class CipherDigitalSignature : DigitalSignature
  • protected CipherDigitalSignature(ObjectIdentifier oid, AsymmetricCipher cipher)
  • protected byte[] DerEncode(byte[] hashData)
  • protected abstract byte[] Hash(byte[] input)
• public class DsaDigitalSignature : DigitalSignature, IDisposable
  • public DsaDigitalSignature(DsaKey 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 : CipherDigitalSignature, IDisposable
  • public RsaDigitalSignature(RsaKey rsaKey, HashAlgorithmName hashAlgorithmName)
• public abstract class StreamCipher : SymmetricCipher
  • protected StreamCipher(byte[] key)
• 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
  • public AesCipher(byte[] key, byte[] iv, AesCipherMode mode, bool pkcs7Padding = false)
  • public void Dispose()
  • public AesCipher(byte[] key, CipherMode mode, CipherPadding padding)
• public enum AesCipherMode
• 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 CipherPadding
  • protected CipherPadding()
  • public byte[] Pad(int blockSize, byte[] input)
  • 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 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, byte[] iv, CipherMode mode, bool pkcs7Padding)
  • public void Dispose()
  • 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.Paddings

• public class PKCS5Padding : CipherPadding
  • public PKCS5Padding()
• public class PKCS7Padding : CipherPadding
  • public PKCS7Padding()

Renci.SshNet.Sftp

• public interface ISftpFile
• public class SftpFile
  • public Task DeleteAsync(CancellationToken cancellationToken = default)
• public class SftpFileAttributes
  • public bool IsGroupIDBitSet { get; set; }
  • public bool IsStickyBitSet { get; set; }
  • public bool IsUIDBitSet { get; set; }
• public sealed class SftpFileSystemInformation
• public class SftpFileSytemInformation
  • 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 enum StatusCode