sshscan.py

import socket
import paramiko
import multiprocessing
import logging
import sys
import netaddr
import json
from datetime import datetime

# logging.basicConfig(
#   level=logging.INFO,
#   format=u'[%(levelname)s/%(processName)s] %(message)s',
# )

def err_handler(err):
  logger = multiprocessing.get_logger()
  logger.error("%s:: %s", err.__class__.__name__, err)
  # print "--- %s (%s, %s) ---" % (err.__class__.__name__, dest, destport, )
  # print "GE: Seargent Wisdom?"
  # print "SW: Sir! Yes, Sir!"
  # print "GE: This is `General Exception`! How are you doing?"
  # print "SW: %s" % (err, )
  # print "--- (%s, %s) ---" % (dest, destport, )


def check_auth_types(remote):
  logger = multiprocessing.get_logger()
  dest, destport = remote[0], remote[1]
  begin_of_action = datetime.now()
  remote = {
                  u'current_process_name': multiprocessing.current_process().name,
                  u'begin_of_action': begin_of_action.isoformat(),
                  u'dest': dest,
                  u'destport': destport,
                  u'allowed_types': [],
                  u'errors': [],
                  }
  try:
    s = socket.create_connection((dest, destport), timeout=2)
    t = paramiko.Transport(s)
    t.start_client()
    remote[u'peername'] = t.getpeername()
    remote[u'remote_version'] = t.remote_version
    t.auth_none('dummy-user (mmarcher)')
    t.close()
    e = paramiko.BadAuthenticationType(explanation='Something unexpected happened!', types=['none'])
    raise e
  except socket.error as err:
    err_handler(err)
    remote['errors'].append(str(err))
  except paramiko.BadAuthenticationType as err:
    remote[u'allowed_types'] = err.allowed_types
  except paramiko.SSHException as err:
    err_handler(err)
    remote['errors'].append(str(err))
  except paramiko.AuthenticationException as err:
    err_handler(err)
    remote['errors'].append(str(err))
  except Exception as err:
    err_handler(err)
    remote['errors'].append(str(err))
  finally:
    end_of_action = datetime.now()
    remote[u'end_of_action'] = end_of_action.isoformat()
    remote[u'duration'] = str(end_of_action - begin_of_action)
    remote
    return remote

def pprint_result(elem):
  logger = multiprocessing.get_logger()
  # pprint(elem)
  print json.dumps(elem, separators=(',',':'))

def run(it, poolsize=None):
  logger = multiprocessing.get_logger()
  if not poolsize:
    try:
      poolsize = multiprocessing.cpu_count()
    except Exception:
      poolsize = 2
  pool = multiprocessing.Pool(poolsize, maxtasksperchild=1)

  result = pool.imap_unordered(check_auth_types, it)
  for elem in result:
    pprint_result(elem)

def read_infile(infile):
  """Reads an fd line by line and returns an IPSet.
  """
  logger = multiprocessing.get_logger()
  s = netaddr.IPSet()
  for line in infile:
    line = line.strip()
    try:
      i = netaddr.IPNetwork(line)
      s.add(i)
    except Exception as err:
      logger.error(err)
  logger.info(s)
  return s


if __name__ == u'__main__':
  logger = multiprocessing.log_to_stderr()
  logger.setLevel(logging.INFO)

  from pprint import pprint
  import argparse
  parser = argparse.ArgumentParser()
  parser.add_argument("--num-cpus", type=int, help="Number of CPUs. Sets the maximum number of parallel tasks.")
  parser.add_argument("--infile", type=argparse.FileType('r'), help="Input file to read from (Default: stdin).")
  parser.set_defaults(infile='-')
  parser.add_argument("--port", type=int, help="Which port shall be scanned! (If you can guess the default you are ueber!)")
  parser.set_defaults(port=22)

  args = parser.parse_args()
  remotes = [(str(remote), args.port) for remote in read_infile(args.infile)]
  run(remotes, args.num_cpus)

# vim: set ts=2 sts=2 fenc=utf-8 expandtab: