From ebc7e94aea2248dd23b94a2d6c94f55f8f85fee5 Mon Sep 17 00:00:00 2001 From: root Date: Sun, 3 Sep 2017 00:01:11 +0000 Subject: [PATCH] HTTP Completed --- checkmyip.py | 103 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 61 insertions(+), 42 deletions(-) diff --git a/checkmyip.py b/checkmyip.py index e7e636b..78f5343 100755 --- a/checkmyip.py +++ b/checkmyip.py @@ -11,6 +11,7 @@ version = "v1.0.0" +##### Import python2 native modules ##### import os import sys import time @@ -20,10 +21,11 @@ import paramiko import threading +##### Jinja formatting for logging queries ##### j2log = "Connection from: {{ ip }} ({{ port }}) ({{ proto }})" -#j2send = "\n\n\nYour IP Address is {{ ip }} ({{ port }})\n\n\n\n" - + +##### Jinja formatting for response queries ##### j2send = """{ @@ -32,24 +34,28 @@ j2send = """{ "family": "{{ family }}", "ip": "{{ ip }}", -"port": "{{ port }}" -}""" +"port": "{{ port }}", +"protocol": "{{ proto }}", +"version": "%s", +"website": "https://github.com/packetsar/checkmyip" +}""" % version +##### Handles all prnting to console and logging to the logfile ##### class log_management: def __init__(self): - self.logpath = "/etc/checkmyip/" - self.logfile = "/etc/checkmyip/checkmyip.log" - self._publish_methods() - self.can_log = True - try: + self.logpath = "/etc/checkmyip/" # Log file directory path + self.logfile = "/etc/checkmyip/checkmyip.log" # Log file full path + self._publish_methods() # Publish the console and log methods to glob + self.can_log = True # Variable used to check if we can log + try: # Try to configure the SSH log file, create dir if fail paramiko.util.log_to_file('/etc/checkmyip/ssh.log') except IOError: self._create_log_dir() - def _logger(self, data): + def _logger(self, data): # Logging method published to global as 'log' logdata = time.strftime("%Y-%m-%d %H:%M:%S") + ": " + data + "\n" if self.can_log: - try: + try: # Try to write to log, create log dir if fail f = open(self.logfile, 'a') f.write(logdata) f.close() @@ -67,14 +73,15 @@ class log_management: def _publish_methods(self): global log global console - log = self._logger - console = self._console - def _create_log_dir(self): + log = self._logger # Global method used to write to the log file + console = self._console # Global method used to write to the console + def _create_log_dir(self): # Create the directory for logging os.system('mkdir -p ' + self.logpath) self._console("Logpath (%s) created" % self.logpath) self.can_log = True +##### Creates a RSA key for use by paramiko ##### class rsa_key: data = """-----BEGIN RSA PRIVATE KEY----- MIICWgIBAAKBgQDTj1bqB4WmayWNPB+8jVSYpZYk80Ujvj680pOTh2bORBjbIAyz @@ -92,16 +99,13 @@ class rsa_key: nvuQES5C9BMHjF39LZiGH1iLQy7FgdHyoP+eodI7 -----END RSA PRIVATE KEY----- """ - def open(self): - pass - def close(self): - pass - def readlines(self): + def readlines(self): # For use by paramiko.RSAKey.from_private_key mthd return self.data.split("\n") - def __call__(self): + def __call__(self): # Recursive method uses own object as arg when called return paramiko.RSAKey.from_private_key(self) +##### Imports and modifies the ServerInterface module for use by paramiko ##### class ssh_server (paramiko.ServerInterface): def __init__(self): self.event = threading.Event() @@ -109,9 +113,9 @@ class ssh_server (paramiko.ServerInterface): if kind == 'session': return paramiko.OPEN_SUCCEEDED return paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED - def check_auth_none(self, username): + def check_auth_none(self, username): # Auth none method left wide open return paramiko.AUTH_SUCCESSFUL - def get_allowed_auths(self, username): + def get_allowed_auths(self, username): # Give no auth options return 'none' def check_channel_shell_request(self, channel): self.event.set() @@ -121,11 +125,13 @@ class ssh_server (paramiko.ServerInterface): return True +##### Method to merge Jinja templates ##### def j2format(j2tmp, valdict): template = jinja2.Template(j2tmp) return template.render(valdict) +##### Cleans IP addresses coming from socket library ##### def cleanip(addr): ip = addr[0] port = addr[1] @@ -137,47 +143,55 @@ def cleanip(addr): return (ip, port, family) # Return the uncleaned IP if not matched +##### TCP listener methods. Gets used once for each listening port ##### def listener(port, talker): listen_ip = '' listen_port = port - buffer_size = 100 # Normally 1024, but we want fast response + buffer_size = 1024 while True: - sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) + sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) # v6 family sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind((listen_ip, listen_port)) sock.listen(buffer_size) client, addr = sock.accept() - ip, port, family = cleanip(addr) - valdict = {"ip": ip, "port": port, "family": family} + ip, port, family = cleanip(addr) # Get all cleaned IP info + valdict = {"ip": ip, "port": port, "family": family} # Put in dict thread = threading.Thread(target=talker, args=(client, valdict)) - thread.start() + thread.start() # Start talker thread to listen to port +##### Telnet responder method. Is run in own thread for each telnet query ##### def telnet_talker(client, valdict): - valdict.update({"proto": "telnet"}) - log(j2format(j2log, valdict)) - client.send(j2format(j2send, valdict)) # echo - client.close() + valdict.update({"proto": "telnet"}) # Add the protocol to the value dict + log(j2format(j2log, valdict)) # Log the query to the console and logfile + client.send(j2format(j2send, valdict)) # Send the query response + client.close() # Close the channel +##### SSH responder method. Gets run in own thread for each SSH query ##### def ssh_talker(client, valdict): + def makefile(): # A hack to make Cisco SSH sessions work properly + chan.makefile('rU').readline().strip('\r\n') valdict.update({"proto": "ssh"}) log(j2format(j2log, valdict)) t = paramiko.Transport(client, gss_kex=True) t.set_gss_host(socket.getfqdn("")) t.load_server_moduli() - t.add_server_key(rsa_key()()) + t.add_server_key(rsa_key()()) # RSA key object nested call server = ssh_server() t.start_server(server=server) chan = t.accept(20) if chan: server.event.wait(10) - chan.send('%s' % j2format(j2send, valdict)) - chan.makefile('rU').readline().strip('\r\n') - chan.close() - client.close() + chan.send('%s' % j2format(j2send, valdict)) # Send the response + thread = threading.Thread(target=makefile) + thread.start() # Start hack in thread since it hangs indefinately + time.sleep(1) # Wait a second + chan.close() # And kill the SSH channel + client.close() # And kill the session +##### HTTP responder method. Gets run in own thread for each HTTP query ##### def http_talker(client, valdict): valdict.update({"proto": "http"}) log(j2format(j2log, valdict)) @@ -185,15 +199,17 @@ def http_talker(client, valdict): response_headers_raw = """HTTP/1.1 200 OK Content-Length: %s Content-Type: application/json; encoding=utf8 -Connection: close""" % str(len(response_body_raw)) +Connection: close""" % str(len(response_body_raw)) # Response with headers client.send(response_headers_raw + "\n\n" + response_body_raw) client.close() +##### Server startup method. Starts a listener thread for each TCP port ##### def start(): talkers = {22: ssh_talker, 23: telnet_talker, 80: http_talker} for talker in talkers: - thread = threading.Thread(target=listener, args=(talker, talkers[talker])) + thread = threading.Thread(target=listener, + args=(talker, talkers[talker])) thread.daemon = True thread.start() while True: @@ -203,10 +219,12 @@ def start(): quit() +##### Client class to be used to make API calls to CheckMyIP server ##### class CheckMyIP_Client: def __init__(self): self._json = __import__('json') # Import the JSON library self._socket = __import__('socket') # Import the socket library + self._raw_data = None # Initialize the _raw_data variable self._data = None # Initialize the _data variable self._af = "auto" # Set the IP address family type to "auto" self.server = "telnetmyip.com" # Set the default CheckMyIP server @@ -228,9 +246,10 @@ class CheckMyIP_Client: sock = self._socket.socket(self._socket.AF_INET, self._socket.SOCK_STREAM) sock.connect((self.server, 23)) - self._data = sock.recv(1024) # Recieve data from the buffer + self._raw_data = sock.recv(1024).decode() + self._data = self._json.loads(self._raw_data) # Recieve data from the buffer sock.close() # Close the socket - return self._json.loads(self._data) # Return the JSON data + return self._data # Return the JSON data def set_family(self, family): # Method to set the IP address family allowed = ["auto", "ipv4", "ipv6"] # Allowed input values if family in allowed: @@ -240,5 +259,5 @@ class CheckMyIP_Client: if __name__ == "__main__": - logging = log_management() - start() \ No newline at end of file + logging = log_management() # Instantiate log class + start() # Start the server \ No newline at end of file