LethalSSH by baer1

Communities

Lethal CompanyLethalSSH

Install

Last Updated

First Uploaded

Downloads

868

Likes

Size

4.9MB

Dependency string

baer1-LethalSSH-0.1.1

Dependants

1 other mods

Mods Misc BepInEx Client-side

Download

Details Required (2)Wiki ~~Changelog~~Versions Analysis

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Renci.SshNet;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("baer1.LethalSSH")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+27f95d17cffb6ce84f8b76af23974495ea207269")]
[assembly: AssemblyProduct("LethalSsh")]
[assembly: AssemblyTitle("baer1.LethalSSH")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LethalSsh
{
	[BepInPlugin("baer1.LethalSSH", "LethalSsh", "0.1.1")]
	public class LethalSsh : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
		public class ParsePlayerSentencePatch
		{
			private static bool Prefix(ref Terminal __instance, ref TerminalNode __result)
			{
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: Expected O, but got Unknown
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Expected O, but got Unknown
				string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
				Logger.LogDebug((object)(">> ParsePlayerSentence " + text));
				string[] array = text.Split(" ");
				if (Instance.Active && Instance.sshShell != null && ((Stream)(object)Instance.sshShell).CanWrite)
				{
					Instance.sshShell.Write(text + "\n");
					return false;
				}
				if (array[0] == "ssh")
				{
					__result = ScriptableObject.CreateInstance<TerminalNode>();
					__result.clearPreviousText = true;
					switch (array.Length)
					{
					case 4:
					{
						string[] array2 = array[1].Split("@");
						if (array2.Length != 2)
						{
							__result.displayText = "Invalid arguments";
							break;
						}
						int result = 22;
						int.TryParse(array[2], out result);
						Instance.sshClient = new SshClient(array2[1], result, array2[0], array[3]);
						((BaseClient)Instance.sshClient).Connect();
						Instance.sshShell = Instance.sshClient.CreateShellStream("linux", 20u, 20u, 800u, 600u, 1024);
						__result.displayText = "";
						break;
					}
					case 3:
					{
						string[] array2 = array[1].Split("@");
						if (array2.Length != 2)
						{
							__result.displayText = "Invalid arguments";
							break;
						}
						Instance.sshClient = new SshClient(array2[1], array2[0], array[2]);
						((BaseClient)Instance.sshClient).Connect();
						Instance.sshShell = Instance.sshClient.CreateShellStream("linux", 50u, 50u, 800u, 600u, 1024);
						__result.displayText = "";
						break;
					}
					default:
						__result.displayText = "Invalid arguments\n";
						break;
					}
					Instance._sgrCloseTags.Clear();
					Instance._sgrDim = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Terminal), "TextChanged")]
		public class TextChangedPatch
		{
			private static bool Prefix(ref Terminal __instance, string newText)
			{
				Logger.LogDebug((object)(">> TextChanged " + newText.Split("\n").Last()));
				if (!Instance.Active)
				{
					return true;
				}
				if (__instance.modifyingText)
				{
					__instance.modifyingText = false;
					return false;
				}
				Terminal obj = __instance;
				obj.textAdded += newText.Length - __instance.currentText.Length;
				if (__instance.textAdded < 0)
				{
					__instance.screenText.text = __instance.currentText;
					__instance.textAdded = 0;
				}
				else
				{
					__instance.currentText = newText;
				}
				__instance.forceScrollbarCoroutine = ((MonoBehaviour)__instance).StartCoroutine(__instance.forceScrollbarDown());
				return false;
			}
		}

		[HarmonyPatch(typeof(Terminal), "QuitTerminal")]
		public class QuitTerminalPatch
		{
			private static void Prefix()
			{
				Logger.LogDebug((object)">> QuitTerminal");
				Instance.ResetSSH();
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")]
		public class StartDisconnectPatch
		{
			private static void Prefix()
			{
				Logger.LogDebug((object)">> StartDisconnect");
				Instance.ResetSSH();
			}
		}

		[HarmonyPatch(typeof(Terminal), "Update")]
		public class TerminalUpdatePatch
		{
			private static void Prefix(ref Terminal __instance)
			{
				if (!Instance.Active || Instance.sshShell == null || !((Stream)(object)Instance.sshShell).CanRead)
				{
					return;
				}
				string text = Instance.sshShell.Read();
				if (text.Length == 0)
				{
					return;
				}
				string text2 = Regex.Split(GeneralExtensions.Join<string>((__instance.currentText + text).Split("\n").TakeLast(50), (Func<string, string>)null, "\n"), "\\x1B\\[[0-3]?[jJ]").Last();
				__instance.currentText = Regex.Replace(enableANSI.Value ? Regex.Replace(text2, "\\x1B\\[([0-9;]*)[mM]", delegate(Match m)
				{
					StringBuilder sb = new StringBuilder();
					string[] array = m.Groups[1].Value.Split(";");
					Func<string, string, bool> next = null;
					string text3 = null;
					string[] array2 = array;
					foreach (string text4 in array2)
					{
						Logger.LogDebug((object)(">> Parsing ANSI code " + text4));
						if (next != null)
						{
							Logger.LogDebug((object)("Found next function, previous: " + text3));
							if (!next(text3, text4))
							{
								text3 = text4;
								Logger.LogDebug((object)("previous overwritten " + text3));
							}
							else
							{
								Logger.LogDebug((object)("previous not overwritten: " + text3));
							}
						}
						else
						{
							switch (text4)
							{
							case "1":
								Instance._sgrCloseTags.Insert(0, "</b>");
								sb.Append("<b>");
								break;
							case "2":
								Instance._sgrCloseTags.Insert(0, "<alpha=#FF>");
								Instance._sgrDim = true;
								sb.Append("<alpha=#33>");
								break;
							case "3":
								Instance._sgrCloseTags.Insert(0, "</i>");
								sb.Append("<i>");
								break;
							case "4":
								Instance._sgrCloseTags.Insert(0, "</u>");
								sb.Append("<u>");
								break;
							case "9":
								Instance._sgrCloseTags.Insert(0, "</s>");
								sb.Append("<s>");
								break;
							case "30":
							case "31":
							case "32":
							case "33":
							case "34":
							case "35":
							case "36":
							case "37":
							case "90":
							case "91":
							case "92":
							case "93":
							case "94":
							case "95":
							case "96":
							case "97":
								Instance._sgrCloseTags.Insert(0, "</color>");
								sb.Append("<color=#" + GetColorByCode(text4) + (Instance._sgrDim ? "33" : "") + ">");
								break;
							case "40":
							case "41":
							case "42":
							case "43":
							case "44":
							case "45":
							case "46":
							case "47":
							case "100":
							case "101":
							case "102":
							case "103":
							case "104":
							case "105":
							case "106":
							case "107":
								Instance._sgrCloseTags.Insert(0, "</mark>");
								sb.Append("<mark=#" + GetColorByCode(text4) + "55>");
								break;
							case "38":
							case "48":
								next = delegate(string _, string mode)
								{
									if (!(mode == "2"))
									{
										if (mode == "5")
										{
											next = delegate(string previous, string color)
											{
												if (previous == "38")
												{
													Instance._sgrCloseTags.Insert(0, "</color>");
													sb.Append("<color=#" + Get256ColorByCode(color) + (Instance._sgrDim ? "33" : "") + ">");
												}
												else
												{
													Instance._sgrCloseTags.Insert(0, "</mark>");
													sb.Append("<mark=#" + Get256ColorByCode(color) + "55>");
												}
												next = null;
												return false;
											};
										}
									}
									else
									{
										StringBuilder rgb = new StringBuilder();
										next = delegate(string _, string r)
										{
											rgb.Append(((byte)int.Parse(r)).ToString("X2"));
											next = delegate(string _, string g)
											{
												rgb.Append(((byte)int.Parse(g)).ToString("X2"));
												next = delegate(string previous, string b)
												{
													rgb.Append(((byte)int.Parse(b)).ToString("X2"));
													if (previous == "38")
													{
														Instance._sgrCloseTags.Insert(0, "</color>");
														sb.Append("<color=#" + rgb.ToString() + (Instance._sgrDim ? "33" : "") + ">");
													}
													else
													{
														Instance._sgrCloseTags.Insert(0, "</mark>");
														sb.Append("<mark=#" + rgb.ToString() + "55>");
													}
													next = null;
													return false;
												};
												return true;
											};
											return true;
										};
									}
									return true;
								};
								break;
							default:
							{
								string result = Instance._sgrCloseTags.ToString();
								Instance._sgrCloseTags.Clear();
								Instance._sgrDim = false;
								return result;
							}
							}
							text3 = text4;
						}
					}
					Logger.LogDebug((object)("<< Parsed \u001b[" + m.Groups[1].Value + "m: " + sb.ToString()));
					return sb.ToString();
				}) : text2, "\\x1B\\[[?;=0-9]*[a-zA-Z~]", "");
				if (!__instance.currentText.StartsWith("\n\n\n"))
				{
					__instance.currentText = "\n\n\n" + __instance.currentText.TrimStart('\n');
				}
				__instance.screenText.text = __instance.currentText;
				__instance.forceScrollbarCoroutine = ((MonoBehaviour)__instance).StartCoroutine(__instance.forceScrollbarDown());
			}
		}

		internal SshClient? sshClient;

		internal ShellStream? sshShell;

		internal StringBuilder _sgrCloseTags = new StringBuilder();

		internal bool _sgrDim = false;

		public static LethalSsh Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		public bool Active
		{
			get
			{
				SshClient val = sshClient;
				return val != null && ((BaseClient)val).IsConnected;
			}
		}

		internal static ConfigEntry<bool> enableANSI { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			enableANSI = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "enableFormatting", true, "Enable or disable text colorization and formatting.");
			Patch();
			Logger.LogInfo((object)"baer1.LethalSSH v0.1.1 has loaded!");
		}

		public static string GetColorByCode(string code)
		{
			if (code.StartsWith("4"))
			{
				code = $"3{code.Last()}";
			}
			else if (code.StartsWith("10"))
			{
				code = $"9{code.Last()}";
			}
			if (1 == 0)
			{
			}
			string result = code switch
			{
				"30" => "000000", 
				"31" => "AA0000", 
				"32" => "00AA00", 
				"33" => "AA5500", 
				"34" => "0000AA", 
				"35" => "AA00AA", 
				"36" => "00AAAA", 
				"37" => "AAAAAA", 
				"90" => "555555", 
				"91" => "FF5555", 
				"92" => "55FF55", 
				"93" => "FFFF55", 
				"94" => "5555FF", 
				"95" => "FF55FF", 
				"96" => "55FFFF", 
				_ => "FFFFFF", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string Get256ColorByCode(string code)
		{
			byte b;
			try
			{
				b = (byte)int.Parse(code);
			}
			catch
			{
				return "FFFFFF";
			}
			if (b <= 7)
			{
				return GetColorByCode($"3{b}");
			}
			if (b <= 15)
			{
				return GetColorByCode($"9{b - 8}");
			}
			if (b >= 232)
			{
				return string.Concat(Enumerable.Repeat((Enumerable.Range(0, 24).ToArray()[b - 232] * 10 + 8).ToString("X2"), 3));
			}
			byte[] array = new byte[3]
			{
				(byte)Math.Floor(((float)(int)b - 16f) / 36f),
				(byte)Math.Floor(((float)(int)b - 16f) % 36f / 6f),
				(byte)Math.Floor(((float)(int)b - 16f) % 6f)
			};
			StringBuilder stringBuilder = new StringBuilder();
			byte[] array2 = array;
			foreach (byte b2 in array2)
			{
				stringBuilder.Append((b2 == 0) ? "00" : (b2 * 40 + 55).ToString("X2"));
			}
			return stringBuilder.ToString();
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("baer1.LethalSSH");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}

		internal void ResetSSH()
		{
			if (Instance.Active)
			{
				((Stream)(object)Instance.sshShell).Close();
				((BaseClient)Instance.sshClient).Disconnect();
				Instance.sshClient = null;
				Instance._sgrCloseTags.Clear();
				Instance._sgrDim = false;
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "baer1.LethalSSH";

		public const string PLUGIN_NAME = "LethalSsh";

		public const string PLUGIN_VERSION = "0.1.1";
	}
}

The result has been truncated due to the large size, download it to view the full contents!

#define TRACE
using System;
using System.Buffers.Binary;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Formats.Asn1;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using Microsoft.CodeAnalysis;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.EdEC;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.Sec;
using Org.BouncyCastle.Asn1.X9;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Agreement;
using Org.BouncyCastle.Crypto.Digests;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Macs;
using Org.BouncyCastle.Crypto.Modes;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Prng;
using Org.BouncyCastle.Crypto.Signers;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Math.EC;
using Org.BouncyCastle.Math.EC.Rfc8032;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Utilities;
using Org.BouncyCastle.Utilities.Zlib;
using Renci.SshNet.Abstractions;
using Renci.SshNet.Channels;
using Renci.SshNet.Common;
using Renci.SshNet.Compression;
using Renci.SshNet.Connection;
using Renci.SshNet.Messages;
using Renci.SshNet.Messages.Authentication;
using Renci.SshNet.Messages.Connection;
using Renci.SshNet.Messages.Transport;
using Renci.SshNet.NetConf;
using Renci.SshNet.Security;
using Renci.SshNet.Security.Cryptography;
using Renci.SshNet.Security.Cryptography.Ciphers;
using Renci.SshNet.Security.Cryptography.Ciphers.Modes;
using Renci.SshNet.Security.Cryptography.Ciphers.Paddings;
using Renci.SshNet.Sftp;
using Renci.SshNet.Sftp.Requests;
using Renci.SshNet.Sftp.Responses;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("2024.2.0.1")]
[assembly: AssemblyInformationalVersion("2024.2.0.1+74d4364c32")]
[assembly: CLSCompliant(false)]
[assembly: Guid("ad816c5e-6f13-4589-9f3e-59523f8b77a4")]
[assembly: InternalsVisibleTo("Renci.SshNet.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2")]
[assembly: InternalsVisibleTo("Renci.SshNet.IntegrationTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2")]
[assembly: InternalsVisibleTo("Renci.SshNet.Benchmarks, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2")]
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Renci")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © Renci 2010-2024")]
[assembly: AssemblyDescription("SSH.NET is a Secure Shell (SSH) library for .NET, optimized for parallelism.")]
[assembly: AssemblyProduct("SSH.NET")]
[assembly: AssemblyTitle("SSH.NET")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/sshnet/SSH.NET.git")]
[assembly: AssemblyVersion("2024.2.0.1")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.7.77.5761")]
[ExcludeFromCodeCoverage]
internal static class ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "2024.2.0.1";

	internal const string AssemblyInformationalVersion = "2024.2.0.1+74d4364c32";

	internal const string AssemblyName = "Renci.SshNet";

	internal const string AssemblyTitle = "SSH.NET";

	internal const string AssemblyVersion = "2024.2.0.1";

	internal static readonly DateTime GitCommitDate = new DateTime(638667472230000000L, DateTimeKind.Utc);

	internal const string GitCommitId = "74d4364c32c523f2a7d9a3ddbfc3a304ee9fb023";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string NuGetPackageVersion = "2024.2.0";

	internal const string PublicKey = "0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2";

	internal const string PublicKeyToken = "1cee9f8bde3db106";

	internal const string RootNamespace = "Renci.SshNet";
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Threading.Tasks
{
	internal static class TaskToAsyncResult
	{
		private sealed class TaskAsyncResult : IAsyncResult
		{
			internal readonly Task _task;

			private readonly AsyncCallback? _callback;

			public object? AsyncState { get; }

			public bool CompletedSynchronously { get; }

			public bool IsCompleted => _task.IsCompleted;

			public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle;

			internal TaskAsyncResult(Task task, object? state, AsyncCallback? callback)
			{
				_task = task;
				AsyncState = state;
				if (task.IsCompleted)
				{
					CompletedSynchronously = true;
					callback?.Invoke(this);
				}
				else if (callback != null)
				{
					_callback = callback;
					_task.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter().OnCompleted(delegate
					{
						_callback(this);
					});
				}
			}
		}

		public static IAsyncResult Begin(Task task, AsyncCallback? callback, object? state)
		{
			if (task == null)
			{
				throw new ArgumentNullException("task");
			}
			return new TaskAsyncResult(task, state, callback);
		}

		public static void End(IAsyncResult asyncResult)
		{
			Unwrap(asyncResult).GetAwaiter().GetResult();
		}

		public static TResult End<TResult>(IAsyncResult asyncResult)
		{
			return Unwrap<TResult>(asyncResult).GetAwaiter().GetResult();
		}

		public static Task Unwrap(IAsyncResult asyncResult)
		{
			if (asyncResult == null)
			{
				throw new ArgumentNullException("asyncResult");
			}
			return (asyncResult as TaskAsyncResult)?._task ?? throw new ArgumentException(null, "asyncResult");
		}

		public static Task<TResult> Unwrap<TResult>(IAsyncResult asyncResult)
		{
			if (asyncResult == null)
			{
				throw new ArgumentNullException("asyncResult");
			}
			return ((asyncResult as TaskAsyncResult)?._task as Task<TResult>) ?? throw new ArgumentException(null, "asyncResult");
		}
	}
}
namespace Renci.SshNet
{
	public abstract class AuthenticationMethod : IAuthenticationMethod
	{
		public abstract string Name { get; }

		public string Username { get; private set; }

		public string[] AllowedAuthentications { get; protected set; }

		protected AuthenticationMethod(string username)
		{
			ThrowHelper.ThrowIfNullOrWhiteSpace(username, "username");
			Username = username;
		}

		public abstract AuthenticationResult Authenticate(Session session);

		AuthenticationResult IAuthenticationMethod.Authenticate(ISession session)
		{
			return Authenticate((Session)session);
		}
	}
	public enum AuthenticationResult
	{
		Success,
		PartialSuccess,
		Failure
	}
	public abstract class BaseClient : IBaseClient, IDisposable
	{
		private readonly bool _ownsConnectionInfo;

		private readonly IServiceFactory _serviceFactory;

		private readonly object _keepAliveLock = new object();

		private TimeSpan _keepAliveInterval;

		private Timer? _keepAliveTimer;

		private ConnectionInfo _connectionInfo;

		private bool _isDisposed;

		internal ISession? Session { get; private set; }

		internal IServiceFactory ServiceFactory => _serviceFactory;

		public ConnectionInfo ConnectionInfo
		{
			get
			{
				CheckDisposed();
				return _connectionInfo;
			}
			private set
			{
				_connectionInfo = value;
			}
		}

		public virtual bool IsConnected
		{
			get
			{
				CheckDisposed();
				return IsSessionConnected();
			}
		}

		public TimeSpan KeepAliveInterval
		{
			get
			{
				CheckDisposed();
				return _keepAliveInterval;
			}
			set
			{
				CheckDisposed();
				value.EnsureValidTimeout("KeepAliveInterval");
				if (!(value == _keepAliveInterval))
				{
					if (value == Timeout.InfiniteTimeSpan)
					{
						StopKeepAliveTimer();
					}
					else if (_keepAliveTimer != null)
					{
						_keepAliveTimer.Change(value, value);
					}
					else if (IsSessionConnected())
					{
						_keepAliveTimer = CreateKeepAliveTimer(value, value);
					}
					_keepAliveInterval = value;
				}
			}
		}

		public event EventHandler<ExceptionEventArgs>? ErrorOccurred;

		public event EventHandler<HostKeyEventArgs>? HostKeyReceived;

		public event EventHandler<SshIdentificationEventArgs>? ServerIdentificationReceived;

		protected BaseClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo)
			: this(connectionInfo, ownsConnectionInfo, new ServiceFactory())
		{
		}

		private protected BaseClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo, IServiceFactory serviceFactory)
		{
			ThrowHelper.ThrowIfNull(connectionInfo, "connectionInfo");
			ThrowHelper.ThrowIfNull(serviceFactory, "serviceFactory");
			_connectionInfo = connectionInfo;
			_ownsConnectionInfo = ownsConnectionInfo;
			_serviceFactory = serviceFactory;
			_keepAliveInterval = Timeout.InfiniteTimeSpan;
		}

		public void Connect()
		{
			CheckDisposed();
			if (IsConnected)
			{
				throw new InvalidOperationException("The client is already connected.");
			}
			OnConnecting();
			ISession session = Session;
			if (session == null || !session.IsConnected)
			{
				if (session != null)
				{
					DisposeSession(session);
				}
				Session = CreateAndConnectSession();
			}
			try
			{
				OnConnected();
			}
			catch
			{
				DisposeSession();
				throw;
			}
			StartKeepAliveTimer();
		}

		public async Task ConnectAsync(CancellationToken cancellationToken)
		{
			CheckDisposed();
			cancellationToken.ThrowIfCancellationRequested();
			if (IsConnected)
			{
				throw new InvalidOperationException("The client is already connected.");
			}
			OnConnecting();
			ISession session = Session;
			if (session == null || !session.IsConnected)
			{
				if (session != null)
				{
					DisposeSession(session);
				}
				using CancellationTokenSource timeoutCancellationTokenSource = new CancellationTokenSource(ConnectionInfo.Timeout);
				using CancellationTokenSource linkedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCancellationTokenSource.Token);
				try
				{
					Session = await CreateAndConnectSessionAsync(linkedCancellationTokenSource.Token).ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (OperationCanceledException innerException) when (timeoutCancellationTokenSource.IsCancellationRequested)
				{
					throw new SshOperationTimeoutException("Connection has timed out.", innerException);
				}
			}
			try
			{
				OnConnected();
			}
			catch
			{
				DisposeSession();
				throw;
			}
			StartKeepAliveTimer();
		}

		public void Disconnect()
		{
			CheckDisposed();
			OnDisconnecting();
			StopKeepAliveTimer();
			DisposeSession();
			OnDisconnected();
		}

		[Obsolete("Use KeepAliveInterval to send a keep-alive message at regular intervals.")]
		public void SendKeepAlive()
		{
			CheckDisposed();
			SendKeepAliveMessage();
		}

		protected virtual void OnConnecting()
		{
		}

		protected virtual void OnConnected()
		{
		}

		protected virtual void OnDisconnecting()
		{
			Session?.OnDisconnecting();
		}

		protected virtual void OnDisconnected()
		{
		}

		private void Session_ErrorOccured(object? sender, ExceptionEventArgs e)
		{
			this.ErrorOccurred?.Invoke(this, e);
		}

		private void Session_HostKeyReceived(object? sender, HostKeyEventArgs e)
		{
			this.HostKeyReceived?.Invoke(this, e);
		}

		private void Session_ServerIdentificationReceived(object? sender, SshIdentificationEventArgs e)
		{
			this.ServerIdentificationReceived?.Invoke(this, e);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_isDisposed && disposing)
			{
				Disconnect();
				if (_ownsConnectionInfo && _connectionInfo is IDisposable disposable)
				{
					disposable.Dispose();
				}
				_isDisposed = true;
			}
		}

		protected void CheckDisposed()
		{
			ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this);
		}

		private void StopKeepAliveTimer()
		{
			if (_keepAliveTimer != null)
			{
				_keepAliveTimer.Dispose();
				_keepAliveTimer = null;
			}
		}

		private void SendKeepAliveMessage()
		{
			ISession session = Session;
			if (session == null || !Monitor.TryEnter(_keepAliveLock))
			{
				return;
			}
			try
			{
				session.TrySendMessage(new IgnoreMessage());
			}
			finally
			{
				Monitor.Exit(_keepAliveLock);
			}
		}

		private void StartKeepAliveTimer()
		{
			if (!(_keepAliveInterval == Timeout.InfiniteTimeSpan) && _keepAliveTimer == null)
			{
				_keepAliveTimer = CreateKeepAliveTimer(_keepAliveInterval, _keepAliveInterval);
			}
		}

		private Timer CreateKeepAliveTimer(TimeSpan dueTime, TimeSpan period)
		{
			return new Timer(delegate
			{
				SendKeepAliveMessage();
			}, Session, dueTime, period);
		}

		private ISession CreateAndConnectSession()
		{
			ISession session = _serviceFactory.CreateSession(ConnectionInfo, _serviceFactory.CreateSocketFactory());
			session.ServerIdentificationReceived += Session_ServerIdentificationReceived;
			session.HostKeyReceived += Session_HostKeyReceived;
			session.ErrorOccured += Session_ErrorOccured;
			try
			{
				session.Connect();
				return session;
			}
			catch
			{
				DisposeSession(session);
				throw;
			}
		}

		private async Task<ISession> CreateAndConnectSessionAsync(CancellationToken cancellationToken)
		{
			ISession session = _serviceFactory.CreateSession(ConnectionInfo, _serviceFactory.CreateSocketFactory());
			session.ServerIdentificationReceived += Session_ServerIdentificationReceived;
			session.HostKeyReceived += Session_HostKeyReceived;
			session.ErrorOccured += Session_ErrorOccured;
			try
			{
				await session.ConnectAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				return session;
			}
			catch
			{
				DisposeSession(session);
				throw;
			}
		}

		private void DisposeSession(ISession session)
		{
			session.ErrorOccured -= Session_ErrorOccured;
			session.HostKeyReceived -= Session_HostKeyReceived;
			session.ServerIdentificationReceived -= Session_ServerIdentificationReceived;
			session.Dispose();
		}

		private void DisposeSession()
		{
			ISession session = Session;
			if (session != null)
			{
				Session = null;
				DisposeSession(session);
			}
		}

		private bool IsSessionConnected()
		{
			return Session?.IsConnected ?? false;
		}
	}
	public class CipherInfo
	{
		public int KeySize { get; private set; }

		public bool IsAead { get; private set; }

		public Func<byte[], byte[], Cipher> Cipher { get; private set; }

		public CipherInfo(int keySize, Func<byte[], byte[], Cipher> cipher, bool isAead = false)
		{
			CipherInfo cipherInfo = this;
			KeySize = keySize;
			Cipher = (byte[] key, byte[] iv) => cipher(key.Take(cipherInfo.KeySize / 8), iv);
			IsAead = isAead;
		}
	}
	internal sealed class ClientAuthentication : IClientAuthentication
	{
		private sealed class AuthenticationState
		{
			private readonly IList<IAuthenticationMethod> _supportedAuthenticationMethods;

			private readonly Dictionary<IAuthenticationMethod, int> _authenticationMethodPartialSuccessRegister;

			private readonly List<IAuthenticationMethod> _failedAuthenticationMethods;

			public AuthenticationState(IList<IAuthenticationMethod> supportedAuthenticationMethods)
			{
				_supportedAuthenticationMethods = supportedAuthenticationMethods;
				_failedAuthenticationMethods = new List<IAuthenticationMethod>();
				_authenticationMethodPartialSuccessRegister = new Dictionary<IAuthenticationMethod, int>();
			}

			public void RecordFailure(IAuthenticationMethod authenticationMethod)
			{
				_failedAuthenticationMethods.Add(authenticationMethod);
			}

			public void RecordPartialSuccess(IAuthenticationMethod authenticationMethod)
			{
				if (_authenticationMethodPartialSuccessRegister.TryGetValue(authenticationMethod, out var value))
				{
					_authenticationMethodPartialSuccessRegister[authenticationMethod] = value + 1;
				}
				else
				{
					_authenticationMethodPartialSuccessRegister.Add(authenticationMethod, 1);
				}
			}

			public int GetPartialSuccessCount(IAuthenticationMethod authenticationMethod)
			{
				if (_authenticationMethodPartialSuccessRegister.TryGetValue(authenticationMethod, out var value))
				{
					return value;
				}
				return 0;
			}

			public List<IAuthenticationMethod> GetSupportedAuthenticationMethods(string[] allowedAuthenticationMethods)
			{
				List<IAuthenticationMethod> list = new List<IAuthenticationMethod>();
				foreach (IAuthenticationMethod supportedAuthenticationMethod in _supportedAuthenticationMethods)
				{
					string name = supportedAuthenticationMethod.Name;
					for (int i = 0; i < allowedAuthenticationMethods.Length; i++)
					{
						if (allowedAuthenticationMethods[i] == name)
						{
							list.Add(supportedAuthenticationMethod);
							break;
						}
					}
				}
				return list;
			}

			public IEnumerable<IAuthenticationMethod> GetActiveAuthenticationMethods(List<IAuthenticationMethod> matchingAuthenticationMethods)
			{
				List<IAuthenticationMethod> skippedAuthenticationMethods = new List<IAuthenticationMethod>();
				for (int i = 0; i < matchingAuthenticationMethods.Count; i++)
				{
					IAuthenticationMethod authenticationMethod = matchingAuthenticationMethods[i];
					if (!_failedAuthenticationMethods.Contains(authenticationMethod))
					{
						if (_authenticationMethodPartialSuccessRegister.ContainsKey(authenticationMethod))
						{
							skippedAuthenticationMethods.Add(authenticationMethod);
						}
						else
						{
							yield return authenticationMethod;
						}
					}
				}
				foreach (IAuthenticationMethod item in skippedAuthenticationMethods)
				{
					yield return item;
				}
			}
		}

		private readonly int _partialSuccessLimit;

		internal int PartialSuccessLimit => _partialSuccessLimit;

		public ClientAuthentication(int partialSuccessLimit)
		{
			if (partialSuccessLimit < 1)
			{
				throw new ArgumentOutOfRangeException("partialSuccessLimit", "Cannot be less than one.");
			}
			_partialSuccessLimit = partialSuccessLimit;
		}

		public void Authenticate(IConnectionInfoInternal connectionInfo, ISession session)
		{
			ThrowHelper.ThrowIfNull(connectionInfo, "connectionInfo");
			ThrowHelper.ThrowIfNull(session, "session");
			session.RegisterMessage("SSH_MSG_USERAUTH_FAILURE");
			session.RegisterMessage("SSH_MSG_USERAUTH_SUCCESS");
			session.RegisterMessage("SSH_MSG_USERAUTH_BANNER");
			session.UserAuthenticationBannerReceived += connectionInfo.UserAuthenticationBannerReceived;
			try
			{
				SshAuthenticationException authenticationException = null;
				IAuthenticationMethod authenticationMethod = connectionInfo.CreateNoneAuthenticationMethod();
				if (authenticationMethod.Authenticate(session) != 0 && !TryAuthenticate(session, new AuthenticationState(connectionInfo.AuthenticationMethods), authenticationMethod.AllowedAuthentications, ref authenticationException))
				{
					throw authenticationException;
				}
			}
			finally
			{
				session.UserAuthenticationBannerReceived -= connectionInfo.UserAuthenticationBannerReceived;
				session.UnRegisterMessage("SSH_MSG_USERAUTH_FAILURE");
				session.UnRegisterMessage("SSH_MSG_USERAUTH_SUCCESS");
				session.UnRegisterMessage("SSH_MSG_USERAUTH_BANNER");
			}
		}

		private bool TryAuthenticate(ISession session, AuthenticationState authenticationState, string[] allowedAuthenticationMethods, ref SshAuthenticationException authenticationException)
		{
			if (allowedAuthenticationMethods.Length == 0)
			{
				authenticationException = new SshAuthenticationException("No authentication methods defined on SSH server.");
				return false;
			}
			List<IAuthenticationMethod> supportedAuthenticationMethods = authenticationState.GetSupportedAuthenticationMethods(allowedAuthenticationMethods);
			if (supportedAuthenticationMethods.Count == 0)
			{
				authenticationException = new SshAuthenticationException(string.Format(CultureInfo.InvariantCulture, "No suitable authentication method found to complete authentication ({0}).", string.Join(',', allowedAuthenticationMethods)));
				return false;
			}
			foreach (IAuthenticationMethod activeAuthenticationMethod in authenticationState.GetActiveAuthenticationMethods(supportedAuthenticationMethods))
			{
				if (authenticationState.GetPartialSuccessCount(activeAuthenticationMethod) >= _partialSuccessLimit)
				{
					authenticationException = new SshAuthenticationException($"Reached authentication attempt limit for method ({activeAuthenticationMethod.Name}).");
					continue;
				}
				AuthenticationResult authenticationResult = activeAuthenticationMethod.Authenticate(session);
				switch (authenticationResult)
				{
				case AuthenticationResult.PartialSuccess:
					authenticationState.RecordPartialSuccess(activeAuthenticationMethod);
					if (TryAuthenticate(session, authenticationState, activeAuthenticationMethod.AllowedAuthentications, ref authenticationException))
					{
						authenticationResult = AuthenticationResult.Success;
					}
					break;
				case AuthenticationResult.Failure:
					authenticationState.RecordFailure(activeAuthenticationMethod);
					authenticationException = new SshAuthenticationException($"Permission denied ({activeAuthenticationMethod.Name}).");
					break;
				case AuthenticationResult.Success:
					authenticationException = null;
					break;
				}
				if (authenticationResult != 0)
				{
					continue;
				}
				return true;
			}
			return false;
		}
	}
	public class ConnectionInfo : IConnectionInfoInternal, IConnectionInfo
	{
		internal const int DefaultPort = 22;

		private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(30.0);

		private static readonly TimeSpan DefaultChannelCloseTimeout = TimeSpan.FromSeconds(1.0);

		private TimeSpan _timeout;

		private TimeSpan _channelCloseTimeout;

		public IDictionary<string, Func<IKeyExchange>> KeyExchangeAlgorithms { get; private set; }

		public IDictionary<string, CipherInfo> Encryptions { get; private set; }

		public IDictionary<string, HashInfo> HmacAlgorithms { get; private set; }

		public IDictionary<string, Func<byte[], KeyHostAlgorithm>> HostKeyAlgorithms { get; private set; }

		public IList<AuthenticationMethod> AuthenticationMethods { get; private set; }

		public IDictionary<string, Func<Compressor>> CompressionAlgorithms { get; private set; }

		public IDictionary<string, RequestInfo> ChannelRequests { get; private set; }

		public bool IsAuthenticated { get; private set; }

		public string Host { get; private set; }

		public int Port { get; private set; }

		public string Username { get; private set; }

		public ProxyTypes ProxyType { get; private set; }

		public string ProxyHost { get; private set; }

		public int ProxyPort { get; private set; }

		public string ProxyUsername { get; private set; }

		public string ProxyPassword { get; private set; }

		public TimeSpan Timeout
		{
			get
			{
				return _timeout;
			}
			set
			{
				value.EnsureValidTimeout("Timeout");
				_timeout = value;
			}
		}

		public TimeSpan ChannelCloseTimeout
		{
			get
			{
				return _channelCloseTimeout;
			}
			set
			{
				value.EnsureValidTimeout("ChannelCloseTimeout");
				_channelCloseTimeout = value;
			}
		}

		public Encoding Encoding { get; set; }

		public int RetryAttempts { get; set; }

		public int MaxSessions { get; set; }

		public string CurrentKeyExchangeAlgorithm { get; internal set; }

		public string CurrentServerEncryption { get; internal set; }

		public string CurrentClientEncryption { get; internal set; }

		public string CurrentServerHmacAlgorithm { get; internal set; }

		public string CurrentClientHmacAlgorithm { get; internal set; }

		public string CurrentHostKeyAlgorithm { get; internal set; }

		public string CurrentServerCompressionAlgorithm { get; internal set; }

		public string ServerVersion { get; internal set; }

		public string ClientVersion { get; internal set; }

		public string CurrentClientCompressionAlgorithm { get; internal set; }

		IList<IAuthenticationMethod> IConnectionInfoInternal.AuthenticationMethods => AuthenticationMethods.Cast<IAuthenticationMethod>().ToList();

		public event EventHandler<AuthenticationBannerEventArgs> AuthenticationBanner;

		public ConnectionInfo(string host, string username, params AuthenticationMethod[] authenticationMethods)
			: this(host, 22, username, ProxyTypes.None, null, 0, null, null, authenticationMethods)
		{
		}

		public ConnectionInfo(string host, int port, string username, params AuthenticationMethod[] authenticationMethods)
			: this(host, port, username, ProxyTypes.None, null, 0, null, null, authenticationMethods)
		{
		}

		public ConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, params AuthenticationMethod[] authenticationMethods)
		{
			ThrowHelper.ThrowIfNull(host, "host");
			port.ValidatePort("port");
			ThrowHelper.ThrowIfNullOrWhiteSpace(username, "username");
			if (proxyType != 0)
			{
				ThrowHelper.ThrowIfNull(proxyHost, "proxyHost");
				proxyPort.ValidatePort("proxyPort");
			}
			ThrowHelper.ThrowIfNull(authenticationMethods, "authenticationMethods");
			if (authenticationMethods.Length == 0)
			{
				throw new ArgumentException("At least one authentication method should be specified.", "authenticationMethods");
			}
			Timeout = DefaultTimeout;
			ChannelCloseTimeout = DefaultChannelCloseTimeout;
			RetryAttempts = 10;
			MaxSessions = 10;
			Encoding = Encoding.UTF8;
			KeyExchangeAlgorithms = new Dictionary<string, Func<IKeyExchange>>
			{
				{
					"curve25519-sha256",
					() => new KeyExchangeECCurve25519()
				},
				{
					"[email protected]",
					() => new KeyExchangeECCurve25519()
				},
				{
					"ecdh-sha2-nistp256",
					() => new KeyExchangeECDH256()
				},
				{
					"ecdh-sha2-nistp384",
					() => new KeyExchangeECDH384()
				},
				{
					"ecdh-sha2-nistp521",
					() => new KeyExchangeECDH521()
				},
				{
					"diffie-hellman-group-exchange-sha256",
					() => new KeyExchangeDiffieHellmanGroupExchangeSha256()
				},
				{
					"diffie-hellman-group-exchange-sha1",
					() => new KeyExchangeDiffieHellmanGroupExchangeSha1()
				},
				{
					"diffie-hellman-group16-sha512",
					() => new KeyExchangeDiffieHellmanGroup16Sha512()
				},
				{
					"diffie-hellman-group14-sha256",
					() => new KeyExchangeDiffieHellmanGroup14Sha256()
				},
				{
					"diffie-hellman-group14-sha1",
					() => new KeyExchangeDiffieHellmanGroup14Sha1()
				},
				{
					"diffie-hellman-group1-sha1",
					() => new KeyExchangeDiffieHellmanGroup1Sha1()
				}
			};
			Encryptions = new Dictionary<string, CipherInfo>
			{
				{
					"aes128-ctr",
					new CipherInfo(128, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CTR))
				},
				{
					"aes192-ctr",
					new CipherInfo(192, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CTR))
				},
				{
					"aes256-ctr",
					new CipherInfo(256, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CTR))
				},
				{
					"[email protected]",
					new CipherInfo(128, (byte[] key, byte[] iv) => new AesGcmCipher(key, iv, 4), isAead: true)
				},
				{
					"[email protected]",
					new CipherInfo(256, (byte[] key, byte[] iv) => new AesGcmCipher(key, iv, 4), isAead: true)
				},
				{
					"[email protected]",
					new CipherInfo(512, (byte[] key, byte[] iv) => new ChaCha20Poly1305Cipher(key, 4), isAead: true)
				},
				{
					"aes128-cbc",
					new CipherInfo(128, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CBC))
				},
				{
					"aes192-cbc",
					new CipherInfo(192, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CBC))
				},
				{
					"aes256-cbc",
					new CipherInfo(256, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CBC))
				},
				{
					"3des-cbc",
					new CipherInfo(192, (byte[] key, byte[] iv) => new TripleDesCipher(key, new CbcCipherMode(iv), null))
				}
			};
			HmacAlgorithms = new Dictionary<string, HashInfo>
			{
				{
					"hmac-sha2-256",
					new HashInfo(256, (byte[] key) => new HMACSHA256(key))
				},
				{
					"hmac-sha2-512",
					new HashInfo(512, (byte[] key) => new HMACSHA512(key))
				},
				{
					"hmac-sha1",
					new HashInfo(160, (byte[] key) => new HMACSHA1(key))
				},
				{
					"[email protected]",
					new HashInfo(256, (byte[] key) => new HMACSHA256(key), isEncryptThenMAC: true)
				},
				{
					"[email protected]",
					new HashInfo(512, (byte[] key) => new HMACSHA512(key), isEncryptThenMAC: true)
				},
				{
					"[email protected]",
					new HashInfo(160, (byte[] key) => new HMACSHA1(key), isEncryptThenMAC: true)
				}
			};
			Dictionary<string, Func<byte[], KeyHostAlgorithm>> hostAlgs = new Dictionary<string, Func<byte[], KeyHostAlgorithm>>();
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate8 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate8, hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate7 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate7, hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate6 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate6, hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate5 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate5, hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate4 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate4, new RsaDigitalSignature((RsaKey)certificate4.Key, HashAlgorithmName.SHA512), hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate3 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate3, new RsaDigitalSignature((RsaKey)certificate3.Key, HashAlgorithmName.SHA256), hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate2 = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate2, hostAlgs);
			});
			hostAlgs.Add("[email protected]", delegate(byte[] data)
			{
				Certificate certificate = new Certificate(data);
				return new CertificateHostAlgorithm("[email protected]", certificate, hostAlgs);
			});
			hostAlgs.Add("ssh-ed25519", (byte[] data) => new KeyHostAlgorithm("ssh-ed25519", new ED25519Key(new SshKeyData(data))));
			hostAlgs.Add("ecdsa-sha2-nistp256", (byte[] data) => new KeyHostAlgorithm("ecdsa-sha2-nistp256", new EcdsaKey(new SshKeyData(data))));
			hostAlgs.Add("ecdsa-sha2-nistp384", (byte[] data) => new KeyHostAlgorithm("ecdsa-sha2-nistp384", new EcdsaKey(new SshKeyData(data))));
			hostAlgs.Add("ecdsa-sha2-nistp521", (byte[] data) => new KeyHostAlgorithm("ecdsa-sha2-nistp521", new EcdsaKey(new SshKeyData(data))));
			hostAlgs.Add("rsa-sha2-512", delegate(byte[] data)
			{
				RsaKey rsaKey2 = new RsaKey(new SshKeyData(data));
				return new KeyHostAlgorithm("rsa-sha2-512", rsaKey2, new RsaDigitalSignature(rsaKey2, HashAlgorithmName.SHA512));
			});
			hostAlgs.Add("rsa-sha2-256", delegate(byte[] data)
			{
				RsaKey rsaKey = new RsaKey(new SshKeyData(data));
				return new KeyHostAlgorithm("rsa-sha2-256", rsaKey, new RsaDigitalSignature(rsaKey, HashAlgorithmName.SHA256));
			});
			hostAlgs.Add("ssh-rsa", (byte[] data) => new KeyHostAlgorithm("ssh-rsa", new RsaKey(new SshKeyData(data))));
			hostAlgs.Add("ssh-dss", (byte[] data) => new KeyHostAlgorithm("ssh-dss", new DsaKey(new SshKeyData(data))));
			HostKeyAlgorithms = hostAlgs;
			CompressionAlgorithms = new Dictionary<string, Func<Compressor>>
			{
				{ "none", null },
				{
					"[email protected]",
					() => new ZlibOpenSsh()
				}
			};
			ChannelRequests = new Dictionary<string, RequestInfo>
			{
				{
					"env",
					new EnvironmentVariableRequestInfo()
				},
				{
					"exec",
					new ExecRequestInfo()
				},
				{
					"exit-signal",
					new ExitSignalRequestInfo()
				},
				{
					"exit-status",
					new ExitStatusRequestInfo()
				},
				{
					"pty-req",
					new PseudoTerminalRequestInfo()
				},
				{
					"shell",
					new ShellRequestInfo()
				},
				{
					"signal",
					new SignalRequestInfo()
				},
				{
					"subsystem",
					new SubsystemRequestInfo()
				},
				{
					"window-change",
					new WindowChangeRequestInfo()
				},
				{
					"x11-req",
					new X11ForwardingRequestInfo()
				},
				{
					"xon-xoff",
					new XonXoffRequestInfo()
				},
				{
					"[email protected]",
					new EndOfWriteRequestInfo()
				},
				{
					"[email protected]",
					new KeepAliveRequestInfo()
				}
			};
			Host = host;
			Port = port;
			Username = username;
			ProxyType = proxyType;
			ProxyHost = proxyHost;
			ProxyPort = proxyPort;
			ProxyUsername = proxyUsername;
			ProxyPassword = proxyPassword;
			AuthenticationMethods = authenticationMethods;
		}

		internal void Authenticate(ISession session, IServiceFactory serviceFactory)
		{
			ThrowHelper.ThrowIfNull(serviceFactory, "serviceFactory");
			IsAuthenticated = false;
			serviceFactory.CreateClientAuthentication().Authenticate(this, session);
			IsAuthenticated = true;
		}

		void IConnectionInfoInternal.UserAuthenticationBannerReceived(object sender, MessageEventArgs<BannerMessage> e)
		{
			this.AuthenticationBanner?.Invoke(this, new AuthenticationBannerEventArgs(Username, e.Message.Message, e.Message.Language));
		}

		IAuthenticationMethod IConnectionInfoInternal.CreateNoneAuthenticationMethod()
		{
			return new NoneAuthenticationMethod(Username);
		}
	}
	public class ExpectAction
	{
		public Regex Expect { get; private set; }

		public Action<string> Action { get; private set; }

		public ExpectAction(Regex expect, Action<string> action)
		{
			ThrowHelper.ThrowIfNull(expect, "expect");
			ThrowHelper.ThrowIfNull(action, "action");
			Expect = expect;
			Action = action;
		}

		public ExpectAction(string expect, Action<string> action)
		{
			ThrowHelper.ThrowIfNull(expect, "expect");
			ThrowHelper.ThrowIfNull(action, "action");
			Expect = new Regex(Regex.Escape(expect));
			Action = action;
		}
	}
	public abstract class ForwardedPort : IForwardedPort, IDisposable
	{
		internal ISession Session { get; set; }

		public abstract bool IsStarted { get; }

		public event EventHandler Closing;

		public event EventHandler<ExceptionEventArgs> Exception;

		public event EventHandler<PortForwardEventArgs> RequestReceived;

		public virtual void Start()
		{
			CheckDisposed();
			if (IsStarted)
			{
				throw new InvalidOperationException("Forwarded port is already started.");
			}
			if (Session == null)
			{
				throw new InvalidOperationException("Forwarded port is not added to a client.");
			}
			if (!Session.IsConnected)
			{
				throw new SshConnectionException("Client not connected.");
			}
			Session.ErrorOccured += Session_ErrorOccured;
			StartPort();
		}

		public virtual void Stop()
		{
			if (IsStarted)
			{
				StopPort(Session.ConnectionInfo.Timeout);
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected abstract void StartPort();

		protected virtual void StopPort(TimeSpan timeout)
		{
			timeout.EnsureValidTimeout("timeout");
			RaiseClosing();
			ISession session = Session;
			if (session != null)
			{
				session.ErrorOccured -= Session_ErrorOccured;
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				ISession session = Session;
				if (session != null)
				{
					StopPort(session.ConnectionInfo.Timeout);
					Session = null;
				}
			}
		}

		protected abstract void CheckDisposed();

		protected void RaiseExceptionEvent(Exception exception)
		{
			this.Exception?.Invoke(this, new ExceptionEventArgs(exception));
		}

		protected void RaiseRequestReceived(string host, uint port)
		{
			this.RequestReceived?.Invoke(this, new PortForwardEventArgs(host, port));
		}

		private void RaiseClosing()
		{
			this.Closing?.Invoke(this, EventArgs.Empty);
		}

		private void Session_ErrorOccured(object sender, ExceptionEventArgs e)
		{
			RaiseExceptionEvent(e.Exception);
		}
	}
	public class ForwardedPortDynamic : ForwardedPort
	{
		private ForwardedPortStatus _status;

		private bool _isDisposed;

		private Socket _listener;

		private CountdownEvent _pendingChannelCountdown;

		public string BoundHost { get; }

		public uint BoundPort { get; }

		public override bool IsStarted => _status == ForwardedPortStatus.Started;

		public ForwardedPortDynamic(uint port)
			: this(string.Empty, port)
		{
		}

		public ForwardedPortDynamic(string host, uint port)
		{
			BoundHost = host;
			BoundPort = port;
			_status = ForwardedPortStatus.Stopped;
		}

		protected override void StartPort()
		{
			if (!ForwardedPortStatus.ToStarting(ref _status))
			{
				return;
			}
			try
			{
				InternalStart();
			}
			catch (Exception)
			{
				_status = ForwardedPortStatus.Stopped;
				throw;
			}
		}

		protected override void StopPort(TimeSpan timeout)
		{
			timeout.EnsureValidTimeout("timeout");
			if (ForwardedPortStatus.ToStopping(ref _status))
			{
				base.StopPort(timeout);
				StopListener();
				InternalStop(timeout);
				_status = ForwardedPortStatus.Stopped;
			}
		}

		protected override void CheckDisposed()
		{
			ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this);
		}

		protected override void Dispose(bool disposing)
		{
			if (!_isDisposed)
			{
				base.Dispose(disposing);
				InternalDispose(disposing);
				_isDisposed = true;
			}
		}

		private void InternalStart()
		{
			InitializePendingChannelCountdown();
			IPAddress address = IPAddress.Any;
			if (!string.IsNullOrEmpty(BoundHost))
			{
				address = Dns.GetHostAddresses(BoundHost)[0];
			}
			IPEndPoint iPEndPoint = new IPEndPoint(address, (int)BoundPort);
			_listener = new Socket(iPEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
			{
				NoDelay = true
			};
			_listener.Bind(iPEndPoint);
			_listener.Listen(5);
			base.Session.ErrorOccured += Session_ErrorOccured;
			base.Session.Disconnected += Session_Disconnected;
			_status = ForwardedPortStatus.Started;
			StartAccept(null);
		}

		private void StartAccept(SocketAsyncEventArgs e)
		{
			if (e == null)
			{
				e = new SocketAsyncEventArgs();
				e.Completed += AcceptCompleted;
			}
			else
			{
				e.AcceptSocket = null;
			}
			if (!IsStarted)
			{
				return;
			}
			try
			{
				if (!_listener.AcceptAsync(e))
				{
					AcceptCompleted(null, e);
				}
			}
			catch (ObjectDisposedException)
			{
				if (_status == ForwardedPortStatus.Stopping || _status == ForwardedPortStatus.Stopped)
				{
					return;
				}
				throw;
			}
		}

		private void AcceptCompleted(object sender, SocketAsyncEventArgs e)
		{
			SocketError socketError = e.SocketError;
			if ((socketError != SocketError.OperationAborted && socketError != SocketError.NotSocket) || 1 == 0)
			{
				Socket acceptSocket = e.AcceptSocket;
				if (e.SocketError != 0)
				{
					StartAccept(e);
					CloseClientSocket(acceptSocket);
				}
				else
				{
					StartAccept(e);
					ProcessAccept(acceptSocket);
				}
			}
		}

		private void ProcessAccept(Socket clientSocket)
		{
			if (!IsStarted)
			{
				CloseClientSocket(clientSocket);
				return;
			}
			CountdownEvent pendingChannelCountdown = _pendingChannelCountdown;
			pendingChannelCountdown.AddCount();
			try
			{
				using IChannelDirectTcpip channelDirectTcpip = base.Session.CreateChannelDirectTcpip();
				channelDirectTcpip.Exception += Channel_Exception;
				if (!HandleSocks(channelDirectTcpip, clientSocket, base.Session.ConnectionInfo.Timeout))
				{
					CloseClientSocket(clientSocket);
				}
				else
				{
					channelDirectTcpip.Bind();
				}
			}
			catch (Exception exception)
			{
				RaiseExceptionEvent(exception);
				CloseClientSocket(clientSocket);
			}
			finally
			{
				try
				{
					pendingChannelCountdown.Signal();
				}
				catch (ObjectDisposedException)
				{
				}
			}
		}

		private void InitializePendingChannelCountdown()
		{
			Interlocked.Exchange(ref _pendingChannelCountdown, new CountdownEvent(1))?.Dispose();
		}

		private bool HandleSocks(IChannelDirectTcpip channel, Socket clientSocket, TimeSpan timeout)
		{
			base.Closing += closeClientSocket;
			try
			{
				int num = SocketAbstraction.ReadByte(clientSocket, timeout);
				return num switch
				{
					-1 => false, 
					4 => HandleSocks4(clientSocket, channel, timeout), 
					5 => HandleSocks5(clientSocket, channel, timeout), 
					_ => throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "SOCKS version {0} is not supported.", num)), 
				};
			}
			catch (SocketException ex)
			{
				if (ex.SocketErrorCode != SocketError.ConnectionAborted)
				{
					RaiseExceptionEvent(ex);
				}
				return false;
			}
			finally
			{
				base.Closing -= closeClientSocket;
			}
			void closeClientSocket(object sender, EventArgs args)
			{
				CloseClientSocket(clientSocket);
			}
		}

		private static void CloseClientSocket(Socket clientSocket)
		{
			if (clientSocket.Connected)
			{
				try
				{
					clientSocket.Shutdown(SocketShutdown.Send);
				}
				catch (Exception)
				{
				}
			}
			clientSocket.Dispose();
		}

		private void StopListener()
		{
			_listener?.Dispose();
			ISession session = base.Session;
			if (session != null)
			{
				session.ErrorOccured -= Session_ErrorOccured;
				session.Disconnected -= Session_Disconnected;
			}
		}

		private void InternalStop(TimeSpan timeout)
		{
			_pendingChannelCountdown.Signal();
			_pendingChannelCountdown.Wait(timeout);
		}

		private void InternalDispose(bool disposing)
		{
			if (disposing)
			{
				Socket listener = _listener;
				if (listener != null)
				{
					_listener = null;
					listener.Dispose();
				}
				CountdownEvent pendingChannelCountdown = _pendingChannelCountdown;
				if (pendingChannelCountdown != null)
				{
					_pendingChannelCountdown = null;
					pendingChannelCountdown.Dispose();
				}
			}
		}

		private void Session_Disconnected(object sender, EventArgs e)
		{
			ISession session = base.Session;
			if (session != null)
			{
				StopPort(session.ConnectionInfo.Timeout);
			}
		}

		private void Session_ErrorOccured(object sender, ExceptionEventArgs e)
		{
			ISession session = base.Session;
			if (session != null)
			{
				StopPort(session.ConnectionInfo.Timeout);
			}
		}

		private void Channel_Exception(object sender, ExceptionEventArgs e)
		{
			RaiseExceptionEvent(e.Exception);
		}

		private bool HandleSocks4(Socket socket, IChannelDirectTcpip channel, TimeSpan timeout)
		{
			if (SocketAbstraction.ReadByte(socket, timeout) == -1)
			{
				return false;
			}
			byte[] array = new byte[2];
			if (SocketAbstraction.Read(socket, array, 0, array.Length, timeout) == 0)
			{
				return false;
			}
			ushort port = BinaryPrimitives.ReadUInt16BigEndian(array);
			byte[] array2 = new byte[4];
			if (SocketAbstraction.Read(socket, array2, 0, array2.Length, timeout) == 0)
			{
				return false;
			}
			IPAddress iPAddress = new IPAddress(array2);
			if (ReadString(socket, timeout) == null)
			{
				return false;
			}
			string text = iPAddress.ToString();
			RaiseRequestReceived(text, port);
			channel.Open(text, port, this, socket);
			SocketAbstraction.SendByte(socket, 0);
			if (channel.IsOpen)
			{
				SocketAbstraction.SendByte(socket, 90);
				SocketAbstraction.Send(socket, array, 0, array.Length);
				SocketAbstraction.Send(socket, array2, 0, array2.Length);
				return true;
			}
			SocketAbstraction.SendByte(socket, 91);
			return false;
		}

		private bool HandleSocks5(Socket socket, IChannelDirectTcpip channel, TimeSpan timeout)
		{
			int num = SocketAbstraction.ReadByte(socket, timeout);
			if (num == -1)
			{
				return false;
			}
			byte[] array = new byte[num];
			if (SocketAbstraction.Read(socket, array, 0, array.Length, timeout) == 0)
			{
				return false;
			}
			if (array.Min() == 0)
			{
				SocketAbstraction.Send(socket, new byte[2] { 5, 0 }, 0, 2);
			}
			else
			{
				SocketAbstraction.Send(socket, new byte[2] { 5, 255 }, 0, 2);
			}
			switch (SocketAbstraction.ReadByte(socket, timeout))
			{
			case -1:
				return false;
			default:
				throw new ProxyException("SOCKS5: Version 5 is expected.");
			case 5:
				if (SocketAbstraction.ReadByte(socket, timeout) == -1)
				{
					return false;
				}
				switch (SocketAbstraction.ReadByte(socket, timeout))
				{
				case -1:
					return false;
				default:
					throw new ProxyException("SOCKS5: 0 is expected for reserved byte.");
				case 0:
				{
					int num2 = SocketAbstraction.ReadByte(socket, timeout);
					if (num2 == -1)
					{
						return false;
					}
					string socks5Host = GetSocks5Host(num2, socket, timeout);
					if (socks5Host == null)
					{
						return false;
					}
					byte[] array2 = new byte[2];
					if (SocketAbstraction.Read(socket, array2, 0, array2.Length, timeout) == 0)
					{
						return false;
					}
					ushort port = BinaryPrimitives.ReadUInt16BigEndian(array2);
					RaiseRequestReceived(socks5Host, port);
					channel.Open(socks5Host, port, this, socket);
					byte[] array3 = CreateSocks5Reply(channel.IsOpen);
					SocketAbstraction.Send(socket, array3, 0, array3.Length);
					return true;
				}
				}
			}
		}

		private static string GetSocks5Host(int addressType, Socket socket, TimeSpan timeout)
		{
			switch (addressType)
			{
			case 1:
			{
				byte[] array3 = new byte[4];
				if (SocketAbstraction.Read(socket, array3, 0, 4, timeout) == 0)
				{
					return null;
				}
				return new IPAddress(array3).ToString();
			}
			case 3:
			{
				int num = SocketAbstraction.ReadByte(socket, timeout);
				if (num == -1)
				{
					return null;
				}
				byte[] array2 = new byte[num];
				if (SocketAbstraction.Read(socket, array2, 0, array2.Length, timeout) == 0)
				{
					return null;
				}
				return SshData.Ascii.GetString(array2, 0, array2.Length);
			}
			case 4:
			{
				byte[] array = new byte[16];
				if (SocketAbstraction.Read(socket, array, 0, 16, timeout) == 0)
				{
					return null;
				}
				return new IPAddress(array).ToString();
			}
			default:
				throw new ProxyException(string.Format(CultureInfo.InvariantCulture, "SOCKS5: Address type '{0}' is not supported.", addressType));
			}
		}

		private static byte[] CreateSocks5Reply(bool channelOpen)
		{
			byte[] array = new byte[10] { 5, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			if (channelOpen)
			{
				array[1] = 0;
			}
			else
			{
				array[1] = 1;
			}
			array[2] = 0;
			array[3] = 1;
			return array;
		}

		private static string ReadString(Socket socket, TimeSpan timeout)
		{
			StringBuilder stringBuilder = new StringBuilder();
			byte[] array = new byte[1];
			while (true)
			{
				if (SocketAbstraction.Read(socket, array, 0, 1, timeout) == 0)
				{
					return null;
				}
				byte b = array[0];
				if (b == 0)
				{
					break;
				}
				stringBuilder.Append((char)b);
			}
			return stringBuilder.ToString();
		}

		~ForwardedPortDynamic()
		{
			Dispose(disposing: false);
		}
	}
	public class ForwardedPortLocal : ForwardedPort
	{
		private ForwardedPortStatus _status;

		private bool _isDisposed;

		private Socket _listener;

		private CountdownEvent _pendingChannelCountdown;

		public string BoundHost { get; private set; }

		public uint BoundPort { get; private set; }

		public string Host { get; private set; }

		public uint Port { get; private set; }

		public override bool IsStarted => _status == ForwardedPortStatus.Started;

		public ForwardedPortLocal(uint boundPort, string host, uint port)
			: this(string.Empty, boundPort, host, port)
		{
		}

		public ForwardedPortLocal(string boundHost, string host, uint port)
			: this(boundHost, 0u, host, port)
		{
		}

		public ForwardedPortLocal(string boundHost, uint boundPort, string host, uint port)
		{
			ThrowHelper.ThrowIfNull(boundHost, "boundHost");
			ThrowHelper.ThrowIfNull(host, "host");
			boundPort.ValidatePort("boundPort");
			port.ValidatePort("port");
			BoundHost = boundHost;
			BoundPort = boundPort;
			Host = host;
			Port = port;
			_status = ForwardedPortStatus.Stopped;
		}

		protected override void StartPort()
		{
			if (!ForwardedPortStatus.ToStarting(ref _status))
			{
				return;
			}
			try
			{
				InternalStart();
			}
			catch (Exception)
			{
				_status = ForwardedPortStatus.Stopped;
				throw;
			}
		}

		protected override void StopPort(TimeSpan timeout)
		{
			timeout.EnsureValidTimeout("timeout");
			if (ForwardedPortStatus.ToStopping(ref _status))
			{
				base.StopPort(timeout);
				StopListener();
				InternalStop(timeout);
				_status = ForwardedPortStatus.Stopped;
			}
		}

		protected override void CheckDisposed()
		{
			ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this);
		}

		protected override void Dispose(bool disposing)
		{
			if (!_isDisposed)
			{
				base.Dispose(disposing);
				InternalDispose(disposing);
				_isDisposed = true;
			}
		}

		~ForwardedPortLocal()
		{
			Dispose(disposing: false);
		}

		private void InternalStart()
		{
			IPEndPoint iPEndPoint = new IPEndPoint(Dns.GetHostAddresses(BoundHost)[0], (int)BoundPort);
			_listener = new Socket(iPEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
			{
				NoDelay = true
			};
			_listener.Bind(iPEndPoint);
			_listener.Listen(5);
			BoundPort = (uint)((IPEndPoint)_listener.LocalEndPoint).Port;
			base.Session.ErrorOccured += Session_ErrorOccured;
			base.Session.Disconnected += Session_Disconnected;
			InitializePendingChannelCountdown();
			_status = ForwardedPortStatus.Started;
			StartAccept(null);
		}

		private void StartAccept(SocketAsyncEventArgs e)
		{
			if (e == null)
			{
				e = new SocketAsyncEventArgs();
				e.Completed += AcceptCompleted;
			}
			else
			{
				e.AcceptSocket = null;
			}
			if (!IsStarted)
			{
				return;
			}
			try
			{
				if (!_listener.AcceptAsync(e))
				{
					AcceptCompleted(null, e);
				}
			}
			catch (ObjectDisposedException)
			{
				if (_status == ForwardedPortStatus.Stopping || _status == ForwardedPortStatus.Stopped)
				{
					return;
				}
				throw;
			}
		}

		private void AcceptCompleted(object sender, SocketAsyncEventArgs e)
		{
			SocketError socketError = e.SocketError;
			if ((socketError != SocketError.OperationAborted && socketError != SocketError.NotSocket) || 1 == 0)
			{
				Socket acceptSocket = e.AcceptSocket;
				if (e.SocketError != 0)
				{
					StartAccept(e);
					CloseClientSocket(acceptSocket);
				}
				else
				{
					StartAccept(e);
					ProcessAccept(acceptSocket);
				}
			}
		}

		private void ProcessAccept(Socket clientSocket)
		{
			if (!IsStarted)
			{
				CloseClientSocket(clientSocket);
				return;
			}
			CountdownEvent pendingChannelCountdown = _pendingChannelCountdown;
			pendingChannelCountdown.AddCount();
			try
			{
				IPEndPoint iPEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint;
				RaiseRequestReceived(iPEndPoint.Address.ToString(), (uint)iPEndPoint.Port);
				using IChannelDirectTcpip channelDirectTcpip = base.Session.CreateChannelDirectTcpip();
				channelDirectTcpip.Exception += Channel_Exception;
				channelDirectTcpip.Open(Host, Port, this, clientSocket);
				channelDirectTcpip.Bind();
			}
			catch (Exception exception)
			{
				RaiseExceptionEvent(exception);
				CloseClientSocket(clientSocket);
			}
			finally
			{
				try
				{
					pendingChannelCountdown.Signal();
				}
				catch (ObjectDisposedException)
				{
				}
			}
		}

		private void InitializePendingChannelCountdown()
		{
			Interlocked.Exchange(ref _pendingChannelCountdown, new CountdownEvent(1))?.Dispose();
		}

		private static void CloseClientSocket(Socket clientSocket)
		{
			if (clientSocket.Connected)
			{
				try
				{
					clientSocket.Shutdown(SocketShutdown.Send);
				}
				catch (Exception)
				{
				}
			}
			clientSocket.Dispose();
		}

		private void StopListener()
		{
			_listener?.Dispose();
			ISession session = base.Session;
			if (session != null)
			{
				session.ErrorOccured -= Session_ErrorOccured;
				session.Disconnected -= Session_Disconnected;
			}
		}

		private void InternalStop(TimeSpan timeout)
		{
			_pendingChannelCountdown.Signal();
			_pendingChannelCountdown.Wait(timeout);
		}

		private void InternalDispose(bool disposing)
		{
			if (disposing)
			{
				Socket listener = _listener;
				if (listener != null)
				{
					_listener = null;
					listener.Dispose();
				}
				CountdownEvent pendingChannelCountdown = _pendingChannelCountdown;
				if (pendingChannelCountdown != null)
				{
					_pendingChannelCountdown = null;
					pendingChannelCountdown.Dispose();
				}
			}
		}

		private void Session_Disconnected(object sender, EventArgs e)
		{
			ISession session = base.Session;
			if (session != null)
			{
				StopPort(session.ConnectionInfo.Timeout);
			}
		}

		private void Session_ErrorOccured(object sender, ExceptionEventArgs e)
		{
			ISession session = base.Session;
			if (session != null)
			{
				StopPort(session.ConnectionInfo.Timeout);
			}
		}

		private void Channel_Exception(object sender, ExceptionEventArgs e)
		{
			RaiseExceptionEvent(e.Exception);
		}
	}
	public class ForwardedPortRemote : ForwardedPort
	{
		private ForwardedPortStatus _status;

		private bool _requestStatus;

		private EventWaitHandle _globalRequestResponse = new AutoResetEvent(initialState: false);

		private CountdownEvent _pendingChannelCountdown;

		private bool _isDisposed;

		public override bool IsStarted => _status == ForwardedPortStatus.Started;

		public IPAddress BoundHostAddress { get; private set; }

		public string BoundHost => BoundHostAddress.ToString();

		public uint BoundPort { get; private set; }

		public IPAddress HostAddress { get; private set; }

		public string Host => HostAddress.ToString();

		public uint Port { get; private set; }

		public ForwardedPortRemote(IPAddress boundHostAddress, uint boundPort, IPAddress hostAddress, uint port)
		{
			ThrowHelper.ThrowIfNull(boundHostAddress, "boundHostAddress");
			ThrowHelper.ThrowIfNull(hostAddress, "hostAddress");
			boundPort.ValidatePort("boundPort");
			port.ValidatePort("port");
			BoundHostAddress = boundHostAddress;
			BoundPort = boundPort;
			HostAddress = hostAddress;
			Port = port;
			_status = ForwardedPortStatus.Stopped;
		}

		public ForwardedPortRemote(uint boundPort, string host, uint port)
			: this(string.Empty, boundPort, host, port)
		{
		}

		public ForwardedPortRemote(string boundHost, uint boundPort, string host, uint port)
			: this(Dns.GetHostAddresses(boundHost)[0], boundPort, Dns.GetHostAddresses(host)[0], port)
		{
		}

		protected override void StartPort()
		{
			if (!ForwardedPortStatus.ToStarting(ref _status))
			{
				return;
			}
			InitializePendingChannelCountdown();
			try
			{
				base.Session.RegisterMessage("SSH_MSG_REQUEST_FAILURE");
				base.Session.RegisterMessage("SSH_MSG_REQUEST_SUCCESS");
				base.Session.RegisterMessage("SSH_MSG_CHANNEL_OPEN");
				base.Session.RequestSuccessReceived += Session_RequestSuccess;
				base.Session.RequestFailureReceived += Session_RequestFailure;
				base.Session.ChannelOpenReceived += Session_ChannelOpening;
				base.Session.SendMessage(new TcpIpForwardGlobalRequestMessage(BoundHost, BoundPort));
				base.Session.WaitOnHandle(_globalRequestResponse);
				if (!_requestStatus)
				{
					throw new SshException(string.Format(CultureInfo.CurrentCulture, "Port forwarding for '{0}' port '{1}' failed to start.", Host, Port));
				}
			}
			catch (Exception)
			{
				_status = ForwardedPortStatus.Stopped;
				base.Session.RequestSuccessReceived -= Session_RequestSuccess;
				base.Session.RequestFailureReceived -= Session_RequestFailure;
				base.Session.ChannelOpenReceived -= Session_ChannelOpening;
				throw;
			}
			_status = ForwardedPortStatus.Started;
		}

		protected override void StopPort(TimeSpan timeout)
		{
			timeout.EnsureValidTimeout("timeout");
			if (ForwardedPortStatus.ToStopping(ref _status))
			{
				base.StopPort(timeout);
				base.Session.SendMessage(new CancelTcpIpForwardGlobalRequestMessage(BoundHost, BoundPort));
				WaitHandle.WaitAny(new WaitHandle[2]
				{
					_globalRequestResponse,
					base.Session.MessageListenerCompleted
				}, timeout);
				base.Session.RequestSuccessReceived -= Session_RequestSuccess;
				base.Session.RequestFailureReceived -= Session_RequestFailure;
				base.Session.ChannelOpenReceived -= Session_ChannelOpening;
				_pendingChannelCountdown.Signal();
				_pendingChannelCountdown.Wait(timeout);
				_status = ForwardedPortStatus.Stopped;
			}
		}

		protected override void CheckDisposed()
		{
			ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this);
		}

		private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenMessage> e)
		{
			ChannelOpenMessage channelOpenMessage = e.Message;
			ChannelOpenInfo info2 = channelOpenMessage.Info;
			ForwardedTcpipChannelInfo info = info2 as ForwardedTcpipChannelInfo;
			if (info == null || !(info.ConnectedAddress == BoundHost) || info.ConnectedPort != BoundPort)
			{
				return;
			}
			if (!IsStarted)
			{
				base.Session.SendMessage(new ChannelOpenFailureMessage(channelOpenMessage.LocalChannelNumber, string.Empty, 1u));
				return;
			}
			ThreadAbstraction.ExecuteThread(delegate
			{
				CountdownEvent pendingChannelCountdown = _pendingChannelCountdown;
				pendingChannelCountdown.AddCount();
				try
				{
					RaiseRequestReceived(info.OriginatorAddress, info.OriginatorPort);
					using IChannelForwardedTcpip channelForwardedTcpip = base.Session.CreateChannelForwardedTcpip(channelOpenMessage.LocalChannelNumber, channelOpenMessage.InitialWindowSize, channelOpenMessage.MaximumPacketSize);
					channelForwardedTcpip.Exception += Channel_Exception;
					channelForwardedTcpip.Bind(new IPEndPoint(HostAddress, (int)Port), this);
				}
				catch (Exception exception)
				{
					RaiseExceptionEvent(exception);
				}
				finally
				{
					try
					{
						pendingChannelCountdown.Signal();
					}
					catch (ObjectDisposedException)
					{
					}
				}
			});
		}

		private void InitializePendingChannelCountdown()
		{
			Interlocked.Exchange(ref _pendingChannelCountdown, new CountdownEvent(1))?.Dispose();
		}

		private void Channel_Exception(object sender, ExceptionEventArgs exceptionEventArgs)
		{
			RaiseExceptionEvent(exceptionEventArgs.Exception);
		}

		private void Session_RequestFailure(object sender, EventArgs e)
		{
			_requestStatus = false;
			_globalRequestResponse.Set();
		}

		private void Session_RequestSuccess(object sender, MessageEventArgs<RequestSuccessMessage> e)
		{
			_requestStatus = true;
			if (BoundPort == 0)
			{
				BoundPort = (e.Message.BoundPort.HasValue ? e.Message.BoundPort.Value : 0u);
			}
			_globalRequestResponse.Set();
		}

		protected override void Dispose(bool disposing)
		{
			if (_isDisposed)
			{
				return;
			}
			base.Dispose(disposing);
			if (disposing)
			{
				ISession session = base.Session;
				if (session != null)
				{
					base.Session = null;
					session.RequestSuccessReceived -= Session_RequestSuccess;
					session.RequestFailureReceived -= Session_RequestFailure;
					session.ChannelOpenReceived -= Session_ChannelOpening;
				}
				EventWaitHandle globalRequestResponse = _globalRequestResponse;
				if (globalRequestResponse != null)
				{
					_globalRequestResponse = null;
					globalRequestResponse.Dispose();
				}
				CountdownEvent pendingChannelCountdown = _pendingChannelCountdown;
				if (pendingChannelCountdown != null)
				{
					_pendingChannelCountdown = null;
					pendingChannelCountdown.Dispose();
				}
			}
			_isDisposed = true;
		}
	}
	internal sealed class ForwardedPortStatus
	{
		public static readonly ForwardedPortStatus Stopped = new ForwardedPortStatus(1, "Stopped");

		public static readonly ForwardedPortStatus Stopping = new ForwardedPortStatus(2, "Stopping");

		public static readonly ForwardedPortStatus Started = new ForwardedPortStatus(3, "Started");

		public static readonly ForwardedPortStatus Starting = new ForwardedPortStatus(4, "Starting");

		private readonly int _value;

		private readonly string _name;

		private ForwardedPortStatus(int value, string name)
		{
			_value = value;
			_name = name;
		}

		public override bool Equals(object obj)
		{
			if (this == obj)
			{
				return true;
			}
			if (!(obj is ForwardedPortStatus forwardedPortStatus))
			{
				return false;
			}
			return forwardedPortStatus._value == _value;
		}

		public static bool operator ==(ForwardedPortStatus left, ForwardedPortStatus right)
		{
			return left?.Equals(right) ?? ((object)right == null);
		}

		public static bool operator !=(ForwardedPortStatus left, ForwardedPortStatus right)
		{
			return !(left == right);
		}

		public override int GetHashCode()
		{
			return _value;
		}

		public override string ToString()
		{
			return _name;
		}

		public static bool ToStopping(ref ForwardedPortStatus status)
		{
			ForwardedPortStatus forwardedPortStatus = Interlocked.CompareExchange(ref status, Stopping, Started);
			if (forwardedPortStatus == Stopping || forwardedPortStatus == Stopped)
			{
				return false;
			}
			if (status == Stopping)
			{
				return true;
			}
			forwardedPortStatus = Interlocked.CompareExchange(ref status, Stopping, Starting);
			if (forwardedPortStatus == Stopping || forwardedPortStatus == Stopped)
			{
				return false;
			}
			if (status == Stopping)
			{
				return true;
			}
			throw new InvalidOperationException($"Forwarded port cannot transition from '{forwardedPortStatus}' to '{Stopping}'.");
		}

		public static bool ToStarting(ref ForwardedPortStatus status)
		{
			ForwardedPortStatus forwardedPortStatus = Interlocked.CompareExchange(ref status, Starting, Stopped);
			if (forwardedPortStatus == Starting || forwardedPortStatus == Started)
			{
				return false;
			}
			if (status == Starting)
			{
				return true;
			}
			throw new InvalidOperationException($"Forwarded port cannot transition from '{forwardedPortStatus}' to '{Starting}'.");
		}
	}
	public class HashInfo
	{
		public int KeySize { get; private set; }

		public bool IsEncryptThenMAC { get; private set; }

		public Func<byte[], HashAlgorithm> HashAlgorithm { get; private set; }

		public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash, bool isEncryptThenMAC = false)
		{
			HashInfo hashInfo = this;
			KeySize = keySize;
			HashAlgorithm = (byte[] key) => hash(key.Take(hashInfo.KeySize / 8));
			IsEncryptThenMAC = isEncryptThenMAC;
		}
	}
	internal interface IAuthenticationMethod
	{
		string[] AllowedAuthentications { get; }

		string Name { get; }

		AuthenticationResult Authenticate(ISession session);
	}
	public interface IBaseClient : IDisposable
	{
		ConnectionInfo ConnectionInfo { get; }

		bool IsConnected { get; }

		TimeSpan KeepAliveInterval { get; set; }

		event EventHandler<ExceptionEventArgs> ErrorOccurred;

		event EventHandler<HostKeyEventArgs> HostKeyReceived;

		event EventHandler<SshIdentificationEventArgs>? ServerIdentificationReceived;

		void Connect();

		Task ConnectAsync(CancellationToken cancellationToken);

		void Disconnect();

		void SendKeepAlive();
	}
	internal interface IClientAuthentication
	{
		void Authenticate(IConnectionInfoInternal connectionInfo, ISession session);
	}
	internal interface IConnectionInfo
	{
		TimeSpan ChannelCloseTimeout { get; }

		IDictionary<string, RequestInfo> ChannelRequests { get; }

		Encoding Encoding { get; }

		string Host { get; }

		int Port { get; }

		ProxyTypes ProxyType { get; }

		string ProxyHost { get; }

		int ProxyPort { get; }

		string ProxyUsername { get; }

		string ProxyPassword { get; }

		int RetryAttempts { get; }

		TimeSpan Timeout { get; }

		event EventHandler<AuthenticationBannerEventArgs> AuthenticationBanner;
	}
	internal interface IConnectionInfoInternal : IConnectionInfo
	{
		IList<IAuthenticationMethod> AuthenticationMethods { get; }

		void UserAuthenticationBannerReceived(object sender, MessageEventArgs<BannerMessage> e);

		IAuthenticationMethod CreateNoneAuthenticationMethod();
	}
	public interface IForwardedPort : IDisposable
	{
		event EventHandler Closing;
	}
	public interface IPrivateKeySource
	{
		IReadOnlyCollection<HostAlgorithm> HostKeyAlgorithms { get; }
	}
	public interface IRemotePathTransformation
	{
		string Transform(string path);
	}
	internal interface IServiceFactory
	{
		IClientAuthentication CreateClientAuthentication();

		INetConfSession CreateNetConfSession(ISession session, int operationTimeout);

		ISession CreateSession(ConnectionInfo connectionInfo, ISocketFactory socketFactory);

		ISftpSession CreateSftpSession(ISession session, int operationTimeout, Encoding encoding, ISftpResponseFactory sftpMessageFactory);

		PipeStream CreatePipeStream();

		IKeyExchange CreateKeyExchange(IDictionary<string, Func<IKeyExchange>> clientAlgorithms, string[] serverAlgorithms);

		ISftpFileReader CreateSftpFileReader(string fileName, ISftpSession sftpSession, uint bufferSize);

		ISftpResponseFactory CreateSftpResponseFactory();

		ShellStream CreateShellStream(ISession session, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModeValues, int bufferSize);

		ShellStream CreateShellStreamNoTerminal(ISession session, int bufferSize);

		IRemotePathTransformation CreateRemotePathDoubleQuoteTransformation();

		IConnector CreateConnector(IConnectionInfo connectionInfo, ISocketFactory socketFactory);

		IProtocolVersionExchange CreateProtocolVersionExchange();

		ISocketFactory CreateSocketFactory();
	}
	internal interface ISession : IDisposable
	{
		IConnectionInfo ConnectionInfo { get; }

		bool IsConnected { get; }

		SemaphoreSlim SessionSemaphore { get; }

		WaitHandle MessageListenerCompleted { get; }

		event EventHandler<MessageEventArgs<ChannelCloseMessage>> ChannelCloseReceived;

		event EventHandler<MessageEventArgs<ChannelDataMessage>> ChannelDataReceived;

		event EventHandler<MessageEventArgs<ChannelEofMessage>> ChannelEofReceived;

		event EventHandler<MessageEventArgs<ChannelExtendedDataMessage>> ChannelExtendedDataReceived;

		event EventHandler<MessageEventArgs<ChannelFailureMessage>> ChannelFailureReceived;

		event EventHandler<MessageEventArgs<ChannelOpenConfirmationMessage>> ChannelOpenConfirmationReceived;

		event EventHandler<MessageEventArgs<ChannelOpenFailureMessage>> ChannelOpenFailureReceived;

		event EventHandler<MessageEventArgs<ChannelOpenMessage>> ChannelOpenReceived;

		event EventHandler<MessageEventArgs<ChannelRequestMessage>> ChannelRequestReceived;

		event EventHandler<MessageEventArgs<ChannelSuccessMessage>> ChannelSuccessReceived;

		event EventHandler<MessageEventArgs<ChannelWindowAdjustMessage>> ChannelWindowAdjustReceived;

		event EventHandler<EventArgs> Disconnected;

		event EventHandler<ExceptionEventArgs> ErrorOccured;

		event EventHandler<SshIdentificationEventArgs> ServerIdentificationReceived;

		event EventHandler<HostKeyEventArgs> HostKeyReceived;

		event EventHandler<MessageEventArgs<RequestSuccessMessage>> RequestSuccessReceived;

		event EventHandler<MessageEventArgs<RequestFailureMessage>> RequestFailureReceived;

		event EventHandler<MessageEventArgs<BannerMessage>> UserAuthenticationBannerReceived;

		void Connect();

		Task ConnectAsync(CancellationToken cancellationToken);

		IChannelSession CreateChannelSession();

		IChannelDirectTcpip CreateChannelDirectTcpip();

		IChannelForwardedTcpip CreateChannelForwardedTcpip(uint remoteChannelNumber, uint remoteWindowSize, uint remoteChannelDataPacketSize);

		void Disconnect();

		void OnDisconnecting();

		void RegisterMessage(string messageName);

		void SendMessage(Message message);

		bool TrySendMessage(Message message);

		void UnRegisterMessage(string messageName);

		void WaitOnHandle(WaitHandle waitHandle);

		void WaitOnHandle(WaitHandle waitHandle, TimeSpan timeout);

		WaitResult TryWait(WaitHandle waitHandle, TimeSpan timeout, out Exception exception);

		WaitResult TryWait(WaitHandle waitHandle, TimeSpan timeout);
	}
	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);

		Task ChangeDirectoryAsync(string path, CancellationToken cancellationToken = default(CancellationToken));

		void ChangePermissions(string path, short mode);

		SftpFileStream Create(string path);

		SftpFileStream Create(string path, int bufferSize);

		void CreateDirectory(string path);

		Task CreateDirectoryAsync(string path, CancellationToken cancellationToken = default(CancellationToken));

		StreamWriter CreateText(string path);

		StreamWriter CreateText(string path, Encoding encoding);

		void Delete(string path);

		Task DeleteAsync(string path, CancellationToken cancellationToken = default(CancellationToken));

		void DeleteDirectory(string path);

		Task DeleteDirectoryAsync(string path, CancellationToken cancellationToken = default(CancellationToken));

		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 SetLastAccessTime(string path, DateTime lastAccessTime);

		void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc);

		void SetLastWriteTime(string path, DateTime lastWriteTime);

		void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc);

		void SetAttributes(string path, SftpFileAttributes fileAttributes);

		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 interface ISshClient : IBaseClient, IDisposable
	{
		IEnumerable<ForwardedPort> ForwardedPorts { get; }

		void AddForwardedPort(ForwardedPort port);

		void RemoveForwardedPort(ForwardedPort port);

		SshCommand CreateCommand(string commandText);

		SshCommand CreateCommand(string commandText, Encoding encoding);

		SshCommand RunCommand(string commandText);

		Shell CreateShell(Stream input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint>? terminalModes, int bufferSize);

		Shell CreateShell(Stream input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes);

		Shell CreateShell(Stream input, Stream output, Stream extendedOutput);

		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);

		Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes);

		Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput);

		Shell CreateShellNoTerminal(Stream input, Stream output, Stream extendedOutput, int bufferSize = -1);

		ShellStream CreateShellStream(string terminalName, uint columns, uint rows, uint width, uint height, int bufferSize);

		ShellStream CreateShellStream(string terminalName, uint columns, uint rows, uint width, uint height, int bufferSize, IDictionary<TerminalModes, uint>? terminalModeValues);

		ShellStream CreateShellStreamNoTerminal(int bufferSize = -1);
	}
	internal interface ISubsystemSession : IDisposable
	{
		int OperationTimeout { get; set; }

		bool IsOpen { get; }

		void Connect();

		void Disconnect();

		void WaitOnHandle(WaitHandle waitHandle, int millisecondsTimeout);

		bool WaitOne(WaitHandle waitHandle, int millisecondsTimeout);

		int WaitAny(WaitHandle waitHandleA, WaitHandle waitHandleB, int millisecondsTimeout);

		int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout);

		WaitHandle[] CreateWaitHandleArray(params WaitHandle[] waitHandles);

		WaitHandle[] CreateWaitHandleArray(WaitHandle waitHandle1, WaitHandle waitHandle2);
	}
	public class KeyboardInteractiveAuthenticationMethod : AuthenticationMethod, IDisposable
	{
		private readonly RequestMessageKeyboardInteractive _requestMessage;

		private AuthenticationResult _authenticationResult = AuthenticationResult.Failure;

		private Session _session;

		private EventWaitHandle _authenticationCompleted = new AutoResetEvent(initialState: false);

		private Exception _exception;

		private bool _isDisposed;

		public override string Name => _requestMessage.MethodName;

		public event EventHandler<AuthenticationPromptEventArgs> AuthenticationPrompt;

		public KeyboardInteractiveAuthenticationMethod(string username)
			: base(username)
		{
			_requestMessage = new RequestMessageKeyboardInteractive(ServiceName.Connection, username);
		}

		public override AuthenticationResult Authenticate(Session session)
		{
			_session = session;
			session.UserAuthenticationSuccessReceived += Session_UserAuthenticationSuccessReceived;
			session.UserAuthenticationFailureReceived += Session_UserAuthenticationFailureReceived;
			session.UserAuthenticationInformationRequestReceived += Session_UserAuthenticationInformationRequestReceived;
			session.RegisterMessage("SSH_MSG_USERAUTH_INFO_REQUEST");
			try
			{
				session.SendMessage(_requestMessage);
				session.WaitOnHandle(_authenticationCompleted);
			}
			finally
			{
				session.UnRegisterMessage("SSH_MSG_USERAUTH_INFO_REQUEST");
				session.UserAuthenticationSuccessReceived -= Session_UserAuthenticationSuccessReceived;
				session.UserAuthenticationFailureReceived -= Session_UserAuthenticationFailureReceived;
				session.UserAuthenticationInformationRequestReceived -= Session_UserAuthenticationInformationRequestReceived;
			}
			if (_exception != null)
			{
				ExceptionDispatchInfo.Capture(_exception).Throw();
			}
			return _authenticationResult;
		}

		private void Session_UserAuthenticationSuccessReceived(object sender, MessageEventArgs<SuccessMessage> e)
		{
			_authenticationResult = AuthenticationResult.Success;
			_authenticationCompleted.Set();
		}

		private void Session_UserAuthenticationFailureReceived(object sender, MessageEventArgs<FailureMessage> e)
		{
			if (e.Message.PartialSuccess)
			{
				_authenticationResult = AuthenticationResult.PartialSuccess;
			}
			else
			{
				_authenticationResult = AuthenticationResult.Failure;
			}
			base.AllowedAuthentications = e.Message.AllowedAuthentications;
			_authenticationCompleted.Set();
		}

		private void Session_UserAuthenticationInformationRequestReceived(object sender, MessageEventArgs<InformationRequestMessage> e)
		{
			InformationRequestMessage message = e.Message;
			AuthenticationPromptEventArgs eventArgs = new AuthenticationPromptEventArgs(base.Username, message.Instruction, message.Language, message.Prompts);
			ThreadAbstraction.ExecuteThread(delegate
			{
				try
				{
					this.AuthenticationPrompt?.Invoke(this, eventArgs);
					InformationResponseMessage informationResponseMessage = new InformationResponseMessage();
					foreach (AuthenticationPrompt item in eventArgs.Prompts.OrderBy((AuthenticationPrompt r) => r.Id))
					{
						if (item.Response == null)
						{
							throw new SshAuthenticationException("AuthenticationPrompt.Response is null for prompt \"" + item.Request + "\". You can set this by subscribing to KeyboardInteractiveAuthenticationMethod.AuthenticationPrompt and inspecting the Prompts property of the event args.");
						}
						informationResponseMessage.Responses.Add(item.Response);
					}
					_session.SendMessage(informationResponseMessage);
				}
				catch (Exception exception)
				{
					_exception = exception;
					_authenticationCompleted.Set();
				}
			});
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_isDisposed && disposing)
			{
				EventWaitHandle authenticationCompleted = _authenticationCompleted;
				if (authenticationCompleted != null)
				{
					_authenticationCompleted = null;
					authenticationCompleted.Dispose();
				}
				_isDisposed = true;
			}
		}
	}
	public class KeyboardInteractiveConnectionInfo : ConnectionInfo, IDisposable
	{
		private bool _isDisposed;

		public event EventHandler<AuthenticationPromptEventArgs> AuthenticationPrompt;

		public KeyboardInteractiveConnectionInfo(string host, string username)
			: this(host, 22, username, ProxyTypes.None, string.Empty, 0, string.Empty, string.Empty)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, int port, string username)
			: this(host, port, username, ProxyTypes.None, string.Empty, 0, string.Empty, string.Empty)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort)
			: this(host, port, username, proxyType, proxyHost, proxyPort, string.Empty, string.Empty)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
			: this(host, port, username, proxyType, proxyHost, proxyPort, proxyUsername, string.Empty)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort)
			: this(host, 22, username, proxyType, proxyHost, proxyPort, string.Empty, string.Empty)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername)
			: this(host, 22, username, proxyType, proxyHost, proxyPort, proxyUsername, string.Empty)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
			: this(host, 22, username, proxyType, proxyHost, proxyPort, proxyUsername, proxyPassword)
		{
		}

		public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword)
			: base(host, port, username, proxyType, proxyHost, proxyPort, proxyUsername, proxyPassword, new KeyboardInteractiveAuthenticationMethod(username))
		{
			foreach (AuthenticationMethod authenticationMethod in base.AuthenticationMethods)
			{
				if (authenticationMethod is KeyboardInteractiveAuthenticationMethod keyboardInteractiveAuthenticationMethod)
				{
					keyboardInteractiveAuthenticationMethod.AuthenticationPrompt += AuthenticationMethod_AuthenticationPrompt;
				}
			}
		}

		private void AuthenticationMethod_AuthenticationPrompt(object sender, AuthenticationPromptEventArgs e)
		{
			this.AuthenticationPrompt?.Invoke(sender, e);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (_isDisposed || !disposing)
			{
				return;
			}
			if (base.AuthenticationMethods != null)
			{
				foreach (AuthenticationMethod authenticationMethod in base.AuthenticationMethods)
				{
					if (authenticationMethod is IDisposable disposable)
					{
						disposable.Dispose();
					}
				}
			}
			_isDisposed = true;
		}
	}
	public class MessageEventArgs<T> : EventArgs
	{
		public T Message { get; private set; }

		public MessageEventArgs(T message)
		{
			ThrowHelper.ThrowIfNull(message, "message");
			Message = message;
		}
	}
	public class NetConfClient : BaseClient
	{
		private int _operationTimeout;

		private INetConfSession? _netConfSession;

		public TimeSpan OperationTimeout
		{
			get
			{
				return TimeSpan.FromMilliseconds(_operationTimeout);
			}
			set
			{
				_operationTimeout = value.AsTimeout("OperationTimeout");
			}
		}

		internal INetConfSession? NetConfSession => _netConfSession;

		public XmlDocument ServerCapabilities
		{
			get
			{
				if (_netConfSession == null)
				{
					throw new SshConnectionException("Client not connected.");
				}
				return _netConfSession.ServerCapabilities;
			}
		}

		public XmlDocument ClientCapabilities
		{
			get
			{
				if (_netConfSession == null)
				{
					throw new SshConnectionException("Client not connected.");
				}
				return _netConfSession.ClientCapabilities;
			}
		}

		public bool AutomaticMessageIdHandling { get; set; }

		public NetConfClient(ConnectionInfo connectionInfo)
			: this(connectionInfo, ownsConnectionInfo: false)
		{
		}

		public NetConfClient(string host, int port, string username, string password)
			: this(new PasswordConnectionInfo(host, port, username, password), ownsConnectionInfo: true)
		{
		}

		public NetConfClient(string host, string username, string password)
			: this(host, 22, username, password)
		{
		}

		public NetConfClient(string host, int port, string username, params IPrivateKeySource[] keyFiles)
			: this(new PrivateKeyConnectionInfo(host, port, username, keyFiles), ownsConnectionInfo: true)
		{
		}

		public NetConfClient(string host, string username, params IPrivateKeySource[] keyFiles)
			: this(host, 22, username, keyFiles)
		{
		}

		private NetConfClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo)
			: this(connectionInfo, ownsConnectionInfo, new ServiceFactory())
		{
		}

		internal NetConfClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo, IServiceFactory serviceFactory)
			: base(connectionInfo, ownsConnectionInfo, serviceFactory)
		{
			_operationTimeout = -1;
			AutomaticMessageIdHandling = true;
		}

		public XmlDocument SendReceiveRpc(XmlDocument rpc)
		{
			if (_netConfSession == null)
			{
				throw new SshConnectionException("Client not connected.");
			}
			return _netConfSession.SendReceiveRpc(rpc, AutomaticMessageIdHandling);
		}

		public XmlDocument SendReceiveRpc(string xml)
		{
			XmlDocument xmlDocument = new XmlDocument();
			xmlDocument.LoadXml(xml);
			return SendReceiveRpc(xmlDocument);
		}

		public XmlDocument SendCloseRpc()
		{
			if (_netConfSession == null)
			{
				throw new SshConnectionException("Client not connected.");
			}
			XmlDocument xmlDocument = new XmlDocument();
			xmlDocument.LoadXml("<?xml version=\"1.0\" encoding=\"UTF-8\"?><rpc message-id=\"6666\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\"><close-session/></rpc>");
			return _netConfSession.SendReceiveRpc(xmlDocument, AutomaticMessageIdHandling);
		}

		protected override void OnConnected()
		{
			base.OnConnected();
			_netConfSession = CreateAndConnectNetConfSession();
		}

		protected override void OnDisconnecting()
		{
			base.OnDisconnecting();
			_netConfSession?.Disconnect();
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			if (disposing && _netConfSession != null)
			{
				_netConfSession.Dispose();
				_netConfSession = null;
			}
		}

		private INetConfSession CreateAndConnectNetConfSession()
		{
			INetConfSession netConfSession = base.ServiceFactory.CreateNetConfSession(base.Session, _operationTimeout);
			try
			{
				netConfSession.Connect();
				return netConfSession;
			}
			catch
			{
				netConfSession.Dispose();
				throw;
			}
		}
	}
	public class NoneAuthenticationMethod : AuthenticationMethod, IDisposable
	{
		private AuthenticationResult _authenticationResult = AuthenticationResult.Failure;

		private EventWaitHandle _authenticationCompleted = new AutoResetEvent(initialState: false);

		private bool _isDisposed;

		public override string Name => "none";

		public NoneAuthenticationMethod(string username)
			: base(username)
		{
		}

		public override AuthenticationResult Authenticate(Session session)
		{
			ThrowHelper.ThrowIfNull(session, "session");
			session.UserAuthenticationSuccessReceived += Session_UserAuthenticationSuccessReceived;
			session.UserAuthenticationFailureReceived += Session_UserAuthenticationFailureReceived;
			try
			{
				session.SendMessage(new RequestMessageNone(ServiceName.Connection, base.Username));
				session.WaitOnHandle(_authenticationCompleted);
			}
			finally
			{
				session.UserAuthenticationSuccessReceived -= Session_UserAuthenticationSuccessReceived;
				session.UserAuthenticationFailureReceived -= Session_UserAuthenticationFailureReceived;
			}
			return _authenticationResult;
		}

		private void Session_UserAuthenticationSuccessReceived(object sender, MessageEventArgs<SuccessMessage> e)
		{
			_authenticationResult = AuthenticationResult.Success;
			_authenticationCompleted.Set();
		}

		private void Session_UserAuthenticationFailureReceived(object sender, MessageEventArgs<FailureMessage> e)
		{
			if (e.Message.PartialSuccess)
			{
				_authenticationResult = AuthenticationResult.PartialSuccess;
			}
			else
			{
				_authenticationResult = AuthenticationResult.Failure;
			}
			base.AllowedAuthentications = e.Message.AllowedAuthentications;
			_authenticationCompleted.Set();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_isDisposed && disposing)
			{
				EventWaitHandle authenticationCompleted = _authenticationCompleted;
				if (authenticationCompleted != null)
				{
					authenticationCompleted.Dispose();
					_authenticationCompleted = null;
				}
				_isDisposed = true;
			}
		}
	}
	public class PasswordAuthenticationMethod : AuthenticationMethod, IDisposable
	{
		private readonly RequestMessagePassword _requestMessage;

		private readonly byte[] _password;

		private AuthenticationResult _authenticationResult = AuthenticationResult.Failure;

		private Session _session;

		private EventWaitHandle _authenticationCompleted = new AutoResetEvent(initialState: false);

		private Exception _exception;

		private bool _isDisposed;

		public override string Name => _requestMessage.MethodName;

		internal byte[] Password => _password;

		public event EventHandler<AuthenticationPasswordChangeEventArgs> PasswordExpired;

		public PasswordAuthenticationMethod(string username, string password)
			: this(username, Encoding.UTF8.GetBytes(password))
		{
		}

		public PasswordAuthenticationMethod(string username, byte[] password)
			: base(username)
		{
			ThrowHelper.ThrowIfNull(password, "password");
			_password = password;
			_requestMessage = new RequestMessagePassword(ServiceName.Connection, base.Username, _password);
		}

		public override AuthenticationResult Authenticate(Session session)
		{
			ThrowHelper.ThrowIfNull(session, "session");
			_session = session;
			session.UserAuthenticationSuccessReceived += Session_UserAuthenticationSuccessReceived;
			session.UserAuthenticationFailureReceived += Session_UserAuthenticationFailureReceived;
			session.UserAuthenticationPasswordChangeRequiredReceived += Session_UserAuthenticationPasswordChangeRequiredReceived;
			try
			{
				session.RegisterMessage("SSH_MSG_USERAUTH_PASSWD_CHANGEREQ");
				session.SendMessage(_requestMessage);
				session.WaitOnHandle(_authenticationCompleted);
			}
			finally
			{
				session.UnRegisterMessage("SSH_MSG_USERAUTH_PASSWD_CHANGEREQ");
				session.UserAuthenticationSuccessReceived -= Session_UserAuthenticationSuccessReceived;
				session.UserAuthenticationFailur

using System; using System.Diagnostics; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Text.RegularExpressions; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using HarmonyLib; using Microsoft.CodeAnalysis; using Renci.SshNet; using UnityEngine; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("baer1.LethalSSH")] [assembly: AssemblyConfiguration("Debug")] [assembly: AssemblyFileVersion("0.1.1.0")] [assembly: AssemblyInformationalVersion("0.1.1+27f95d17cffb6ce84f8b76af23974495ea207269")] [assembly: AssemblyProduct("LethalSsh")] [assembly: AssemblyTitle("baer1.LethalSSH")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("0.1.1.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] internal sealed class NullableAttribute : Attribute { public readonly byte[] NullableFlags; public NullableAttribute(byte P_0) { NullableFlags = new byte[1] { P_0 }; } public NullableAttribute(byte[] P_0) { NullableFlags = P_0; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] internal sealed class NullableContextAttribute : Attribute { public readonly byte Flag; public NullableContextAttribute(byte P_0) { Flag = P_0; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } namespace LethalSsh { [BepInPlugin("baer1.LethalSSH", "LethalSsh", "0.1.1")] public class LethalSsh : BaseUnityPlugin { [HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")] public class ParsePlayerSentencePatch { private static bool Prefix(ref Terminal __instance, ref TerminalNode __result) { //IL_01d1: Unknown result type (might be due to invalid IL or missing references) //IL_01db: Expected O, but got Unknown //IL_0136: Unknown result type (might be due to invalid IL or missing references) //IL_0140: Expected O, but got Unknown string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded); Logger.LogDebug((object)(">> ParsePlayerSentence " + text)); string[] array = text.Split(" "); if (Instance.Active && Instance.sshShell != null && ((Stream)(object)Instance.sshShell).CanWrite) { Instance.sshShell.Write(text + "\n"); return false; } if (array[0] == "ssh") { __result = ScriptableObject.CreateInstance<TerminalNode>(); __result.clearPreviousText = true; switch (array.Length) { case 4: { string[] array2 = array[1].Split("@"); if (array2.Length != 2) { __result.displayText = "Invalid arguments"; break; } int result = 22; int.TryParse(array[2], out result); Instance.sshClient = new SshClient(array2[1], result, array2[0], array[3]); ((BaseClient)Instance.sshClient).Connect(); Instance.sshShell = Instance.sshClient.CreateShellStream("linux", 20u, 20u, 800u, 600u, 1024); __result.displayText = ""; break; } case 3: { string[] array2 = array[1].Split("@"); if (array2.Length != 2) { __result.displayText = "Invalid arguments"; break; } Instance.sshClient = new SshClient(array2[1], array2[0], array[2]); ((BaseClient)Instance.sshClient).Connect(); Instance.sshShell = Instance.sshClient.CreateShellStream("linux", 50u, 50u, 800u, 600u, 1024); __result.displayText = ""; break; } default: __result.displayText = "Invalid arguments\n"; break; } Instance._sgrCloseTags.Clear(); Instance._sgrDim = false; return false; } return true; } } [HarmonyPatch(typeof(Terminal), "TextChanged")] public class TextChangedPatch { private static bool Prefix(ref Terminal __instance, string newText) { Logger.LogDebug((object)(">> TextChanged " + newText.Split("\n").Last())); if (!Instance.Active) { return true; } if (__instance.modifyingText) { __instance.modifyingText = false; return false; } Terminal obj = __instance; obj.textAdded += newText.Length - __instance.currentText.Length; if (__instance.textAdded < 0) { __instance.screenText.text = __instance.currentText; __instance.textAdded = 0; } else { __instance.currentText = newText; } __instance.forceScrollbarCoroutine = ((MonoBehaviour)__instance).StartCoroutine(__instance.forceScrollbarDown()); return false; } } [HarmonyPatch(typeof(Terminal), "QuitTerminal")] public class QuitTerminalPatch { private static void Prefix() { Logger.LogDebug((object)">> QuitTerminal"); Instance.ResetSSH(); } } [HarmonyPatch(typeof(GameNetworkManager), "StartDisconnect")] public class StartDisconnectPatch { private static void Prefix() { Logger.LogDebug((object)">> StartDisconnect"); Instance.ResetSSH(); } } [HarmonyPatch(typeof(Terminal), "Update")] public class TerminalUpdatePatch { private static void Prefix(ref Terminal __instance) { if (!Instance.Active || Instance.sshShell == null || !((Stream)(object)Instance.sshShell).CanRead) { return; } string text = Instance.sshShell.Read(); if (text.Length == 0) { return; } string text2 = Regex.Split(GeneralExtensions.Join<string>((__instance.currentText + text).Split("\n").TakeLast(50), (Func<string, string>)null, "\n"), "\\x1B\\[[0-3]?[jJ]").Last(); __instance.currentText = Regex.Replace(enableANSI.Value ? Regex.Replace(text2, "\\x1B\\[([0-9;]*)[mM]", delegate(Match m) { StringBuilder sb = new StringBuilder(); string[] array = m.Groups[1].Value.Split(";"); Func<string, string, bool> next = null; string text3 = null; string[] array2 = array; foreach (string text4 in array2) { Logger.LogDebug((object)(">> Parsing ANSI code " + text4)); if (next != null) { Logger.LogDebug((object)("Found next function, previous: " + text3)); if (!next(text3, text4)) { text3 = text4; Logger.LogDebug((object)("previous overwritten " + text3)); } else { Logger.LogDebug((object)("previous not overwritten: " + text3)); } } else { switch (text4) { case "1": Instance._sgrCloseTags.Insert(0, ""); sb.Append(""); break; case "2": Instance._sgrCloseTags.Insert(0, "<alpha=#FF>"); Instance._sgrDim = true; sb.Append("<alpha=#33>"); break; case "3": Instance._sgrCloseTags.Insert(0, ""); sb.Append(""); break; case "4": Instance._sgrCloseTags.Insert(0, ""); sb.Append(""); break; case "9": Instance._sgrCloseTags.Insert(0, "</s>"); sb.Append("<s>"); break; case "30": case "31": case "32": case "33": case "34": case "35": case "36": case "37": case "90": case "91": case "92": case "93": case "94": case "95": case "96": case "97": Instance._sgrCloseTags.Insert(0, "</color>"); sb.Append("<color=#" + GetColorByCode(text4) + (Instance._sgrDim ? "33" : "") + ">"); break; case "40": case "41": case "42": case "43": case "44": case "45": case "46": case "47": case "100": case "101": case "102": case "103": case "104": case "105": case "106": case "107": Instance._sgrCloseTags.Insert(0, ""); sb.Append("<mark=#" + GetColorByCode(text4) + "55>"); break; case "38": case "48": next = delegate(string _, string mode) { if (!(mode == "2")) { if (mode == "5") { next = delegate(string previous, string color) { if (previous == "38") { Instance._sgrCloseTags.Insert(0, "</color>"); sb.Append("<color=#" + Get256ColorByCode(color) + (Instance._sgrDim ? "33" : "") + ">"); } else { Instance._sgrCloseTags.Insert(0, ""); sb.Append("<mark=#" + Get256ColorByCode(color) + "55>"); } next = null; return false; }; } } else { StringBuilder rgb = new StringBuilder(); next = delegate(string _, string r) { rgb.Append(((byte)int.Parse(r)).ToString("X2")); next = delegate(string _, string g) { rgb.Append(((byte)int.Parse(g)).ToString("X2")); next = delegate(string previous, string b) { rgb.Append(((byte)int.Parse(b)).ToString("X2")); if (previous == "38") { Instance._sgrCloseTags.Insert(0, "</color>"); sb.Append("<color=#" + rgb.ToString() + (Instance._sgrDim ? "33" : "") + ">"); } else { Instance._sgrCloseTags.Insert(0, ""); sb.Append("<mark=#" + rgb.ToString() + "55>"); } next = null; return false; }; return true; }; return true; }; } return true; }; break; default: { string result = Instance._sgrCloseTags.ToString(); Instance._sgrCloseTags.Clear(); Instance._sgrDim = false; return result; } } text3 = text4; } } Logger.LogDebug((object)("<< Parsed \u001b[" + m.Groups[1].Value + "m: " + sb.ToString())); return sb.ToString(); }) : text2, "\\x1B\\[[?;=0-9]*[a-zA-Z~]", ""); if (!__instance.currentText.StartsWith("\n\n\n")) { __instance.currentText = "\n\n\n" + __instance.currentText.TrimStart('\n'); } __instance.screenText.text = __instance.currentText; __instance.forceScrollbarCoroutine = ((MonoBehaviour)__instance).StartCoroutine(__instance.forceScrollbarDown()); } } internal SshClient? sshClient; internal ShellStream? sshShell; internal StringBuilder _sgrCloseTags = new StringBuilder(); internal bool _sgrDim = false; public static LethalSsh Instance { get; private set; } internal static ManualLogSource Logger { get; private set; } internal static Harmony? Harmony { get; set; } public bool Active { get { SshClient val = sshClient; return val != null && ((BaseClient)val).IsConnected; } } internal static ConfigEntry<bool> enableANSI { get; private set; } private void Awake() { Logger = ((BaseUnityPlugin)this).Logger; Instance = this; enableANSI = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "enableFormatting", true, "Enable or disable text colorization and formatting."); Patch(); Logger.LogInfo((object)"baer1.LethalSSH v0.1.1 has loaded!"); } public static string GetColorByCode(string code) { if (code.StartsWith("4")) { code = $"3{code.Last()}"; } else if (code.StartsWith("10")) { code = $"9{code.Last()}"; } if (1 == 0) { } string result = code switch { "30" => "000000", "31" => "AA0000", "32" => "00AA00", "33" => "AA5500", "34" => "0000AA", "35" => "AA00AA", "36" => "00AAAA", "37" => "AAAAAA", "90" => "555555", "91" => "FF5555", "92" => "55FF55", "93" => "FFFF55", "94" => "5555FF", "95" => "FF55FF", "96" => "55FFFF", _ => "FFFFFF", }; if (1 == 0) { } return result; } public static string Get256ColorByCode(string code) { byte b; try { b = (byte)int.Parse(code); } catch { return "FFFFFF"; } if (b <= 7) { return GetColorByCode($"3{b}"); } if (b <= 15) { return GetColorByCode($"9{b - 8}"); } if (b >= 232) { return string.Concat(Enumerable.Repeat((Enumerable.Range(0, 24).ToArray()[b - 232] * 10 + 8).ToString("X2"), 3)); } byte[] array = new byte[3] { (byte)Math.Floor(((float)(int)b - 16f) / 36f), (byte)Math.Floor(((float)(int)b - 16f) % 36f / 6f), (byte)Math.Floor(((float)(int)b - 16f) % 6f) }; StringBuilder stringBuilder = new StringBuilder(); byte[] array2 = array; foreach (byte b2 in array2) { stringBuilder.Append((b2 == 0) ? "00" : (b2 * 40 + 55).ToString("X2")); } return stringBuilder.ToString(); } internal static void Patch() { //IL_000d: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Unknown result type (might be due to invalid IL or missing references) //IL_0018: Expected O, but got Unknown if (Harmony == null) { Harmony = new Harmony("baer1.LethalSSH"); } Logger.LogDebug((object)"Patching..."); Harmony.PatchAll(); Logger.LogDebug((object)"Finished patching!"); } internal static void Unpatch() { Logger.LogDebug((object)"Unpatching..."); Harmony? harmony = Harmony; if (harmony != null) { harmony.UnpatchSelf(); } Logger.LogDebug((object)"Finished unpatching!"); } internal void ResetSSH() { if (Instance.Active) { ((Stream)(object)Instance.sshShell).Close(); ((BaseClient)Instance.sshClient).Disconnect(); Instance.sshClient = null; Instance._sgrCloseTags.Clear(); Instance._sgrDim = false; } } } public static class MyPluginInfo { public const string PLUGIN_GUID = "baer1.LethalSSH"; public const string PLUGIN_NAME = "LethalSsh"; public const string PLUGIN_VERSION = "0.1.1"; } }

#define TRACE using System; using System.Buffers.Binary; using System.CodeDom.Compiler; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Formats.Asn1; using System.Globalization; using System.IO; using System.Linq; using System.Net; using System.Net.Sockets; using System.Numerics; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security.Cryptography; using System.Text; using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; using System.Xml; using Microsoft.CodeAnalysis; using Org.BouncyCastle.Asn1; using Org.BouncyCastle.Asn1.EdEC; using Org.BouncyCastle.Asn1.Pkcs; using Org.BouncyCastle.Asn1.Sec; using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Crypto.Agreement; using Org.BouncyCastle.Crypto.Digests; using Org.BouncyCastle.Crypto.Engines; using Org.BouncyCastle.Crypto.Generators; using Org.BouncyCastle.Crypto.Macs; using Org.BouncyCastle.Crypto.Modes; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Crypto.Prng; using Org.BouncyCastle.Crypto.Signers; using Org.BouncyCastle.Math; using Org.BouncyCastle.Math.EC; using Org.BouncyCastle.Math.EC.Rfc8032; using Org.BouncyCastle.Pkcs; using Org.BouncyCastle.Security; using Org.BouncyCastle.Utilities; using Org.BouncyCastle.Utilities.Zlib; using Renci.SshNet.Abstractions; using Renci.SshNet.Channels; using Renci.SshNet.Common; using Renci.SshNet.Compression; using Renci.SshNet.Connection; using Renci.SshNet.Messages; using Renci.SshNet.Messages.Authentication; using Renci.SshNet.Messages.Connection; using Renci.SshNet.Messages.Transport; using Renci.SshNet.NetConf; using Renci.SshNet.Security; using Renci.SshNet.Security.Cryptography; using Renci.SshNet.Security.Cryptography.Ciphers; using Renci.SshNet.Security.Cryptography.Ciphers.Modes; using Renci.SshNet.Security.Cryptography.Ciphers.Paddings; using Renci.SshNet.Sftp; using Renci.SshNet.Sftp.Requests; using Renci.SshNet.Sftp.Responses; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AssemblyFileVersion("2024.2.0.1")] [assembly: AssemblyInformationalVersion("2024.2.0.1+74d4364c32")] [assembly: CLSCompliant(false)] [assembly: Guid("ad816c5e-6f13-4589-9f3e-59523f8b77a4")] [assembly: InternalsVisibleTo("Renci.SshNet.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2")] [assembly: InternalsVisibleTo("Renci.SshNet.IntegrationTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2")] [assembly: InternalsVisibleTo("Renci.SshNet.Benchmarks, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2")] [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("Renci")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyCopyright("Copyright © Renci 2010-2024")] [assembly: AssemblyDescription("SSH.NET is a Secure Shell (SSH) library for .NET, optimized for parallelism.")] [assembly: AssemblyProduct("SSH.NET")] [assembly: AssemblyTitle("SSH.NET")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/sshnet/SSH.NET.git")] [assembly: AssemblyVersion("2024.2.0.1")] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] internal sealed class NullableAttribute : Attribute { public readonly byte[] NullableFlags; public NullableAttribute(byte P_0) { NullableFlags = new byte[1] { P_0 }; } public NullableAttribute(byte[] P_0) { NullableFlags = P_0; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] internal sealed class NullableContextAttribute : Attribute { public readonly byte Flag; public NullableContextAttribute(byte P_0) { Flag = P_0; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } [GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.7.77.5761")] [ExcludeFromCodeCoverage] internal static class ThisAssembly { internal const string AssemblyConfiguration = "Release"; internal const string AssemblyFileVersion = "2024.2.0.1"; internal const string AssemblyInformationalVersion = "2024.2.0.1+74d4364c32"; internal const string AssemblyName = "Renci.SshNet"; internal const string AssemblyTitle = "SSH.NET"; internal const string AssemblyVersion = "2024.2.0.1"; internal static readonly DateTime GitCommitDate = new DateTime(638667472230000000L, DateTimeKind.Utc); internal const string GitCommitId = "74d4364c32c523f2a7d9a3ddbfc3a304ee9fb023"; internal const bool IsPrerelease = false; internal const bool IsPublicRelease = true; internal const string NuGetPackageVersion = "2024.2.0"; internal const string PublicKey = "0024000004800000940000000602000000240000525341310004000001000100f9194e1eb66b7e2575aaee115ee1d27bc100920e7150e43992d6f668f9737de8b9c7ae892b62b8a36dd1d57929ff1541665d101dc476d6e02390846efae7e5186eec409710fdb596e3f83740afef0d4443055937649bc5a773175b61c57615dac0f0fd10f52b52fedf76c17474cc567b3f7a79de95dde842509fb39aaf69c6c2"; internal const string PublicKeyToken = "1cee9f8bde3db106"; internal const string RootNamespace = "Renci.SshNet"; } namespace System.Runtime.Versioning { [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class RequiresPreviewFeaturesAttribute : Attribute { public string? Message { get; } public string? Url { get; set; } public RequiresPreviewFeaturesAttribute() { } public RequiresPreviewFeaturesAttribute(string? message) { Message = message; } } } namespace System.Runtime.CompilerServices { [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class CallerArgumentExpressionAttribute : Attribute { public string ParameterName { get; } public CallerArgumentExpressionAttribute(string parameterName) { ParameterName = parameterName; } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class CollectionBuilderAttribute : Attribute { public Type BuilderType { get; } public string MethodName { get; } public CollectionBuilderAttribute(Type builderType, string methodName) { BuilderType = builderType; MethodName = methodName; } } [AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class CompilerFeatureRequiredAttribute : Attribute { public const string RefStructs = "RefStructs"; public const string RequiredMembers = "RequiredMembers"; public string FeatureName { get; } public bool IsOptional { get; set; } public CompilerFeatureRequiredAttribute(string featureName) { FeatureName = featureName; } } [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute { public string[] Arguments { get; } public InterpolatedStringHandlerArgumentAttribute(string argument) { Arguments = new string[1] { argument }; } public InterpolatedStringHandlerArgumentAttribute(params string[] arguments) { Arguments = arguments; } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class InterpolatedStringHandlerAttribute : Attribute { } [EditorBrowsable(EditorBrowsableState.Never)] [ExcludeFromCodeCoverage] internal static class IsExternalInit { } [AttributeUsage(AttributeTargets.Method, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class ModuleInitializerAttribute : Attribute { } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class RequiredMemberAttribute : Attribute { } [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] [EditorBrowsable(EditorBrowsableState.Never)] [ExcludeFromCodeCoverage] internal sealed class RequiresLocationAttribute : Attribute { } [AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class SkipLocalsInitAttribute : Attribute { } } namespace System.Diagnostics.CodeAnalysis { [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class ExperimentalAttribute : Attribute { public string DiagnosticId { get; } public string? UrlFormat { get; set; } public ExperimentalAttribute(string diagnosticId) { DiagnosticId = diagnosticId; } } [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)] [ExcludeFromCodeCoverage] internal sealed class MemberNotNullAttribute : Attribute { public string[] Members { get; } public MemberNotNullAttribute(string member) { Members = new string[1] { member }; } public MemberNotNullAttribute(params string[] members) { Members = members; } } [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)] [ExcludeFromCodeCoverage] internal sealed class MemberNotNullWhenAttribute : Attribute { public bool ReturnValue { get; } public string[] Members { get; } public MemberNotNullWhenAttribute(bool returnValue, string member) { ReturnValue = returnValue; Members = new string[1] { member }; } public MemberNotNullWhenAttribute(bool returnValue, params string[] members) { ReturnValue = returnValue; Members = members; } } [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class SetsRequiredMembersAttribute : Attribute { } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class StringSyntaxAttribute : Attribute { public const string CompositeFormat = "CompositeFormat"; public const string DateOnlyFormat = "DateOnlyFormat"; public const string DateTimeFormat = "DateTimeFormat"; public const string EnumFormat = "EnumFormat"; public const string GuidFormat = "GuidFormat"; public const string Json = "Json"; public const string NumericFormat = "NumericFormat"; public const string Regex = "Regex"; public const string TimeOnlyFormat = "TimeOnlyFormat"; public const string TimeSpanFormat = "TimeSpanFormat"; public const string Uri = "Uri"; public const string Xml = "Xml"; public string Syntax { get; } public object?[] Arguments { get; } public StringSyntaxAttribute(string syntax) { Syntax = syntax; Arguments = new object[0]; } public StringSyntaxAttribute(string syntax, params object?[] arguments) { Syntax = syntax; Arguments = arguments; } } [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] [ExcludeFromCodeCoverage] internal sealed class UnscopedRefAttribute : Attribute { } } namespace System.Threading.Tasks { internal static class TaskToAsyncResult { private sealed class TaskAsyncResult : IAsyncResult { internal readonly Task _task; private readonly AsyncCallback? _callback; public object? AsyncState { get; } public bool CompletedSynchronously { get; } public bool IsCompleted => _task.IsCompleted; public WaitHandle AsyncWaitHandle => ((IAsyncResult)_task).AsyncWaitHandle; internal TaskAsyncResult(Task task, object? state, AsyncCallback? callback) { _task = task; AsyncState = state; if (task.IsCompleted) { CompletedSynchronously = true; callback?.Invoke(this); } else if (callback != null) { _callback = callback; _task.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter().OnCompleted(delegate { _callback(this); }); } } } public static IAsyncResult Begin(Task task, AsyncCallback? callback, object? state) { if (task == null) { throw new ArgumentNullException("task"); } return new TaskAsyncResult(task, state, callback); } public static void End(IAsyncResult asyncResult) { Unwrap(asyncResult).GetAwaiter().GetResult(); } public static TResult End<TResult>(IAsyncResult asyncResult) { return Unwrap<TResult>(asyncResult).GetAwaiter().GetResult(); } public static Task Unwrap(IAsyncResult asyncResult) { if (asyncResult == null) { throw new ArgumentNullException("asyncResult"); } return (asyncResult as TaskAsyncResult)?._task ?? throw new ArgumentException(null, "asyncResult"); } public static Task<TResult> Unwrap<TResult>(IAsyncResult asyncResult) { if (asyncResult == null) { throw new ArgumentNullException("asyncResult"); } return ((asyncResult as TaskAsyncResult)?._task as Task<TResult>) ?? throw new ArgumentException(null, "asyncResult"); } } } namespace Renci.SshNet { public abstract class AuthenticationMethod : IAuthenticationMethod { public abstract string Name { get; } public string Username { get; private set; } public string[] AllowedAuthentications { get; protected set; } protected AuthenticationMethod(string username) { ThrowHelper.ThrowIfNullOrWhiteSpace(username, "username"); Username = username; } public abstract AuthenticationResult Authenticate(Session session); AuthenticationResult IAuthenticationMethod.Authenticate(ISession session) { return Authenticate((Session)session); } } public enum AuthenticationResult { Success, PartialSuccess, Failure } public abstract class BaseClient : IBaseClient, IDisposable { private readonly bool _ownsConnectionInfo; private readonly IServiceFactory _serviceFactory; private readonly object _keepAliveLock = new object(); private TimeSpan _keepAliveInterval; private Timer? _keepAliveTimer; private ConnectionInfo _connectionInfo; private bool _isDisposed; internal ISession? Session { get; private set; } internal IServiceFactory ServiceFactory => _serviceFactory; public ConnectionInfo ConnectionInfo { get { CheckDisposed(); return _connectionInfo; } private set { _connectionInfo = value; } } public virtual bool IsConnected { get { CheckDisposed(); return IsSessionConnected(); } } public TimeSpan KeepAliveInterval { get { CheckDisposed(); return _keepAliveInterval; } set { CheckDisposed(); value.EnsureValidTimeout("KeepAliveInterval"); if (!(value == _keepAliveInterval)) { if (value == Timeout.InfiniteTimeSpan) { StopKeepAliveTimer(); } else if (_keepAliveTimer != null) { _keepAliveTimer.Change(value, value); } else if (IsSessionConnected()) { _keepAliveTimer = CreateKeepAliveTimer(value, value); } _keepAliveInterval = value; } } } public event EventHandler<ExceptionEventArgs>? ErrorOccurred; public event EventHandler<HostKeyEventArgs>? HostKeyReceived; public event EventHandler<SshIdentificationEventArgs>? ServerIdentificationReceived; protected BaseClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo) : this(connectionInfo, ownsConnectionInfo, new ServiceFactory()) { } private protected BaseClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo, IServiceFactory serviceFactory) { ThrowHelper.ThrowIfNull(connectionInfo, "connectionInfo"); ThrowHelper.ThrowIfNull(serviceFactory, "serviceFactory"); _connectionInfo = connectionInfo; _ownsConnectionInfo = ownsConnectionInfo; _serviceFactory = serviceFactory; _keepAliveInterval = Timeout.InfiniteTimeSpan; } public void Connect() { CheckDisposed(); if (IsConnected) { throw new InvalidOperationException("The client is already connected."); } OnConnecting(); ISession session = Session; if (session == null || !session.IsConnected) { if (session != null) { DisposeSession(session); } Session = CreateAndConnectSession(); } try { OnConnected(); } catch { DisposeSession(); throw; } StartKeepAliveTimer(); } public async Task ConnectAsync(CancellationToken cancellationToken) { CheckDisposed(); cancellationToken.ThrowIfCancellationRequested(); if (IsConnected) { throw new InvalidOperationException("The client is already connected."); } OnConnecting(); ISession session = Session; if (session == null || !session.IsConnected) { if (session != null) { DisposeSession(session); } using CancellationTokenSource timeoutCancellationTokenSource = new CancellationTokenSource(ConnectionInfo.Timeout); using CancellationTokenSource linkedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCancellationTokenSource.Token); try { Session = await CreateAndConnectSessionAsync(linkedCancellationTokenSource.Token).ConfigureAwait(continueOnCapturedContext: false); } catch (OperationCanceledException innerException) when (timeoutCancellationTokenSource.IsCancellationRequested) { throw new SshOperationTimeoutException("Connection has timed out.", innerException); } } try { OnConnected(); } catch { DisposeSession(); throw; } StartKeepAliveTimer(); } public void Disconnect() { CheckDisposed(); OnDisconnecting(); StopKeepAliveTimer(); DisposeSession(); OnDisconnected(); } [Obsolete("Use KeepAliveInterval to send a keep-alive message at regular intervals.")] public void SendKeepAlive() { CheckDisposed(); SendKeepAliveMessage(); } protected virtual void OnConnecting() { } protected virtual void OnConnected() { } protected virtual void OnDisconnecting() { Session?.OnDisconnecting(); } protected virtual void OnDisconnected() { } private void Session_ErrorOccured(object? sender, ExceptionEventArgs e) { this.ErrorOccurred?.Invoke(this, e); } private void Session_HostKeyReceived(object? sender, HostKeyEventArgs e) { this.HostKeyReceived?.Invoke(this, e); } private void Session_ServerIdentificationReceived(object? sender, SshIdentificationEventArgs e) { this.ServerIdentificationReceived?.Invoke(this, e); } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (!_isDisposed && disposing) { Disconnect(); if (_ownsConnectionInfo && _connectionInfo is IDisposable disposable) { disposable.Dispose(); } _isDisposed = true; } } protected void CheckDisposed() { ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this); } private void StopKeepAliveTimer() { if (_keepAliveTimer != null) { _keepAliveTimer.Dispose(); _keepAliveTimer = null; } } private void SendKeepAliveMessage() { ISession session = Session; if (session == null || !Monitor.TryEnter(_keepAliveLock)) { return; } try { session.TrySendMessage(new IgnoreMessage()); } finally { Monitor.Exit(_keepAliveLock); } } private void StartKeepAliveTimer() { if (!(_keepAliveInterval == Timeout.InfiniteTimeSpan) && _keepAliveTimer == null) { _keepAliveTimer = CreateKeepAliveTimer(_keepAliveInterval, _keepAliveInterval); } } private Timer CreateKeepAliveTimer(TimeSpan dueTime, TimeSpan period) { return new Timer(delegate { SendKeepAliveMessage(); }, Session, dueTime, period); } private ISession CreateAndConnectSession() { ISession session = _serviceFactory.CreateSession(ConnectionInfo, _serviceFactory.CreateSocketFactory()); session.ServerIdentificationReceived += Session_ServerIdentificationReceived; session.HostKeyReceived += Session_HostKeyReceived; session.ErrorOccured += Session_ErrorOccured; try { session.Connect(); return session; } catch { DisposeSession(session); throw; } } private async Task<ISession> CreateAndConnectSessionAsync(CancellationToken cancellationToken) { ISession session = _serviceFactory.CreateSession(ConnectionInfo, _serviceFactory.CreateSocketFactory()); session.ServerIdentificationReceived += Session_ServerIdentificationReceived; session.HostKeyReceived += Session_HostKeyReceived; session.ErrorOccured += Session_ErrorOccured; try { await session.ConnectAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); return session; } catch { DisposeSession(session); throw; } } private void DisposeSession(ISession session) { session.ErrorOccured -= Session_ErrorOccured; session.HostKeyReceived -= Session_HostKeyReceived; session.ServerIdentificationReceived -= Session_ServerIdentificationReceived; session.Dispose(); } private void DisposeSession() { ISession session = Session; if (session != null) { Session = null; DisposeSession(session); } } private bool IsSessionConnected() { return Session?.IsConnected ?? false; } } public class CipherInfo { public int KeySize { get; private set; } public bool IsAead { get; private set; } public Func<byte[], byte[], Cipher> Cipher { get; private set; } public CipherInfo(int keySize, Func<byte[], byte[], Cipher> cipher, bool isAead = false) { CipherInfo cipherInfo = this; KeySize = keySize; Cipher = (byte[] key, byte[] iv) => cipher(key.Take(cipherInfo.KeySize / 8), iv); IsAead = isAead; } } internal sealed class ClientAuthentication : IClientAuthentication { private sealed class AuthenticationState { private readonly IList<IAuthenticationMethod> _supportedAuthenticationMethods; private readonly Dictionary<IAuthenticationMethod, int> _authenticationMethodPartialSuccessRegister; private readonly List<IAuthenticationMethod> _failedAuthenticationMethods; public AuthenticationState(IList<IAuthenticationMethod> supportedAuthenticationMethods) { _supportedAuthenticationMethods = supportedAuthenticationMethods; _failedAuthenticationMethods = new List<IAuthenticationMethod>(); _authenticationMethodPartialSuccessRegister = new Dictionary<IAuthenticationMethod, int>(); } public void RecordFailure(IAuthenticationMethod authenticationMethod) { _failedAuthenticationMethods.Add(authenticationMethod); } public void RecordPartialSuccess(IAuthenticationMethod authenticationMethod) { if (_authenticationMethodPartialSuccessRegister.TryGetValue(authenticationMethod, out var value)) { _authenticationMethodPartialSuccessRegister[authenticationMethod] = value + 1; } else { _authenticationMethodPartialSuccessRegister.Add(authenticationMethod, 1); } } public int GetPartialSuccessCount(IAuthenticationMethod authenticationMethod) { if (_authenticationMethodPartialSuccessRegister.TryGetValue(authenticationMethod, out var value)) { return value; } return 0; } public List<IAuthenticationMethod> GetSupportedAuthenticationMethods(string[] allowedAuthenticationMethods) { List<IAuthenticationMethod> list = new List<IAuthenticationMethod>(); foreach (IAuthenticationMethod supportedAuthenticationMethod in _supportedAuthenticationMethods) { string name = supportedAuthenticationMethod.Name; for (int i = 0; i < allowedAuthenticationMethods.Length; i++) { if (allowedAuthenticationMethods[i] == name) { list.Add(supportedAuthenticationMethod); break; } } } return list; } public IEnumerable<IAuthenticationMethod> GetActiveAuthenticationMethods(List<IAuthenticationMethod> matchingAuthenticationMethods) { List<IAuthenticationMethod> skippedAuthenticationMethods = new List<IAuthenticationMethod>(); for (int i = 0; i < matchingAuthenticationMethods.Count; i++) { IAuthenticationMethod authenticationMethod = matchingAuthenticationMethods[i]; if (!_failedAuthenticationMethods.Contains(authenticationMethod)) { if (_authenticationMethodPartialSuccessRegister.ContainsKey(authenticationMethod)) { skippedAuthenticationMethods.Add(authenticationMethod); } else { yield return authenticationMethod; } } } foreach (IAuthenticationMethod item in skippedAuthenticationMethods) { yield return item; } } } private readonly int _partialSuccessLimit; internal int PartialSuccessLimit => _partialSuccessLimit; public ClientAuthentication(int partialSuccessLimit) { if (partialSuccessLimit < 1) { throw new ArgumentOutOfRangeException("partialSuccessLimit", "Cannot be less than one."); } _partialSuccessLimit = partialSuccessLimit; } public void Authenticate(IConnectionInfoInternal connectionInfo, ISession session) { ThrowHelper.ThrowIfNull(connectionInfo, "connectionInfo"); ThrowHelper.ThrowIfNull(session, "session"); session.RegisterMessage("SSH_MSG_USERAUTH_FAILURE"); session.RegisterMessage("SSH_MSG_USERAUTH_SUCCESS"); session.RegisterMessage("SSH_MSG_USERAUTH_BANNER"); session.UserAuthenticationBannerReceived += connectionInfo.UserAuthenticationBannerReceived; try { SshAuthenticationException authenticationException = null; IAuthenticationMethod authenticationMethod = connectionInfo.CreateNoneAuthenticationMethod(); if (authenticationMethod.Authenticate(session) != 0 && !TryAuthenticate(session, new AuthenticationState(connectionInfo.AuthenticationMethods), authenticationMethod.AllowedAuthentications, ref authenticationException)) { throw authenticationException; } } finally { session.UserAuthenticationBannerReceived -= connectionInfo.UserAuthenticationBannerReceived; session.UnRegisterMessage("SSH_MSG_USERAUTH_FAILURE"); session.UnRegisterMessage("SSH_MSG_USERAUTH_SUCCESS"); session.UnRegisterMessage("SSH_MSG_USERAUTH_BANNER"); } } private bool TryAuthenticate(ISession session, AuthenticationState authenticationState, string[] allowedAuthenticationMethods, ref SshAuthenticationException authenticationException) { if (allowedAuthenticationMethods.Length == 0) { authenticationException = new SshAuthenticationException("No authentication methods defined on SSH server."); return false; } List<IAuthenticationMethod> supportedAuthenticationMethods = authenticationState.GetSupportedAuthenticationMethods(allowedAuthenticationMethods); if (supportedAuthenticationMethods.Count == 0) { authenticationException = new SshAuthenticationException(string.Format(CultureInfo.InvariantCulture, "No suitable authentication method found to complete authentication ({0}).", string.Join(',', allowedAuthenticationMethods))); return false; } foreach (IAuthenticationMethod activeAuthenticationMethod in authenticationState.GetActiveAuthenticationMethods(supportedAuthenticationMethods)) { if (authenticationState.GetPartialSuccessCount(activeAuthenticationMethod) >= _partialSuccessLimit) { authenticationException = new SshAuthenticationException($"Reached authentication attempt limit for method ({activeAuthenticationMethod.Name})."); continue; } AuthenticationResult authenticationResult = activeAuthenticationMethod.Authenticate(session); switch (authenticationResult) { case AuthenticationResult.PartialSuccess: authenticationState.RecordPartialSuccess(activeAuthenticationMethod); if (TryAuthenticate(session, authenticationState, activeAuthenticationMethod.AllowedAuthentications, ref authenticationException)) { authenticationResult = AuthenticationResult.Success; } break; case AuthenticationResult.Failure: authenticationState.RecordFailure(activeAuthenticationMethod); authenticationException = new SshAuthenticationException($"Permission denied ({activeAuthenticationMethod.Name})."); break; case AuthenticationResult.Success: authenticationException = null; break; } if (authenticationResult != 0) { continue; } return true; } return false; } } public class ConnectionInfo : IConnectionInfoInternal, IConnectionInfo { internal const int DefaultPort = 22; private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(30.0); private static readonly TimeSpan DefaultChannelCloseTimeout = TimeSpan.FromSeconds(1.0); private TimeSpan _timeout; private TimeSpan _channelCloseTimeout; public IDictionary<string, Func<IKeyExchange>> KeyExchangeAlgorithms { get; private set; } public IDictionary<string, CipherInfo> Encryptions { get; private set; } public IDictionary<string, HashInfo> HmacAlgorithms { get; private set; } public IDictionary<string, Func<byte[], KeyHostAlgorithm>> HostKeyAlgorithms { get; private set; } public IList<AuthenticationMethod> AuthenticationMethods { get; private set; } public IDictionary<string, Func<Compressor>> CompressionAlgorithms { get; private set; } public IDictionary<string, RequestInfo> ChannelRequests { get; private set; } public bool IsAuthenticated { get; private set; } public string Host { get; private set; } public int Port { get; private set; } public string Username { get; private set; } public ProxyTypes ProxyType { get; private set; } public string ProxyHost { get; private set; } public int ProxyPort { get; private set; } public string ProxyUsername { get; private set; } public string ProxyPassword { get; private set; } public TimeSpan Timeout { get { return _timeout; } set { value.EnsureValidTimeout("Timeout"); _timeout = value; } } public TimeSpan ChannelCloseTimeout { get { return _channelCloseTimeout; } set { value.EnsureValidTimeout("ChannelCloseTimeout"); _channelCloseTimeout = value; } } public Encoding Encoding { get; set; } public int RetryAttempts { get; set; } public int MaxSessions { get; set; } public string CurrentKeyExchangeAlgorithm { get; internal set; } public string CurrentServerEncryption { get; internal set; } public string CurrentClientEncryption { get; internal set; } public string CurrentServerHmacAlgorithm { get; internal set; } public string CurrentClientHmacAlgorithm { get; internal set; } public string CurrentHostKeyAlgorithm { get; internal set; } public string CurrentServerCompressionAlgorithm { get; internal set; } public string ServerVersion { get; internal set; } public string ClientVersion { get; internal set; } public string CurrentClientCompressionAlgorithm { get; internal set; } IList<IAuthenticationMethod> IConnectionInfoInternal.AuthenticationMethods => AuthenticationMethods.Cast<IAuthenticationMethod>().ToList(); public event EventHandler<AuthenticationBannerEventArgs> AuthenticationBanner; public ConnectionInfo(string host, string username, params AuthenticationMethod[] authenticationMethods) : this(host, 22, username, ProxyTypes.None, null, 0, null, null, authenticationMethods) { } public ConnectionInfo(string host, int port, string username, params AuthenticationMethod[] authenticationMethods) : this(host, port, username, ProxyTypes.None, null, 0, null, null, authenticationMethods) { } public ConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword, params AuthenticationMethod[] authenticationMethods) { ThrowHelper.ThrowIfNull(host, "host"); port.ValidatePort("port"); ThrowHelper.ThrowIfNullOrWhiteSpace(username, "username"); if (proxyType != 0) { ThrowHelper.ThrowIfNull(proxyHost, "proxyHost"); proxyPort.ValidatePort("proxyPort"); } ThrowHelper.ThrowIfNull(authenticationMethods, "authenticationMethods"); if (authenticationMethods.Length == 0) { throw new ArgumentException("At least one authentication method should be specified.", "authenticationMethods"); } Timeout = DefaultTimeout; ChannelCloseTimeout = DefaultChannelCloseTimeout; RetryAttempts = 10; MaxSessions = 10; Encoding = Encoding.UTF8; KeyExchangeAlgorithms = new Dictionary<string, Func<IKeyExchange>> { { "curve25519-sha256", () => new KeyExchangeECCurve25519() }, { "[email protected]", () => new KeyExchangeECCurve25519() }, { "ecdh-sha2-nistp256", () => new KeyExchangeECDH256() }, { "ecdh-sha2-nistp384", () => new KeyExchangeECDH384() }, { "ecdh-sha2-nistp521", () => new KeyExchangeECDH521() }, { "diffie-hellman-group-exchange-sha256", () => new KeyExchangeDiffieHellmanGroupExchangeSha256() }, { "diffie-hellman-group-exchange-sha1", () => new KeyExchangeDiffieHellmanGroupExchangeSha1() }, { "diffie-hellman-group16-sha512", () => new KeyExchangeDiffieHellmanGroup16Sha512() }, { "diffie-hellman-group14-sha256", () => new KeyExchangeDiffieHellmanGroup14Sha256() }, { "diffie-hellman-group14-sha1", () => new KeyExchangeDiffieHellmanGroup14Sha1() }, { "diffie-hellman-group1-sha1", () => new KeyExchangeDiffieHellmanGroup1Sha1() } }; Encryptions = new Dictionary<string, CipherInfo> { { "aes128-ctr", new CipherInfo(128, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CTR)) }, { "aes192-ctr", new CipherInfo(192, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CTR)) }, { "aes256-ctr", new CipherInfo(256, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CTR)) }, { "[email protected]", new CipherInfo(128, (byte[] key, byte[] iv) => new AesGcmCipher(key, iv, 4), isAead: true) }, { "[email protected]", new CipherInfo(256, (byte[] key, byte[] iv) => new AesGcmCipher(key, iv, 4), isAead: true) }, { "[email protected]", new CipherInfo(512, (byte[] key, byte[] iv) => new ChaCha20Poly1305Cipher(key, 4), isAead: true) }, { "aes128-cbc", new CipherInfo(128, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CBC)) }, { "aes192-cbc", new CipherInfo(192, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CBC)) }, { "aes256-cbc", new CipherInfo(256, (byte[] key, byte[] iv) => new AesCipher(key, iv, AesCipherMode.CBC)) }, { "3des-cbc", new CipherInfo(192, (byte[] key, byte[] iv) => new TripleDesCipher(key, new CbcCipherMode(iv), null)) } }; HmacAlgorithms = new Dictionary<string, HashInfo> { { "hmac-sha2-256", new HashInfo(256, (byte[] key) => new HMACSHA256(key)) }, { "hmac-sha2-512", new HashInfo(512, (byte[] key) => new HMACSHA512(key)) }, { "hmac-sha1", new HashInfo(160, (byte[] key) => new HMACSHA1(key)) }, { "[email protected]", new HashInfo(256, (byte[] key) => new HMACSHA256(key), isEncryptThenMAC: true) }, { "[email protected]", new HashInfo(512, (byte[] key) => new HMACSHA512(key), isEncryptThenMAC: true) }, { "[email protected]", new HashInfo(160, (byte[] key) => new HMACSHA1(key), isEncryptThenMAC: true) } }; Dictionary<string, Func<byte[], KeyHostAlgorithm>> hostAlgs = new Dictionary<string, Func<byte[], KeyHostAlgorithm>>(); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate8 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate8, hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate7 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate7, hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate6 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate6, hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate5 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate5, hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate4 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate4, new RsaDigitalSignature((RsaKey)certificate4.Key, HashAlgorithmName.SHA512), hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate3 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate3, new RsaDigitalSignature((RsaKey)certificate3.Key, HashAlgorithmName.SHA256), hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate2 = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate2, hostAlgs); }); hostAlgs.Add("[email protected]", delegate(byte[] data) { Certificate certificate = new Certificate(data); return new CertificateHostAlgorithm("[email protected]", certificate, hostAlgs); }); hostAlgs.Add("ssh-ed25519", (byte[] data) => new KeyHostAlgorithm("ssh-ed25519", new ED25519Key(new SshKeyData(data)))); hostAlgs.Add("ecdsa-sha2-nistp256", (byte[] data) => new KeyHostAlgorithm("ecdsa-sha2-nistp256", new EcdsaKey(new SshKeyData(data)))); hostAlgs.Add("ecdsa-sha2-nistp384", (byte[] data) => new KeyHostAlgorithm("ecdsa-sha2-nistp384", new EcdsaKey(new SshKeyData(data)))); hostAlgs.Add("ecdsa-sha2-nistp521", (byte[] data) => new KeyHostAlgorithm("ecdsa-sha2-nistp521", new EcdsaKey(new SshKeyData(data)))); hostAlgs.Add("rsa-sha2-512", delegate(byte[] data) { RsaKey rsaKey2 = new RsaKey(new SshKeyData(data)); return new KeyHostAlgorithm("rsa-sha2-512", rsaKey2, new RsaDigitalSignature(rsaKey2, HashAlgorithmName.SHA512)); }); hostAlgs.Add("rsa-sha2-256", delegate(byte[] data) { RsaKey rsaKey = new RsaKey(new SshKeyData(data)); return new KeyHostAlgorithm("rsa-sha2-256", rsaKey, new RsaDigitalSignature(rsaKey, HashAlgorithmName.SHA256)); }); hostAlgs.Add("ssh-rsa", (byte[] data) => new KeyHostAlgorithm("ssh-rsa", new RsaKey(new SshKeyData(data)))); hostAlgs.Add("ssh-dss", (byte[] data) => new KeyHostAlgorithm("ssh-dss", new DsaKey(new SshKeyData(data)))); HostKeyAlgorithms = hostAlgs; CompressionAlgorithms = new Dictionary<string, Func<Compressor>> { { "none", null }, { "[email protected]", () => new ZlibOpenSsh() } }; ChannelRequests = new Dictionary<string, RequestInfo> { { "env", new EnvironmentVariableRequestInfo() }, { "exec", new ExecRequestInfo() }, { "exit-signal", new ExitSignalRequestInfo() }, { "exit-status", new ExitStatusRequestInfo() }, { "pty-req", new PseudoTerminalRequestInfo() }, { "shell", new ShellRequestInfo() }, { "signal", new SignalRequestInfo() }, { "subsystem", new SubsystemRequestInfo() }, { "window-change", new WindowChangeRequestInfo() }, { "x11-req", new X11ForwardingRequestInfo() }, { "xon-xoff", new XonXoffRequestInfo() }, { "[email protected]", new EndOfWriteRequestInfo() }, { "[email protected]", new KeepAliveRequestInfo() } }; Host = host; Port = port; Username = username; ProxyType = proxyType; ProxyHost = proxyHost; ProxyPort = proxyPort; ProxyUsername = proxyUsername; ProxyPassword = proxyPassword; AuthenticationMethods = authenticationMethods; } internal void Authenticate(ISession session, IServiceFactory serviceFactory) { ThrowHelper.ThrowIfNull(serviceFactory, "serviceFactory"); IsAuthenticated = false; serviceFactory.CreateClientAuthentication().Authenticate(this, session); IsAuthenticated = true; } void IConnectionInfoInternal.UserAuthenticationBannerReceived(object sender, MessageEventArgs<BannerMessage> e) { this.AuthenticationBanner?.Invoke(this, new AuthenticationBannerEventArgs(Username, e.Message.Message, e.Message.Language)); } IAuthenticationMethod IConnectionInfoInternal.CreateNoneAuthenticationMethod() { return new NoneAuthenticationMethod(Username); } } public class ExpectAction { public Regex Expect { get; private set; } public Action<string> Action { get; private set; } public ExpectAction(Regex expect, Action<string> action) { ThrowHelper.ThrowIfNull(expect, "expect"); ThrowHelper.ThrowIfNull(action, "action"); Expect = expect; Action = action; } public ExpectAction(string expect, Action<string> action) { ThrowHelper.ThrowIfNull(expect, "expect"); ThrowHelper.ThrowIfNull(action, "action"); Expect = new Regex(Regex.Escape(expect)); Action = action; } } public abstract class ForwardedPort : IForwardedPort, IDisposable { internal ISession Session { get; set; } public abstract bool IsStarted { get; } public event EventHandler Closing; public event EventHandler<ExceptionEventArgs> Exception; public event EventHandler<PortForwardEventArgs> RequestReceived; public virtual void Start() { CheckDisposed(); if (IsStarted) { throw new InvalidOperationException("Forwarded port is already started."); } if (Session == null) { throw new InvalidOperationException("Forwarded port is not added to a client."); } if (!Session.IsConnected) { throw new SshConnectionException("Client not connected."); } Session.ErrorOccured += Session_ErrorOccured; StartPort(); } public virtual void Stop() { if (IsStarted) { StopPort(Session.ConnectionInfo.Timeout); } } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected abstract void StartPort(); protected virtual void StopPort(TimeSpan timeout) { timeout.EnsureValidTimeout("timeout"); RaiseClosing(); ISession session = Session; if (session != null) { session.ErrorOccured -= Session_ErrorOccured; } } protected virtual void Dispose(bool disposing) { if (disposing) { ISession session = Session; if (session != null) { StopPort(session.ConnectionInfo.Timeout); Session = null; } } } protected abstract void CheckDisposed(); protected void RaiseExceptionEvent(Exception exception) { this.Exception?.Invoke(this, new ExceptionEventArgs(exception)); } protected void RaiseRequestReceived(string host, uint port) { this.RequestReceived?.Invoke(this, new PortForwardEventArgs(host, port)); } private void RaiseClosing() { this.Closing?.Invoke(this, EventArgs.Empty); } private void Session_ErrorOccured(object sender, ExceptionEventArgs e) { RaiseExceptionEvent(e.Exception); } } public class ForwardedPortDynamic : ForwardedPort { private ForwardedPortStatus _status; private bool _isDisposed; private Socket _listener; private CountdownEvent _pendingChannelCountdown; public string BoundHost { get; } public uint BoundPort { get; } public override bool IsStarted => _status == ForwardedPortStatus.Started; public ForwardedPortDynamic(uint port) : this(string.Empty, port) { } public ForwardedPortDynamic(string host, uint port) { BoundHost = host; BoundPort = port; _status = ForwardedPortStatus.Stopped; } protected override void StartPort() { if (!ForwardedPortStatus.ToStarting(ref _status)) { return; } try { InternalStart(); } catch (Exception) { _status = ForwardedPortStatus.Stopped; throw; } } protected override void StopPort(TimeSpan timeout) { timeout.EnsureValidTimeout("timeout"); if (ForwardedPortStatus.ToStopping(ref _status)) { base.StopPort(timeout); StopListener(); InternalStop(timeout); _status = ForwardedPortStatus.Stopped; } } protected override void CheckDisposed() { ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this); } protected override void Dispose(bool disposing) { if (!_isDisposed) { base.Dispose(disposing); InternalDispose(disposing); _isDisposed = true; } } private void InternalStart() { InitializePendingChannelCountdown(); IPAddress address = IPAddress.Any; if (!string.IsNullOrEmpty(BoundHost)) { address = Dns.GetHostAddresses(BoundHost)[0]; } IPEndPoint iPEndPoint = new IPEndPoint(address, (int)BoundPort); _listener = new Socket(iPEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp) { NoDelay = true }; _listener.Bind(iPEndPoint); _listener.Listen(5); base.Session.ErrorOccured += Session_ErrorOccured; base.Session.Disconnected += Session_Disconnected; _status = ForwardedPortStatus.Started; StartAccept(null); } private void StartAccept(SocketAsyncEventArgs e) { if (e == null) { e = new SocketAsyncEventArgs(); e.Completed += AcceptCompleted; } else { e.AcceptSocket = null; } if (!IsStarted) { return; } try { if (!_listener.AcceptAsync(e)) { AcceptCompleted(null, e); } } catch (ObjectDisposedException) { if (_status == ForwardedPortStatus.Stopping || _status == ForwardedPortStatus.Stopped) { return; } throw; } } private void AcceptCompleted(object sender, SocketAsyncEventArgs e) { SocketError socketError = e.SocketError; if ((socketError != SocketError.OperationAborted && socketError != SocketError.NotSocket) || 1 == 0) { Socket acceptSocket = e.AcceptSocket; if (e.SocketError != 0) { StartAccept(e); CloseClientSocket(acceptSocket); } else { StartAccept(e); ProcessAccept(acceptSocket); } } } private void ProcessAccept(Socket clientSocket) { if (!IsStarted) { CloseClientSocket(clientSocket); return; } CountdownEvent pendingChannelCountdown = _pendingChannelCountdown; pendingChannelCountdown.AddCount(); try { using IChannelDirectTcpip channelDirectTcpip = base.Session.CreateChannelDirectTcpip(); channelDirectTcpip.Exception += Channel_Exception; if (!HandleSocks(channelDirectTcpip, clientSocket, base.Session.ConnectionInfo.Timeout)) { CloseClientSocket(clientSocket); } else { channelDirectTcpip.Bind(); } } catch (Exception exception) { RaiseExceptionEvent(exception); CloseClientSocket(clientSocket); } finally { try { pendingChannelCountdown.Signal(); } catch (ObjectDisposedException) { } } } private void InitializePendingChannelCountdown() { Interlocked.Exchange(ref _pendingChannelCountdown, new CountdownEvent(1))?.Dispose(); } private bool HandleSocks(IChannelDirectTcpip channel, Socket clientSocket, TimeSpan timeout) { base.Closing += closeClientSocket; try { int num = SocketAbstraction.ReadByte(clientSocket, timeout); return num switch { -1 => false, 4 => HandleSocks4(clientSocket, channel, timeout), 5 => HandleSocks5(clientSocket, channel, timeout), _ => throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "SOCKS version {0} is not supported.", num)), }; } catch (SocketException ex) { if (ex.SocketErrorCode != SocketError.ConnectionAborted) { RaiseExceptionEvent(ex); } return false; } finally { base.Closing -= closeClientSocket; } void closeClientSocket(object sender, EventArgs args) { CloseClientSocket(clientSocket); } } private static void CloseClientSocket(Socket clientSocket) { if (clientSocket.Connected) { try { clientSocket.Shutdown(SocketShutdown.Send); } catch (Exception) { } } clientSocket.Dispose(); } private void StopListener() { _listener?.Dispose(); ISession session = base.Session; if (session != null) { session.ErrorOccured -= Session_ErrorOccured; session.Disconnected -= Session_Disconnected; } } private void InternalStop(TimeSpan timeout) { _pendingChannelCountdown.Signal(); _pendingChannelCountdown.Wait(timeout); } private void InternalDispose(bool disposing) { if (disposing) { Socket listener = _listener; if (listener != null) { _listener = null; listener.Dispose(); } CountdownEvent pendingChannelCountdown = _pendingChannelCountdown; if (pendingChannelCountdown != null) { _pendingChannelCountdown = null; pendingChannelCountdown.Dispose(); } } } private void Session_Disconnected(object sender, EventArgs e) { ISession session = base.Session; if (session != null) { StopPort(session.ConnectionInfo.Timeout); } } private void Session_ErrorOccured(object sender, ExceptionEventArgs e) { ISession session = base.Session; if (session != null) { StopPort(session.ConnectionInfo.Timeout); } } private void Channel_Exception(object sender, ExceptionEventArgs e) { RaiseExceptionEvent(e.Exception); } private bool HandleSocks4(Socket socket, IChannelDirectTcpip channel, TimeSpan timeout) { if (SocketAbstraction.ReadByte(socket, timeout) == -1) { return false; } byte[] array = new byte[2]; if (SocketAbstraction.Read(socket, array, 0, array.Length, timeout) == 0) { return false; } ushort port = BinaryPrimitives.ReadUInt16BigEndian(array); byte[] array2 = new byte[4]; if (SocketAbstraction.Read(socket, array2, 0, array2.Length, timeout) == 0) { return false; } IPAddress iPAddress = new IPAddress(array2); if (ReadString(socket, timeout) == null) { return false; } string text = iPAddress.ToString(); RaiseRequestReceived(text, port); channel.Open(text, port, this, socket); SocketAbstraction.SendByte(socket, 0); if (channel.IsOpen) { SocketAbstraction.SendByte(socket, 90); SocketAbstraction.Send(socket, array, 0, array.Length); SocketAbstraction.Send(socket, array2, 0, array2.Length); return true; } SocketAbstraction.SendByte(socket, 91); return false; } private bool HandleSocks5(Socket socket, IChannelDirectTcpip channel, TimeSpan timeout) { int num = SocketAbstraction.ReadByte(socket, timeout); if (num == -1) { return false; } byte[] array = new byte[num]; if (SocketAbstraction.Read(socket, array, 0, array.Length, timeout) == 0) { return false; } if (array.Min() == 0) { SocketAbstraction.Send(socket, new byte[2] { 5, 0 }, 0, 2); } else { SocketAbstraction.Send(socket, new byte[2] { 5, 255 }, 0, 2); } switch (SocketAbstraction.ReadByte(socket, timeout)) { case -1: return false; default: throw new ProxyException("SOCKS5: Version 5 is expected."); case 5: if (SocketAbstraction.ReadByte(socket, timeout) == -1) { return false; } switch (SocketAbstraction.ReadByte(socket, timeout)) { case -1: return false; default: throw new ProxyException("SOCKS5: 0 is expected for reserved byte."); case 0: { int num2 = SocketAbstraction.ReadByte(socket, timeout); if (num2 == -1) { return false; } string socks5Host = GetSocks5Host(num2, socket, timeout); if (socks5Host == null) { return false; } byte[] array2 = new byte[2]; if (SocketAbstraction.Read(socket, array2, 0, array2.Length, timeout) == 0) { return false; } ushort port = BinaryPrimitives.ReadUInt16BigEndian(array2); RaiseRequestReceived(socks5Host, port); channel.Open(socks5Host, port, this, socket); byte[] array3 = CreateSocks5Reply(channel.IsOpen); SocketAbstraction.Send(socket, array3, 0, array3.Length); return true; } } } } private static string GetSocks5Host(int addressType, Socket socket, TimeSpan timeout) { switch (addressType) { case 1: { byte[] array3 = new byte[4]; if (SocketAbstraction.Read(socket, array3, 0, 4, timeout) == 0) { return null; } return new IPAddress(array3).ToString(); } case 3: { int num = SocketAbstraction.ReadByte(socket, timeout); if (num == -1) { return null; } byte[] array2 = new byte[num]; if (SocketAbstraction.Read(socket, array2, 0, array2.Length, timeout) == 0) { return null; } return SshData.Ascii.GetString(array2, 0, array2.Length); } case 4: { byte[] array = new byte[16]; if (SocketAbstraction.Read(socket, array, 0, 16, timeout) == 0) { return null; } return new IPAddress(array).ToString(); } default: throw new ProxyException(string.Format(CultureInfo.InvariantCulture, "SOCKS5: Address type '{0}' is not supported.", addressType)); } } private static byte[] CreateSocks5Reply(bool channelOpen) { byte[] array = new byte[10] { 5, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (channelOpen) { array[1] = 0; } else { array[1] = 1; } array[2] = 0; array[3] = 1; return array; } private static string ReadString(Socket socket, TimeSpan timeout) { StringBuilder stringBuilder = new StringBuilder(); byte[] array = new byte[1]; while (true) { if (SocketAbstraction.Read(socket, array, 0, 1, timeout) == 0) { return null; } byte b = array[0]; if (b == 0) { break; } stringBuilder.Append((char)b); } return stringBuilder.ToString(); } ~ForwardedPortDynamic() { Dispose(disposing: false); } } public class ForwardedPortLocal : ForwardedPort { private ForwardedPortStatus _status; private bool _isDisposed; private Socket _listener; private CountdownEvent _pendingChannelCountdown; public string BoundHost { get; private set; } public uint BoundPort { get; private set; } public string Host { get; private set; } public uint Port { get; private set; } public override bool IsStarted => _status == ForwardedPortStatus.Started; public ForwardedPortLocal(uint boundPort, string host, uint port) : this(string.Empty, boundPort, host, port) { } public ForwardedPortLocal(string boundHost, string host, uint port) : this(boundHost, 0u, host, port) { } public ForwardedPortLocal(string boundHost, uint boundPort, string host, uint port) { ThrowHelper.ThrowIfNull(boundHost, "boundHost"); ThrowHelper.ThrowIfNull(host, "host"); boundPort.ValidatePort("boundPort"); port.ValidatePort("port"); BoundHost = boundHost; BoundPort = boundPort; Host = host; Port = port; _status = ForwardedPortStatus.Stopped; } protected override void StartPort() { if (!ForwardedPortStatus.ToStarting(ref _status)) { return; } try { InternalStart(); } catch (Exception) { _status = ForwardedPortStatus.Stopped; throw; } } protected override void StopPort(TimeSpan timeout) { timeout.EnsureValidTimeout("timeout"); if (ForwardedPortStatus.ToStopping(ref _status)) { base.StopPort(timeout); StopListener(); InternalStop(timeout); _status = ForwardedPortStatus.Stopped; } } protected override void CheckDisposed() { ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this); } protected override void Dispose(bool disposing) { if (!_isDisposed) { base.Dispose(disposing); InternalDispose(disposing); _isDisposed = true; } } ~ForwardedPortLocal() { Dispose(disposing: false); } private void InternalStart() { IPEndPoint iPEndPoint = new IPEndPoint(Dns.GetHostAddresses(BoundHost)[0], (int)BoundPort); _listener = new Socket(iPEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp) { NoDelay = true }; _listener.Bind(iPEndPoint); _listener.Listen(5); BoundPort = (uint)((IPEndPoint)_listener.LocalEndPoint).Port; base.Session.ErrorOccured += Session_ErrorOccured; base.Session.Disconnected += Session_Disconnected; InitializePendingChannelCountdown(); _status = ForwardedPortStatus.Started; StartAccept(null); } private void StartAccept(SocketAsyncEventArgs e) { if (e == null) { e = new SocketAsyncEventArgs(); e.Completed += AcceptCompleted; } else { e.AcceptSocket = null; } if (!IsStarted) { return; } try { if (!_listener.AcceptAsync(e)) { AcceptCompleted(null, e); } } catch (ObjectDisposedException) { if (_status == ForwardedPortStatus.Stopping || _status == ForwardedPortStatus.Stopped) { return; } throw; } } private void AcceptCompleted(object sender, SocketAsyncEventArgs e) { SocketError socketError = e.SocketError; if ((socketError != SocketError.OperationAborted && socketError != SocketError.NotSocket) || 1 == 0) { Socket acceptSocket = e.AcceptSocket; if (e.SocketError != 0) { StartAccept(e); CloseClientSocket(acceptSocket); } else { StartAccept(e); ProcessAccept(acceptSocket); } } } private void ProcessAccept(Socket clientSocket) { if (!IsStarted) { CloseClientSocket(clientSocket); return; } CountdownEvent pendingChannelCountdown = _pendingChannelCountdown; pendingChannelCountdown.AddCount(); try { IPEndPoint iPEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint; RaiseRequestReceived(iPEndPoint.Address.ToString(), (uint)iPEndPoint.Port); using IChannelDirectTcpip channelDirectTcpip = base.Session.CreateChannelDirectTcpip(); channelDirectTcpip.Exception += Channel_Exception; channelDirectTcpip.Open(Host, Port, this, clientSocket); channelDirectTcpip.Bind(); } catch (Exception exception) { RaiseExceptionEvent(exception); CloseClientSocket(clientSocket); } finally { try { pendingChannelCountdown.Signal(); } catch (ObjectDisposedException) { } } } private void InitializePendingChannelCountdown() { Interlocked.Exchange(ref _pendingChannelCountdown, new CountdownEvent(1))?.Dispose(); } private static void CloseClientSocket(Socket clientSocket) { if (clientSocket.Connected) { try { clientSocket.Shutdown(SocketShutdown.Send); } catch (Exception) { } } clientSocket.Dispose(); } private void StopListener() { _listener?.Dispose(); ISession session = base.Session; if (session != null) { session.ErrorOccured -= Session_ErrorOccured; session.Disconnected -= Session_Disconnected; } } private void InternalStop(TimeSpan timeout) { _pendingChannelCountdown.Signal(); _pendingChannelCountdown.Wait(timeout); } private void InternalDispose(bool disposing) { if (disposing) { Socket listener = _listener; if (listener != null) { _listener = null; listener.Dispose(); } CountdownEvent pendingChannelCountdown = _pendingChannelCountdown; if (pendingChannelCountdown != null) { _pendingChannelCountdown = null; pendingChannelCountdown.Dispose(); } } } private void Session_Disconnected(object sender, EventArgs e) { ISession session = base.Session; if (session != null) { StopPort(session.ConnectionInfo.Timeout); } } private void Session_ErrorOccured(object sender, ExceptionEventArgs e) { ISession session = base.Session; if (session != null) { StopPort(session.ConnectionInfo.Timeout); } } private void Channel_Exception(object sender, ExceptionEventArgs e) { RaiseExceptionEvent(e.Exception); } } public class ForwardedPortRemote : ForwardedPort { private ForwardedPortStatus _status; private bool _requestStatus; private EventWaitHandle _globalRequestResponse = new AutoResetEvent(initialState: false); private CountdownEvent _pendingChannelCountdown; private bool _isDisposed; public override bool IsStarted => _status == ForwardedPortStatus.Started; public IPAddress BoundHostAddress { get; private set; } public string BoundHost => BoundHostAddress.ToString(); public uint BoundPort { get; private set; } public IPAddress HostAddress { get; private set; } public string Host => HostAddress.ToString(); public uint Port { get; private set; } public ForwardedPortRemote(IPAddress boundHostAddress, uint boundPort, IPAddress hostAddress, uint port) { ThrowHelper.ThrowIfNull(boundHostAddress, "boundHostAddress"); ThrowHelper.ThrowIfNull(hostAddress, "hostAddress"); boundPort.ValidatePort("boundPort"); port.ValidatePort("port"); BoundHostAddress = boundHostAddress; BoundPort = boundPort; HostAddress = hostAddress; Port = port; _status = ForwardedPortStatus.Stopped; } public ForwardedPortRemote(uint boundPort, string host, uint port) : this(string.Empty, boundPort, host, port) { } public ForwardedPortRemote(string boundHost, uint boundPort, string host, uint port) : this(Dns.GetHostAddresses(boundHost)[0], boundPort, Dns.GetHostAddresses(host)[0], port) { } protected override void StartPort() { if (!ForwardedPortStatus.ToStarting(ref _status)) { return; } InitializePendingChannelCountdown(); try { base.Session.RegisterMessage("SSH_MSG_REQUEST_FAILURE"); base.Session.RegisterMessage("SSH_MSG_REQUEST_SUCCESS"); base.Session.RegisterMessage("SSH_MSG_CHANNEL_OPEN"); base.Session.RequestSuccessReceived += Session_RequestSuccess; base.Session.RequestFailureReceived += Session_RequestFailure; base.Session.ChannelOpenReceived += Session_ChannelOpening; base.Session.SendMessage(new TcpIpForwardGlobalRequestMessage(BoundHost, BoundPort)); base.Session.WaitOnHandle(_globalRequestResponse); if (!_requestStatus) { throw new SshException(string.Format(CultureInfo.CurrentCulture, "Port forwarding for '{0}' port '{1}' failed to start.", Host, Port)); } } catch (Exception) { _status = ForwardedPortStatus.Stopped; base.Session.RequestSuccessReceived -= Session_RequestSuccess; base.Session.RequestFailureReceived -= Session_RequestFailure; base.Session.ChannelOpenReceived -= Session_ChannelOpening; throw; } _status = ForwardedPortStatus.Started; } protected override void StopPort(TimeSpan timeout) { timeout.EnsureValidTimeout("timeout"); if (ForwardedPortStatus.ToStopping(ref _status)) { base.StopPort(timeout); base.Session.SendMessage(new CancelTcpIpForwardGlobalRequestMessage(BoundHost, BoundPort)); WaitHandle.WaitAny(new WaitHandle[2] { _globalRequestResponse, base.Session.MessageListenerCompleted }, timeout); base.Session.RequestSuccessReceived -= Session_RequestSuccess; base.Session.RequestFailureReceived -= Session_RequestFailure; base.Session.ChannelOpenReceived -= Session_ChannelOpening; _pendingChannelCountdown.Signal(); _pendingChannelCountdown.Wait(timeout); _status = ForwardedPortStatus.Stopped; } } protected override void CheckDisposed() { ThrowHelper.ThrowObjectDisposedIf(_isDisposed, this); } private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenMessage> e) { ChannelOpenMessage channelOpenMessage = e.Message; ChannelOpenInfo info2 = channelOpenMessage.Info; ForwardedTcpipChannelInfo info = info2 as ForwardedTcpipChannelInfo; if (info == null || !(info.ConnectedAddress == BoundHost) || info.ConnectedPort != BoundPort) { return; } if (!IsStarted) { base.Session.SendMessage(new ChannelOpenFailureMessage(channelOpenMessage.LocalChannelNumber, string.Empty, 1u)); return; } ThreadAbstraction.ExecuteThread(delegate { CountdownEvent pendingChannelCountdown = _pendingChannelCountdown; pendingChannelCountdown.AddCount(); try { RaiseRequestReceived(info.OriginatorAddress, info.OriginatorPort); using IChannelForwardedTcpip channelForwardedTcpip = base.Session.CreateChannelForwardedTcpip(channelOpenMessage.LocalChannelNumber, channelOpenMessage.InitialWindowSize, channelOpenMessage.MaximumPacketSize); channelForwardedTcpip.Exception += Channel_Exception; channelForwardedTcpip.Bind(new IPEndPoint(HostAddress, (int)Port), this); } catch (Exception exception) { RaiseExceptionEvent(exception); } finally { try { pendingChannelCountdown.Signal(); } catch (ObjectDisposedException) { } } }); } private void InitializePendingChannelCountdown() { Interlocked.Exchange(ref _pendingChannelCountdown, new CountdownEvent(1))?.Dispose(); } private void Channel_Exception(object sender, ExceptionEventArgs exceptionEventArgs) { RaiseExceptionEvent(exceptionEventArgs.Exception); } private void Session_RequestFailure(object sender, EventArgs e) { _requestStatus = false; _globalRequestResponse.Set(); } private void Session_RequestSuccess(object sender, MessageEventArgs<RequestSuccessMessage> e) { _requestStatus = true; if (BoundPort == 0) { BoundPort = (e.Message.BoundPort.HasValue ? e.Message.BoundPort.Value : 0u); } _globalRequestResponse.Set(); } protected override void Dispose(bool disposing) { if (_isDisposed) { return; } base.Dispose(disposing); if (disposing) { ISession session = base.Session; if (session != null) { base.Session = null; session.RequestSuccessReceived -= Session_RequestSuccess; session.RequestFailureReceived -= Session_RequestFailure; session.ChannelOpenReceived -= Session_ChannelOpening; } EventWaitHandle globalRequestResponse = _globalRequestResponse; if (globalRequestResponse != null) { _globalRequestResponse = null; globalRequestResponse.Dispose(); } CountdownEvent pendingChannelCountdown = _pendingChannelCountdown; if (pendingChannelCountdown != null) { _pendingChannelCountdown = null; pendingChannelCountdown.Dispose(); } } _isDisposed = true; } } internal sealed class ForwardedPortStatus { public static readonly ForwardedPortStatus Stopped = new ForwardedPortStatus(1, "Stopped"); public static readonly ForwardedPortStatus Stopping = new ForwardedPortStatus(2, "Stopping"); public static readonly ForwardedPortStatus Started = new ForwardedPortStatus(3, "Started"); public static readonly ForwardedPortStatus Starting = new ForwardedPortStatus(4, "Starting"); private readonly int _value; private readonly string _name; private ForwardedPortStatus(int value, string name) { _value = value; _name = name; } public override bool Equals(object obj) { if (this == obj) { return true; } if (!(obj is ForwardedPortStatus forwardedPortStatus)) { return false; } return forwardedPortStatus._value == _value; } public static bool operator ==(ForwardedPortStatus left, ForwardedPortStatus right) { return left?.Equals(right) ?? ((object)right == null); } public static bool operator !=(ForwardedPortStatus left, ForwardedPortStatus right) { return !(left == right); } public override int GetHashCode() { return _value; } public override string ToString() { return _name; } public static bool ToStopping(ref ForwardedPortStatus status) { ForwardedPortStatus forwardedPortStatus = Interlocked.CompareExchange(ref status, Stopping, Started); if (forwardedPortStatus == Stopping || forwardedPortStatus == Stopped) { return false; } if (status == Stopping) { return true; } forwardedPortStatus = Interlocked.CompareExchange(ref status, Stopping, Starting); if (forwardedPortStatus == Stopping || forwardedPortStatus == Stopped) { return false; } if (status == Stopping) { return true; } throw new InvalidOperationException($"Forwarded port cannot transition from '{forwardedPortStatus}' to '{Stopping}'."); } public static bool ToStarting(ref ForwardedPortStatus status) { ForwardedPortStatus forwardedPortStatus = Interlocked.CompareExchange(ref status, Starting, Stopped); if (forwardedPortStatus == Starting || forwardedPortStatus == Started) { return false; } if (status == Starting) { return true; } throw new InvalidOperationException($"Forwarded port cannot transition from '{forwardedPortStatus}' to '{Starting}'."); } } public class HashInfo { public int KeySize { get; private set; } public bool IsEncryptThenMAC { get; private set; } public Func<byte[], HashAlgorithm> HashAlgorithm { get; private set; } public HashInfo(int keySize, Func<byte[], HashAlgorithm> hash, bool isEncryptThenMAC = false) { HashInfo hashInfo = this; KeySize = keySize; HashAlgorithm = (byte[] key) => hash(key.Take(hashInfo.KeySize / 8)); IsEncryptThenMAC = isEncryptThenMAC; } } internal interface IAuthenticationMethod { string[] AllowedAuthentications { get; } string Name { get; } AuthenticationResult Authenticate(ISession session); } public interface IBaseClient : IDisposable { ConnectionInfo ConnectionInfo { get; } bool IsConnected { get; } TimeSpan KeepAliveInterval { get; set; } event EventHandler<ExceptionEventArgs> ErrorOccurred; event EventHandler<HostKeyEventArgs> HostKeyReceived; event EventHandler<SshIdentificationEventArgs>? ServerIdentificationReceived; void Connect(); Task ConnectAsync(CancellationToken cancellationToken); void Disconnect(); void SendKeepAlive(); } internal interface IClientAuthentication { void Authenticate(IConnectionInfoInternal connectionInfo, ISession session); } internal interface IConnectionInfo { TimeSpan ChannelCloseTimeout { get; } IDictionary<string, RequestInfo> ChannelRequests { get; } Encoding Encoding { get; } string Host { get; } int Port { get; } ProxyTypes ProxyType { get; } string ProxyHost { get; } int ProxyPort { get; } string ProxyUsername { get; } string ProxyPassword { get; } int RetryAttempts { get; } TimeSpan Timeout { get; } event EventHandler<AuthenticationBannerEventArgs> AuthenticationBanner; } internal interface IConnectionInfoInternal : IConnectionInfo { IList<IAuthenticationMethod> AuthenticationMethods { get; } void UserAuthenticationBannerReceived(object sender, MessageEventArgs<BannerMessage> e); IAuthenticationMethod CreateNoneAuthenticationMethod(); } public interface IForwardedPort : IDisposable { event EventHandler Closing; } public interface IPrivateKeySource { IReadOnlyCollection<HostAlgorithm> HostKeyAlgorithms { get; } } public interface IRemotePathTransformation { string Transform(string path); } internal interface IServiceFactory { IClientAuthentication CreateClientAuthentication(); INetConfSession CreateNetConfSession(ISession session, int operationTimeout); ISession CreateSession(ConnectionInfo connectionInfo, ISocketFactory socketFactory); ISftpSession CreateSftpSession(ISession session, int operationTimeout, Encoding encoding, ISftpResponseFactory sftpMessageFactory); PipeStream CreatePipeStream(); IKeyExchange CreateKeyExchange(IDictionary<string, Func<IKeyExchange>> clientAlgorithms, string[] serverAlgorithms); ISftpFileReader CreateSftpFileReader(string fileName, ISftpSession sftpSession, uint bufferSize); ISftpResponseFactory CreateSftpResponseFactory(); ShellStream CreateShellStream(ISession session, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModeValues, int bufferSize); ShellStream CreateShellStreamNoTerminal(ISession session, int bufferSize); IRemotePathTransformation CreateRemotePathDoubleQuoteTransformation(); IConnector CreateConnector(IConnectionInfo connectionInfo, ISocketFactory socketFactory); IProtocolVersionExchange CreateProtocolVersionExchange(); ISocketFactory CreateSocketFactory(); } internal interface ISession : IDisposable { IConnectionInfo ConnectionInfo { get; } bool IsConnected { get; } SemaphoreSlim SessionSemaphore { get; } WaitHandle MessageListenerCompleted { get; } event EventHandler<MessageEventArgs<ChannelCloseMessage>> ChannelCloseReceived; event EventHandler<MessageEventArgs<ChannelDataMessage>> ChannelDataReceived; event EventHandler<MessageEventArgs<ChannelEofMessage>> ChannelEofReceived; event EventHandler<MessageEventArgs<ChannelExtendedDataMessage>> ChannelExtendedDataReceived; event EventHandler<MessageEventArgs<ChannelFailureMessage>> ChannelFailureReceived; event EventHandler<MessageEventArgs<ChannelOpenConfirmationMessage>> ChannelOpenConfirmationReceived; event EventHandler<MessageEventArgs<ChannelOpenFailureMessage>> ChannelOpenFailureReceived; event EventHandler<MessageEventArgs<ChannelOpenMessage>> ChannelOpenReceived; event EventHandler<MessageEventArgs<ChannelRequestMessage>> ChannelRequestReceived; event EventHandler<MessageEventArgs<ChannelSuccessMessage>> ChannelSuccessReceived; event EventHandler<MessageEventArgs<ChannelWindowAdjustMessage>> ChannelWindowAdjustReceived; event EventHandler<EventArgs> Disconnected; event EventHandler<ExceptionEventArgs> ErrorOccured; event EventHandler<SshIdentificationEventArgs> ServerIdentificationReceived; event EventHandler<HostKeyEventArgs> HostKeyReceived; event EventHandler<MessageEventArgs<RequestSuccessMessage>> RequestSuccessReceived; event EventHandler<MessageEventArgs<RequestFailureMessage>> RequestFailureReceived; event EventHandler<MessageEventArgs<BannerMessage>> UserAuthenticationBannerReceived; void Connect(); Task ConnectAsync(CancellationToken cancellationToken); IChannelSession CreateChannelSession(); IChannelDirectTcpip CreateChannelDirectTcpip(); IChannelForwardedTcpip CreateChannelForwardedTcpip(uint remoteChannelNumber, uint remoteWindowSize, uint remoteChannelDataPacketSize); void Disconnect(); void OnDisconnecting(); void RegisterMessage(string messageName); void SendMessage(Message message); bool TrySendMessage(Message message); void UnRegisterMessage(string messageName); void WaitOnHandle(WaitHandle waitHandle); void WaitOnHandle(WaitHandle waitHandle, TimeSpan timeout); WaitResult TryWait(WaitHandle waitHandle, TimeSpan timeout, out Exception exception); WaitResult TryWait(WaitHandle waitHandle, TimeSpan timeout); } 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); Task ChangeDirectoryAsync(string path, CancellationToken cancellationToken = default(CancellationToken)); void ChangePermissions(string path, short mode); SftpFileStream Create(string path); SftpFileStream Create(string path, int bufferSize); void CreateDirectory(string path); Task CreateDirectoryAsync(string path, CancellationToken cancellationToken = default(CancellationToken)); StreamWriter CreateText(string path); StreamWriter CreateText(string path, Encoding encoding); void Delete(string path); Task DeleteAsync(string path, CancellationToken cancellationToken = default(CancellationToken)); void DeleteDirectory(string path); Task DeleteDirectoryAsync(string path, CancellationToken cancellationToken = default(CancellationToken)); 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 SetLastAccessTime(string path, DateTime lastAccessTime); void SetLastAccessTimeUtc(string path, DateTime lastAccessTimeUtc); void SetLastWriteTime(string path, DateTime lastWriteTime); void SetLastWriteTimeUtc(string path, DateTime lastWriteTimeUtc); void SetAttributes(string path, SftpFileAttributes fileAttributes); 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 interface ISshClient : IBaseClient, IDisposable { IEnumerable<ForwardedPort> ForwardedPorts { get; } void AddForwardedPort(ForwardedPort port); void RemoveForwardedPort(ForwardedPort port); SshCommand CreateCommand(string commandText); SshCommand CreateCommand(string commandText, Encoding encoding); SshCommand RunCommand(string commandText); Shell CreateShell(Stream input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint>? terminalModes, int bufferSize); Shell CreateShell(Stream input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes); Shell CreateShell(Stream input, Stream output, Stream extendedOutput); 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); Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput, string terminalName, uint columns, uint rows, uint width, uint height, IDictionary<TerminalModes, uint> terminalModes); Shell CreateShell(Encoding encoding, string input, Stream output, Stream extendedOutput); Shell CreateShellNoTerminal(Stream input, Stream output, Stream extendedOutput, int bufferSize = -1); ShellStream CreateShellStream(string terminalName, uint columns, uint rows, uint width, uint height, int bufferSize); ShellStream CreateShellStream(string terminalName, uint columns, uint rows, uint width, uint height, int bufferSize, IDictionary<TerminalModes, uint>? terminalModeValues); ShellStream CreateShellStreamNoTerminal(int bufferSize = -1); } internal interface ISubsystemSession : IDisposable { int OperationTimeout { get; set; } bool IsOpen { get; } void Connect(); void Disconnect(); void WaitOnHandle(WaitHandle waitHandle, int millisecondsTimeout); bool WaitOne(WaitHandle waitHandle, int millisecondsTimeout); int WaitAny(WaitHandle waitHandleA, WaitHandle waitHandleB, int millisecondsTimeout); int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout); WaitHandle[] CreateWaitHandleArray(params WaitHandle[] waitHandles); WaitHandle[] CreateWaitHandleArray(WaitHandle waitHandle1, WaitHandle waitHandle2); } public class KeyboardInteractiveAuthenticationMethod : AuthenticationMethod, IDisposable { private readonly RequestMessageKeyboardInteractive _requestMessage; private AuthenticationResult _authenticationResult = AuthenticationResult.Failure; private Session _session; private EventWaitHandle _authenticationCompleted = new AutoResetEvent(initialState: false); private Exception _exception; private bool _isDisposed; public override string Name => _requestMessage.MethodName; public event EventHandler<AuthenticationPromptEventArgs> AuthenticationPrompt; public KeyboardInteractiveAuthenticationMethod(string username) : base(username) { _requestMessage = new RequestMessageKeyboardInteractive(ServiceName.Connection, username); } public override AuthenticationResult Authenticate(Session session) { _session = session; session.UserAuthenticationSuccessReceived += Session_UserAuthenticationSuccessReceived; session.UserAuthenticationFailureReceived += Session_UserAuthenticationFailureReceived; session.UserAuthenticationInformationRequestReceived += Session_UserAuthenticationInformationRequestReceived; session.RegisterMessage("SSH_MSG_USERAUTH_INFO_REQUEST"); try { session.SendMessage(_requestMessage); session.WaitOnHandle(_authenticationCompleted); } finally { session.UnRegisterMessage("SSH_MSG_USERAUTH_INFO_REQUEST"); session.UserAuthenticationSuccessReceived -= Session_UserAuthenticationSuccessReceived; session.UserAuthenticationFailureReceived -= Session_UserAuthenticationFailureReceived; session.UserAuthenticationInformationRequestReceived -= Session_UserAuthenticationInformationRequestReceived; } if (_exception != null) { ExceptionDispatchInfo.Capture(_exception).Throw(); } return _authenticationResult; } private void Session_UserAuthenticationSuccessReceived(object sender, MessageEventArgs<SuccessMessage> e) { _authenticationResult = AuthenticationResult.Success; _authenticationCompleted.Set(); } private void Session_UserAuthenticationFailureReceived(object sender, MessageEventArgs<FailureMessage> e) { if (e.Message.PartialSuccess) { _authenticationResult = AuthenticationResult.PartialSuccess; } else { _authenticationResult = AuthenticationResult.Failure; } base.AllowedAuthentications = e.Message.AllowedAuthentications; _authenticationCompleted.Set(); } private void Session_UserAuthenticationInformationRequestReceived(object sender, MessageEventArgs<InformationRequestMessage> e) { InformationRequestMessage message = e.Message; AuthenticationPromptEventArgs eventArgs = new AuthenticationPromptEventArgs(base.Username, message.Instruction, message.Language, message.Prompts); ThreadAbstraction.ExecuteThread(delegate { try { this.AuthenticationPrompt?.Invoke(this, eventArgs); InformationResponseMessage informationResponseMessage = new InformationResponseMessage(); foreach (AuthenticationPrompt item in eventArgs.Prompts.OrderBy((AuthenticationPrompt r) => r.Id)) { if (item.Response == null) { throw new SshAuthenticationException("AuthenticationPrompt.Response is null for prompt \"" + item.Request + "\". You can set this by subscribing to KeyboardInteractiveAuthenticationMethod.AuthenticationPrompt and inspecting the Prompts property of the event args."); } informationResponseMessage.Responses.Add(item.Response); } _session.SendMessage(informationResponseMessage); } catch (Exception exception) { _exception = exception; _authenticationCompleted.Set(); } }); } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (!_isDisposed && disposing) { EventWaitHandle authenticationCompleted = _authenticationCompleted; if (authenticationCompleted != null) { _authenticationCompleted = null; authenticationCompleted.Dispose(); } _isDisposed = true; } } } public class KeyboardInteractiveConnectionInfo : ConnectionInfo, IDisposable { private bool _isDisposed; public event EventHandler<AuthenticationPromptEventArgs> AuthenticationPrompt; public KeyboardInteractiveConnectionInfo(string host, string username) : this(host, 22, username, ProxyTypes.None, string.Empty, 0, string.Empty, string.Empty) { } public KeyboardInteractiveConnectionInfo(string host, int port, string username) : this(host, port, username, ProxyTypes.None, string.Empty, 0, string.Empty, string.Empty) { } public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort) : this(host, port, username, proxyType, proxyHost, proxyPort, string.Empty, string.Empty) { } public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername) : this(host, port, username, proxyType, proxyHost, proxyPort, proxyUsername, string.Empty) { } public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort) : this(host, 22, username, proxyType, proxyHost, proxyPort, string.Empty, string.Empty) { } public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername) : this(host, 22, username, proxyType, proxyHost, proxyPort, proxyUsername, string.Empty) { } public KeyboardInteractiveConnectionInfo(string host, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword) : this(host, 22, username, proxyType, proxyHost, proxyPort, proxyUsername, proxyPassword) { } public KeyboardInteractiveConnectionInfo(string host, int port, string username, ProxyTypes proxyType, string proxyHost, int proxyPort, string proxyUsername, string proxyPassword) : base(host, port, username, proxyType, proxyHost, proxyPort, proxyUsername, proxyPassword, new KeyboardInteractiveAuthenticationMethod(username)) { foreach (AuthenticationMethod authenticationMethod in base.AuthenticationMethods) { if (authenticationMethod is KeyboardInteractiveAuthenticationMethod keyboardInteractiveAuthenticationMethod) { keyboardInteractiveAuthenticationMethod.AuthenticationPrompt += AuthenticationMethod_AuthenticationPrompt; } } } private void AuthenticationMethod_AuthenticationPrompt(object sender, AuthenticationPromptEventArgs e) { this.AuthenticationPrompt?.Invoke(sender, e); } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (_isDisposed || !disposing) { return; } if (base.AuthenticationMethods != null) { foreach (AuthenticationMethod authenticationMethod in base.AuthenticationMethods) { if (authenticationMethod is IDisposable disposable) { disposable.Dispose(); } } } _isDisposed = true; } } public class MessageEventArgs<T> : EventArgs { public T Message { get; private set; } public MessageEventArgs(T message) { ThrowHelper.ThrowIfNull(message, "message"); Message = message; } } public class NetConfClient : BaseClient { private int _operationTimeout; private INetConfSession? _netConfSession; public TimeSpan OperationTimeout { get { return TimeSpan.FromMilliseconds(_operationTimeout); } set { _operationTimeout = value.AsTimeout("OperationTimeout"); } } internal INetConfSession? NetConfSession => _netConfSession; public XmlDocument ServerCapabilities { get { if (_netConfSession == null) { throw new SshConnectionException("Client not connected."); } return _netConfSession.ServerCapabilities; } } public XmlDocument ClientCapabilities { get { if (_netConfSession == null) { throw new SshConnectionException("Client not connected."); } return _netConfSession.ClientCapabilities; } } public bool AutomaticMessageIdHandling { get; set; } public NetConfClient(ConnectionInfo connectionInfo) : this(connectionInfo, ownsConnectionInfo: false) { } public NetConfClient(string host, int port, string username, string password) : this(new PasswordConnectionInfo(host, port, username, password), ownsConnectionInfo: true) { } public NetConfClient(string host, string username, string password) : this(host, 22, username, password) { } public NetConfClient(string host, int port, string username, params IPrivateKeySource[] keyFiles) : this(new PrivateKeyConnectionInfo(host, port, username, keyFiles), ownsConnectionInfo: true) { } public NetConfClient(string host, string username, params IPrivateKeySource[] keyFiles) : this(host, 22, username, keyFiles) { } private NetConfClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo) : this(connectionInfo, ownsConnectionInfo, new ServiceFactory()) { } internal NetConfClient(ConnectionInfo connectionInfo, bool ownsConnectionInfo, IServiceFactory serviceFactory) : base(connectionInfo, ownsConnectionInfo, serviceFactory) { _operationTimeout = -1; AutomaticMessageIdHandling = true; } public XmlDocument SendReceiveRpc(XmlDocument rpc) { if (_netConfSession == null) { throw new SshConnectionException("Client not connected."); } return _netConfSession.SendReceiveRpc(rpc, AutomaticMessageIdHandling); } public XmlDocument SendReceiveRpc(string xml) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(xml); return SendReceiveRpc(xmlDocument); } public XmlDocument SendCloseRpc() { if (_netConfSession == null) { throw new SshConnectionException("Client not connected."); } XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml("<?xml version=\"1.0\" encoding=\"UTF-8\"?><rpc message-id=\"6666\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\"><close-session/></rpc>"); return _netConfSession.SendReceiveRpc(xmlDocument, AutomaticMessageIdHandling); } protected override void OnConnected() { base.OnConnected(); _netConfSession = CreateAndConnectNetConfSession(); } protected override void OnDisconnecting() { base.OnDisconnecting(); _netConfSession?.Disconnect(); } protected override void Dispose(bool disposing) { base.Dispose(disposing); if (disposing && _netConfSession != null) { _netConfSession.Dispose(); _netConfSession = null; } } private INetConfSession CreateAndConnectNetConfSession() { INetConfSession netConfSession = base.ServiceFactory.CreateNetConfSession(base.Session, _operationTimeout); try { netConfSession.Connect(); return netConfSession; } catch { netConfSession.Dispose(); throw; } } } public class NoneAuthenticationMethod : AuthenticationMethod, IDisposable { private AuthenticationResult _authenticationResult = AuthenticationResult.Failure; private EventWaitHandle _authenticationCompleted = new AutoResetEvent(initialState: false); private bool _isDisposed; public override string Name => "none"; public NoneAuthenticationMethod(string username) : base(username) { } public override AuthenticationResult Authenticate(Session session) { ThrowHelper.ThrowIfNull(session, "session"); session.UserAuthenticationSuccessReceived += Session_UserAuthenticationSuccessReceived; session.UserAuthenticationFailureReceived += Session_UserAuthenticationFailureReceived; try { session.SendMessage(new RequestMessageNone(ServiceName.Connection, base.Username)); session.WaitOnHandle(_authenticationCompleted); } finally { session.UserAuthenticationSuccessReceived -= Session_UserAuthenticationSuccessReceived; session.UserAuthenticationFailureReceived -= Session_UserAuthenticationFailureReceived; } return _authenticationResult; } private void Session_UserAuthenticationSuccessReceived(object sender, MessageEventArgs<SuccessMessage> e) { _authenticationResult = AuthenticationResult.Success; _authenticationCompleted.Set(); } private void Session_UserAuthenticationFailureReceived(object sender, MessageEventArgs<FailureMessage> e) { if (e.Message.PartialSuccess) { _authenticationResult = AuthenticationResult.PartialSuccess; } else { _authenticationResult = AuthenticationResult.Failure; } base.AllowedAuthentications = e.Message.AllowedAuthentications; _authenticationCompleted.Set(); } public void Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (!_isDisposed && disposing) { EventWaitHandle authenticationCompleted = _authenticationCompleted; if (authenticationCompleted != null) { authenticationCompleted.Dispose(); _authenticationCompleted = null; } _isDisposed = true; } } } public class PasswordAuthenticationMethod : AuthenticationMethod, IDisposable { private readonly RequestMessagePassword _requestMessage; private readonly byte[] _password; private AuthenticationResult _authenticationResult = AuthenticationResult.Failure; private Session _session; private EventWaitHandle _authenticationCompleted = new AutoResetEvent(initialState: false); private Exception _exception; private bool _isDisposed; public override string Name => _requestMessage.MethodName; internal byte[] Password => _password; public event EventHandler<AuthenticationPasswordChangeEventArgs> PasswordExpired; public PasswordAuthenticationMethod(string username, string password) : this(username, Encoding.UTF8.GetBytes(password)) { } public PasswordAuthenticationMethod(string username, byte[] password) : base(username) { ThrowHelper.ThrowIfNull(password, "password"); _password = password; _requestMessage = new RequestMessagePassword(ServiceName.Connection, base.Username, _password); } public override AuthenticationResult Authenticate(Session session) { ThrowHelper.ThrowIfNull(session, "session"); _session = session; session.UserAuthenticationSuccessReceived += Session_UserAuthenticationSuccessReceived; session.UserAuthenticationFailureReceived += Session_UserAuthenticationFailureReceived; session.UserAuthenticationPasswordChangeRequiredReceived += Session_UserAuthenticationPasswordChangeRequiredReceived; try { session.RegisterMessage("SSH_MSG_USERAUTH_PASSWD_CHANGEREQ"); session.SendMessage(_requestMessage); session.WaitOnHandle(_authenticationCompleted); } finally { session.UnRegisterMessage("SSH_MSG_USERAUTH_PASSWD_CHANGEREQ"); session.UserAuthenticationSuccessReceived -= Session_UserAuthenticationSuccessReceived; session.UserAuthenticationFailur

Lethal Company

LethalSSH

Details

Categories

baer1.LethalSSH.dll

Renci.SshNet.dll

Categories

baer1.LethalSSH.dll

Renci.SshNet.dll

Categories