staging.inyokaproject.org

def checkPort(port,ip_addr,timeout):
	if _debug == 1:
		print ("\n--> check port {0} on ip {1}\n".format(port,ip_addr))
	try:
		_chk_port = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		_chk_port.settimeout(timeout)
		_result = _chk_port.connect_ex((ip_addr, port))
		if _result == 0:
			_return = "Open"
		else:
			_return = "Closed"
		_chk_port.close()
	except KeyboardInterrupt:
		print ("You pressed Ctrl+C")
		sys.exit()
	except socket.gaierror:
		print ('Hostname could not be resolved. Exiting')
		sys.exit()
        except socket.timeout:
		_return = "timeout"
	except socket.error:
		print ("Couldn't connect to server")
		sys.exit()
	return _return

#!/usr/bin/env python3
# portscanner 
import socket, subprocess, sys, getopt
from datetime import datetime
# const
DEBUG = False
SHOW_ALL = False

def usage():
	print("portscanner.py")
	print("-" * 20)
	print("-h | --help			:  show this help")
	print("-n | --hostname=		:  define the hostname to be check")
	print("-s | --start_port=	   	:  define the start port")
	print("-e | --end_port=	      	:  define the end port")
	print("-a | --all-ports 		:  shows all (default is show only open ports)")
	print("-t | --timeout=			:  set the timeout for socket default is 3 seconds")
	print("-v | --verbose			:  set debug mode (set --all-ports)")

def get_ip_address(var_hostname):
	try:
		return socket.gethostbyname(var_hostname)
	except socket.error as err:
		print (str(err))
		sys.exit(4)

def check_port(var_port,var_ip,var_timeout):
	global DEBUG, SHOW_ALL
	if DEBUG == True:
		print ("\n--> check port {0} on ip {1}\n".format(var_port,var_ip))
	try:
		var_check_port = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		var_check_port.settimeout(int(var_timeout))
		result = var_check_port.connect_ex((var_ip,var_port))
		if result == 0:
			return_ = "open"
		elif result == 111:
			return_ = "closed"
		elif result == 11:
			return_ = "firewalled"
		var_check_port.close()
	except KeyboardInterrupt: 
		sys.exit(1)
	except socket.gaierror:
		print ('Hostname could not be resolved. Exiting')
		sys.exit(3)
	except socket.error:
		print ("Couldn't connect to server")
		sys.exit(2)
	return return_

def scan_port():
	try:
		opts, args = getopt.getopt(sys.argv[1:], "h:n:s:e:at:v", ["help", "hostname=", "start_port=", "end_port=", "all-ports", "timeout=", "verbose"])	
	except getopt.GetoptError as err:
		print (str(err))
		usage()
		sys.exit(2)
	global DEBUG, SHOW_ALL	
	# var
	remote_host = ""
	var_str_port = ""
	var_end_port = ""
	var_socket_timeout = 3
	for opt, arg in opts:
		if opt in ("-h","--help"):
			usage()
			sys.exit(0)
		elif opt in ("-n","--hostname"):
			remote_host = arg
		elif opt in ("-s","--start_port"):
			var_str_port = int(arg)
		elif opt in ("-e","--end_port"):
			var_end_port = int(arg)
		elif opt in ("-a","--all-ports"):
			SHOW_ALL = True
		elif opt in ("-t","--timeout"):
			var_socket_timeout = int(arg)
		elif opt in ("-v","--verbose"):
			DEBUG = True
	# clear screen
	subprocess.call('clear', shell=True)
	# is debug on ?
	if DEBUG == True:
		SHOW_ALL = True
	# need more input ?
	if not remote_host:
		remote_host = input("please enter hostname or ip address : ")
	remote_host_ip = get_ip_address(remote_host)
	if not var_str_port:
		var_str_port = int(input("startport  : "))
	if not var_end_port:
		var_end_port = int(input("endport  : "))
	if var_str_port < 1 or var_str_port > 65535 or var_end_port < 1 or var_end_port > 65535:
		print("The Portrange must between 1-65535")
		sys.exit(1)

	
	# Print Banner
	print ("-" * 90)
	print ("please wait, scanning remote host {0}".format(remote_host_ip))
	print ("-" * 90)
	print ("\n")
	t1=datetime.now()
	for lp_check_port in range(var_str_port,var_end_port + 1):
		chk_result = check_port(lp_check_port,remote_host_ip,var_socket_timeout)
		if SHOW_ALL == False and chk_result == "Open":
			print ("Port {0}:     {1}".format(lp_check_port,chk_result))
		elif SHOW_ALL == True:
			print ("Port {0}:     {1}".format(lp_check_port,chk_result))
	t2 = datetime.now()
	time_take = t2 - t1
	print ("\n")
	print ("-" * 90)
	print ("scanning completed in : {0}".format(time_take))

if __name__ == "__main__":
	scan_port()

#!/usr/bin/env python3
import argparse
import socket
import sys
from datetime import datetime

SOCKET_STATES = {
    0: "open",
    11: "firewalled",
    111: "closed",
}


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("hostname", metavar="HOSTNAME",
                        help="define the hostname to be checked")
    parser.add_argument("start_port", type=int, metavar="START_PORT",
                        help="define the start port")
    parser.add_argument("end_port", type=int, metavar="END_PORT",
                        help="define the end port")
    parser.add_argument("-a", "--all-ports", action="store_true",
                        help="shows all (default is show only open ports)")
    parser.add_argument("-t", "--timeout", type=int, default=3,
                        help=("set the TIMEOUT for socket operations "
                              "(default is 3 seconds)"))
    parser.add_argument("-v", "--verbose", action="store_true",
                        help="set debug mode (set --all-ports)")
    args = parser.parse_args()
    if 0 < args.start_port <= 65535 and 0 < args.end_port <= 65535:
        return args
    else:
        sys.exit("The Portrange must between 1-65535")

def get_ip_address(hostname):
    try:
        return socket.gethostbyname(hostname)
    except socket.error as err:
        print (str(err))
        sys.exit(4)

def check_port(ip, port):
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            result = s.connect_ex((ip, port))
            return SOCKET_STATES.get(result, result)
    except KeyboardInterrupt:
        sys.exit(1)
    except socket.gaierror:
        print ('Hostname could not be resolved. Exiting')
        sys.exit(3)
    except socket.error:
        print ("Couldn't connect to server")
        sys.exit(2)

def scan_ports(remote_host, start_port, end_port, debug=False, show_all=False):
    ip = get_ip_address(remote_host)

    # clear screen
    print(chr(27) + "[2J")
    # Print Banner
    print ("-" * 90)
    print ("please wait, scanning remote host {0}".format(ip))
    print ("-" * 90)
    print ("\n")

    t_start = datetime.now()
    for port in range(start_port, end_port + 1):
        if debug:
            print ("\n--> check port {0} on ip {1}\n".format(port, ip))
        port_state = check_port(ip, port)
        if port_state == "open" or show_all or debug:
            print ("Port {0: >5}: {1: >10}".format(port, port_state))
    duration = datetime.now() - t_start

    print ("\n")
    print ("-" * 90)
    print ("scanning completed in : {0}".format(duration))

if __name__ == '__main__':
    args = parse_args()
    socket.setdefaulttimeout(args.timeout)
    scan_ports(remote_host=args.hostname,
               start_port=args.start_port, end_port=args.end_port,
               debug=args.verbose, show_all=args.all_ports)

 print(chr(27) + "[2J")

return SOCKET_STATES.get(result, result)

def write_log(logfile,entry,state):
	logging.basicConfig(format='%(asctime)s | %(levelname)s | %(message)s',filename=logfile,filemode='w',level=logging.DEBUG)
	print("Logfile {0} State {1} Eintrag {2}".format(logfile,state,entry))
	if state == "info":
		logging.info(str(entry))
	elif state == "warning":
		logging.warning(str(entry))
	elif state == "critical":
		logging.critical(str(entry))

import logging

def write_log(msg, state):
    if state in ["info", "warning", "critical"]:
        log_method = getattr(logging, state)
        log_method(msg)

if __name__ == '__main__':
    write_log(msg="This is a warning", state="warning")

LOG_METHODS = {
"info": logging.info,
"warning": logging.warning,
"critical": logging.critical,
}

def write_log(msg, state):
    try:
        log_method = LOG_METHODS.get(state)
    except KeyError:
        logging.exception("invalid logging state %s", state)
    else:
        log_method(msg)

SOCKET_STATES = {
    0: 'open',
    errno.EAGAIN: 'firewalled',
    errno.ECONNREFUSED: 'closed',
}

EAI_ERROR_CODES = set(
    getattr(socket, name) for name in dir(socket) if name.startswith('EAI_')
)

def check_port(ip, port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        result = sock.connect_ex((ip, port))
        if result in EAI_ERROR_CODES:
            print('Hostname could not be resolved. Exiting')
            sys.exit(3)
        return SOCKET_STATES.get(result, result)