Merge pull request #28 from zeroday0619/logging-system

[Critical] Implemented a custom logger and fixed some invalid code implementations and fixed some misspellings.

.gitignore

@@ -1,5 +1,6 @@
 certs/
 savedfiles/
+logs/
 settings.ini
 .env
 *.crt
@@ -174,4 +175,4 @@ poetry.toml
 .ruff_cache/
 
 # LSP config files
-pyrightconfig.json
+pyrightconfig.json

base.py

@@ -5,18 +5,25 @@
 #
 # Caterpillar Proxy - The simple web debugging proxy (formerly, php-httpproxy)
 # Namyheon Go (Catswords Research) <gnh1201@gmail.com>
+# Euiseo Cha (Wonkwang University) <zeroday0619_dev@outlook.com>
 # https://github.com/gnh1201/caterpillar
 # Created at: 2024-05-20
 # Updated at: 2024-07-09
 #
 
+import logging
 import hashlib
 import json
+import os
 import re
 import importlib
 
+from datetime import datetime, timezone
+from typing import Union, List
+
 client_encoding = 'utf-8'
 
+
 def extract_credentials(url):
     pattern = re.compile(r'(?P<scheme>\w+://)?(?P<username>[^:/]+):(?P<password>[^@]+)@(?P<url>.+)')
     match = pattern.match(url)
@@ -29,10 +36,12 @@ def extract_credentials(url):
     else:
         return None, None, url
 
+
 def jsonrpc2_create_id(data):
     return hashlib.sha1(json.dumps(data).encode(client_encoding)).hexdigest()
 
-def jsonrpc2_encode(method, params = None):
+
+def jsonrpc2_encode(method, params=None):
     data = {
         "jsonrpc": "2.0",
         "method": method,
@@ -42,7 +51,8 @@ def jsonrpc2_encode(method, params = None):
     data['id'] = id
     return (id, json.dumps(data))
 
-def jsonrpc2_result_encode(result, id = ''):
+
+def jsonrpc2_result_encode(result, id=''):
     data = {
         "jsonrpc": "2.0",
         "result": result,
@@ -50,7 +60,8 @@ def jsonrpc2_result_encode(result, id = ''):
     }
     return json.dumps(data)
 
-def jsonrpc2_error_encode(error, id = ''):
+
+def jsonrpc2_error_encode(error, id=''):
     data = {
         "jsonrpc": "2.0",
         "error": error,
@@ -58,6 +69,7 @@ def jsonrpc2_error_encode(error, id = ''):
     }
     return json.dumps(data)
 
+
 class Extension():
     extensions = []
     protocols = []
@@ -118,14 +130,14 @@ class Extension():
         return None
 
     @classmethod
-    def send_accept(cls, conn, method, success = True):
+    def send_accept(cls, conn, method, success=True):
         if 'tcp' in cls.protocols:
             _, message = jsonrpc2_encode(f"{method}_accept", {
                 "success": success
             })
             conn.send(message.encode(client_encoding))
 
-        print (f"Accepted request with {cls.protocols[0]} protocol")
+        print(f"Accepted request with {cls.protocols[0]} protocol")
 
     @classmethod
     def readall(cls, conn):
@@ -141,7 +153,7 @@ class Extension():
                     pass
 
             return data
-        
+
         elif 'http' in cls.protocols:
             # empty binary when an file not exists
             if 'file' not in conn.request.files:
@@ -150,7 +162,7 @@ class Extension():
             # read an uploaded file with binary mode
             file = conn.request.files['file']
             return file.read()
-    
+
     def __init__(self):
         self.type = None
         self.method = None
@@ -160,8 +172,35 @@ class Extension():
     def test(self, filtered, data, webserver, port, scheme, method, url):
         raise NotImplementedError
 
-    def dispatch(self, type, id, params, method = None, conn = None):
+    def dispatch(self, type, id, params, method=None, conn=None):
         raise NotImplementedError
 
     def connect(self, conn, data, webserver, port, scheme, method, url):
         raise NotImplementedError
+
+
+class Logger(logging.Logger):
+    def __init__(self, name: str, level: int = logging.NOTSET):
+        super().__init__(name, level)
+        self.formatter = logging.Formatter('[%(asctime)s] %(levelname)s %(module)s: %(message)s')
+
+        if not os.path.isdir("logs"):
+            os.mkdir("logs")
+        stream_handler = logging.StreamHandler()
+        file_handler = logging.FileHandler('logs/' + name + "-" + self._generate_timestamp() + '.log')
+
+        self._set_formatters([stream_handler, file_handler])
+        self._add_handlers([stream_handler, file_handler])
+
+    @staticmethod
+    def _generate_timestamp():
+        date = datetime.now(tz=timezone.utc).strftime('%Y-%m-%d')
+        return date
+
+    def _set_formatters(self, handlers: List[Union[logging.StreamHandler, logging.FileHandler]]):
+        for handler in handlers:
+            handler.setFormatter(self.formatter)
+
+    def _add_handlers(self, handlers: List[Union[logging.StreamHandler, logging.FileHandler]]):
+        for handler in handlers:
+            self.addHandler(handler)

plugins/container.py

@@ -12,7 +12,10 @@
 
 import docker
 
-from base import Extension
+from base import Extension, Logger
+
+logger = Logger("Container")
+
 
 class Container(Extension):
     def __init__(self):
@@ -24,7 +27,7 @@ class Container(Extension):
         self.client = docker.from_env()
 
     def dispatch(self, type, id, params, conn):
-        print ("[*] Greeting! dispatch")
+        logger.info("[*] Greeting! dispatch")
         conn.send(b'Greeting! dispatch')
 
     def container_run(self, type, id, params, conn):
@@ -35,7 +38,7 @@ class Container(Extension):
         environment = params['environment']
         volumes = params['volumes']
 
-        container = client.containers.run(
+        container = self.client.containers.run(
             image,
             devices=devices,
             name=name,
@@ -45,13 +48,13 @@ class Container(Extension):
         )
         container.logs()
 
-        print ("[*] Running...")
+        logger.info("[*] Running...")
 
     def container_stop(self, type, id, params, conn):
         name = params['name']
 
-        container = client.containers.get(name)
+        container = self.client.containers.get(name)
         container.stop()
 
-        print ("[*] Stopped")
+        logger.info("[*] Stopped")
 

plugins/fediverse.py

@@ -10,7 +10,8 @@
 # Created in: 2022-10-06
 # Updated in: 2024-07-06
 #
-
+import base64
+import hashlib
 import io
 import re
 import requests
@@ -19,7 +20,9 @@ import os.path
 from decouple import config
 from PIL import Image
 
-from base import Extension
+from base import Extension, Logger
+
+logger = Logger(name="fediverse")
 
 try:
     client_encoding = config('CLIENT_ENCODING', default='utf-8')
@@ -28,7 +31,7 @@ try:
     dictionary_file = config('DICTIONARY_FILE', default='words_alpha.txt')    # https://github.com/dwyl/english-words
     librey_apiurl = config('LIBREY_APIURL', default='https://search.catswords.net')    # https://github.com/Ahwxorg/librey
 except Exception as e:
-    print ("[*] Invaild configration: %s" % (str(e)))
+    logger.error("[*] Invalid configuration", exc_info=e)
 
 class Fediverse(Extension):
     def __init__(self):
@@ -41,7 +44,7 @@ class Fediverse(Extension):
             with open(dictionary_file, "r") as file:
                 words = file.readlines()
                 self.known_words = [word.strip() for word in words if len(word.strip()) > 3]
-                print ("[*] Data loaded to use KnownWords4 strategy")
+                logger.info("[*] Data loaded to use KnownWords4 strategy")
 
     def test(self, filtered, data, webserver, port, scheme, method, url):
         # prevent cache confusing
@@ -63,11 +66,11 @@ class Fediverse(Extension):
         pattern = r'\b(?:(?<=\/@)|(?<=acct:))([a-zA-Z0-9]{10})\b'
         matches = list(set(re.findall(pattern, text)))
         if len(matches) > 0:
-            print ("[*] Found ID: %s" % (', '.join(matches)))
+            logger.info("[*] Found ID: %s" % (', '.join(matches)))
             try:
                 filtered = not all(map(self.pwnedpasswords_test, matches))
             except Exception as e:
-                print ("[*] K-Anonymity strategy not working! %s" % (str(e)))
+                logger.error("[*] K-Anonymity strategy not working!", exc_info=e)
                 filtered = True
 
         # feedback
@@ -131,20 +134,20 @@ class Fediverse(Extension):
                     if filtered:
                         break
 
-                    print ("[*] downloading... %s" % (url))
+                    logger.info("[*] downloading... %s" % (url))
                     encoded_image = webp_to_png_base64(url)
-                    print ("[*] downloaded.")
+                    logger.info("[*] downloaded.")
                     if encoded_image:
-                        print ("[*] solving...")
+                        logger.info("[*] solving...")
                         try:
-                            solved = truecaptcha_solve(encoded_image)
+                            solved = self.truecaptcha_solve(encoded_image)
                             if solved:
-                                print ("[*] solved: %s" % (solved))
+                                logger.info("[*] solved: %s" % (solved))
                                 filtered = filtered or (solved.lower() in ['ctkpaarr', 'spam'])
                             else:
-                                print ("[*] not solved")
+                                logger.info("[*] not solved")
                         except Exception as e:
-                            print ("[*] Not CAPTCHA strategy not working! %s" % (str(e)))
+                            logger.error("[*] Not CAPTCHA strategy not working!", exc_info=e)
 
         return filtered
 

plugins/wayback.py

@@ -13,12 +13,14 @@
 import requests
 from decouple import config
 
-from base import Extension
+from base import Extension, Logger
+
+logger = Logger(name="wayback")
 
 try:
     client_encoding = config('CLIENT_ENCODING')
 except Exception as e:
-    print ("[*] Invaild configration: %s" % (str(e)))
+    logger.error("[*] Invalid configuration", exc_info=e)
 
 def get_cached_page_from_google(url):
     status_code, text = (0, '')

server.py

@@ -32,9 +32,11 @@ from requests.auth import HTTPBasicAuth
 from urllib.parse import urlparse
 from decouple import config
 
-from base import Extension, extract_credentials, jsonrpc2_create_id, jsonrpc2_encode, jsonrpc2_result_encode
+from base import Extension, extract_credentials, jsonrpc2_create_id, jsonrpc2_encode, jsonrpc2_result_encode, Logger
 
-# initalization
+logger = Logger(name="server")
+
+# initialization
 try:
     listening_port = config('PORT', default=5555, cast=int)
     _username, _password, server_url = extract_credentials(config('SERVER_URL', default=''))
@@ -49,11 +51,11 @@ try:
     proxy_pass = config('PROXY_PASS', default='')
     use_extensions = config('USE_EXTENSIONS', default='')
 except KeyboardInterrupt:
-    print("\n[*] User has requested an interrupt")
-    print("[*] Application Exiting.....")
+    logger.warning("[*] User has requested an interrupt")
+    logger.warning("[*] Application Exiting.....")
     sys.exit()
 except Exception as e:
-    print("[*] Failed to initialize:", str(e))
+    logger.error("[*] Failed to initialize:", exc_info=e)
 
 parser = argparse.ArgumentParser()
 parser.add_argument('--max_conn', help="Maximum allowed connections", default=255, type=int)
@@ -74,6 +76,7 @@ auth = None
 if _username:
     auth = HTTPBasicAuth(_username, _password)
 
+
 def parse_first_data(data):
     parsed_data = (b'', b'', b'', b'', b'')
 
@@ -82,12 +85,12 @@ def parse_first_data(data):
 
         method, url = first_line.split()[0:2]
 
-        http_pos = url.find(b'://') #Finding the position of ://
+        http_pos = url.find(b'://')  #Finding the position of ://
         scheme = b'http'  # check http/https or other protocol
         if http_pos == -1:
             temp = url
         else:
-            temp = url[(http_pos+3):]
+            temp = url[(http_pos + 3):]
             scheme = url[0:http_pos]
 
         port_pos = temp.find(b':')
@@ -101,17 +104,18 @@ def parse_first_data(data):
             port = 80
             webserver = temp[:webserver_pos]
         else:
-            port = int((temp[(port_pos+1):])[:webserver_pos-port_pos-1])
+            port = int((temp[(port_pos + 1):])[:webserver_pos - port_pos - 1])
             webserver = temp[:port_pos]
             if port == 443:
                 scheme = b'https'
 
         parsed_data = (webserver, port, scheme, method, url)
     except Exception as e:
-        print("[*] Exception on parsing the header. Cause: %s" % (str(e)))
+        logger.error("[*] Exception on parsing the header", exc_info=e)
 
     return parsed_data
 
+
 def conn_string(conn, data, addr):
     # JSON-RPC 2.0 request
     def process_jsonrpc2(data):
@@ -134,35 +138,37 @@ def conn_string(conn, data, addr):
     if path == "/proxy-cgi/jsonrpc2":
         conn.send(b'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n')
         pos = data.find(b'\r\n\r\n')
-        if pos > -1 and process_jsonrpc2(data[pos+4:]):
-            conn.close()   # will be close by the server
+        if pos > -1 and process_jsonrpc2(data[pos + 4:]):
+            conn.close()  # will be close by the server
             return
 
     # if it is reverse proxy
     if local_domain != '':
         localserver = local_domain.encode(client_encoding)
         if webserver == localserver or data.find(b'\nHost: ' + localserver) > -1:
-            print ("[*] Detected the reverse proxy request: %s" % (local_domain))
+            logger.info("[*] Detected the reverse proxy request: %s" % local_domain)
             scheme, _webserver, _port = proxy_pass.encode(client_encoding).split(b':')
             webserver = _webserver[2:]
             port = int(_port.decode(client_encoding))
 
     proxy_server(webserver, port, scheme, method, url, conn, addr, data)
 
+
 def jsonrpc2_server(conn, id, method, params):
     if method == "relay_accept":
         accepted_relay[id] = conn
         connection_speed = params['connection_speed']
-        print ("[*] connection speed: %s miliseconds" % (str(connection_speed)))
+        logger.info("[*] connection speed: %s milliseconds" % (str(connection_speed)))
         while conn.fileno() > -1:
             time.sleep(1)
         del accepted_relay[id]
-        print ("[*] relay destroyed: %s" % (id))
+        logger.info("[*] relay destroyed: %s" % id)
     else:
         Extension.dispatch_rpcmethod(method, "call", id, params, conn)
 
     #return in conn_string()
 
+
 def proxy_connect(webserver, conn):
     hostname = webserver.decode(client_encoding)
     certpath = "%s/%s.crt" % (certdir.rstrip('/'), hostname)
@@ -178,10 +184,12 @@ def proxy_connect(webserver, conn):
         if not os.path.isfile(certpath):
             epoch = "%d" % (time.time() * 1000)
             p1 = Popen([openssl_binpath, "req", "-new", "-key", certkey, "-subj", "/CN=%s" % hostname], stdout=PIPE)
-            p2 = Popen([openssl_binpath, "x509", "-req", "-days", "3650", "-CA", cacert, "-CAkey", cakey, "-set_serial", epoch, "-out", certpath], stdin=p1.stdout, stderr=PIPE)
+            p2 = Popen(
+                [openssl_binpath, "x509", "-req", "-days", "3650", "-CA", cacert, "-CAkey", cakey, "-set_serial", epoch,
+                 "-out", certpath], stdin=p1.stdout, stderr=PIPE)
             p2.communicate()
     except Exception as e:
-        print("[*] Skipped generating the certificate. Cause: %s" % (str(e)))
+        logger.error("[*] Skipped generating the certificate.", exc_info=e)
 
     # https://stackoverflow.com/questions/11255530/python-simple-ssl-socket-server
     # https://docs.python.org/3/library/ssl.html
@@ -194,19 +202,21 @@ def proxy_connect(webserver, conn):
 
     return (conn, data)
 
+
 def proxy_check_filtered(data, webserver, port, scheme, method, url):
     filtered = False
 
     filters = Extension.get_filters()
-    print ("[*] Checking data with %s filters..." % (str(len(filters))))
+    logger.info("[*] Checking data with %s filters..." % (str(len(filters))))
     for f in filters:
         filtered = f.test(filtered, data, webserver, port, scheme, method, url)
 
     return filtered
 
+
 def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
     try:
-        print("[*] Started the request. %s" % (str(addr[0])))
+        logger.info("[*] Started the request. %s" % (str(addr[0])))
 
         # SSL negotiation
         is_ssl = scheme in [b'https', b'tls', b'ssl']
@@ -214,18 +224,19 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
             while True:
                 try:
                     conn, data = proxy_connect(webserver, conn)
-                    break   # success
+                    break  # success
                 #except OSError as e:
                 #    print ("[*] Retrying SSL negotiation... (%s:%s) %s" % (webserver.decode(client_encoding), str(port), str(e)))
                 except Exception as e:
-                    raise Exception("SSL negotiation failed. (%s:%s) %s" % (webserver.decode(client_encoding), str(port), str(e)))
+                    raise Exception(
+                        "SSL negotiation failed. (%s:%s) %s" % (webserver.decode(client_encoding), str(port), str(e)))
 
         # override data
         if is_ssl:
             _, _, _, method, url = parse_first_data(data)
 
         # https://stackoverflow.com/questions/44343739/python-sockets-ssl-eof-occurred-in-violation-of-protocol
-        def sock_close(sock, is_ssl = False):
+        def sock_close(sock, is_ssl=False):
             #if is_ssl:
             #    sock = sock.unwrap()
             #sock.shutdown(socket.SHUT_RDWR)
@@ -254,8 +265,8 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                         sock_close(sock, is_ssl)
                         raise Exception("Filtered request")
                     sock.send(chunk)
-                    if len(buffered) > buffer_size*2:
-                        buffered = buffered[-buffer_size*2:]
+                    if len(buffered) > buffer_size * 2:
+                        buffered = buffered[-buffer_size * 2:]
                 except:
                     break
 
@@ -293,13 +304,13 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                     add_filtered_host(webserver.decode(client_encoding), '127.0.0.1')
                     raise Exception("Filtered response")
                 conn.send(chunk)
-                if len(buffered) > buffer_size*2:
-                    buffered = buffered[-buffer_size*2:]
+                if len(buffered) > buffer_size * 2:
+                    buffered = buffered[-buffer_size * 2:]
                 i += 1
 
             # when blocked
             if is_http_403:
-                print ("[*] Blocked the request by remote server: %s" % (webserver.decode(client_encoding)))
+                logger.warning("[*] Blocked the request by remote server: %s" % (webserver.decode(client_encoding)))
 
                 def bypass_callback(response, *args, **kwargs):
                     if response.status_code != 200:
@@ -319,15 +330,16 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                         conn.send(chunk)
 
                 if is_ssl and method == b'GET':
-                    print ("[*] Trying to bypass blocked request...")
-                    remote_url = "%s://%s%s" % (scheme.decode(client_encoding), webserver.decode(client_encoding), url.decode(client_encoding))
+                    logger.info("[*] Trying to bypass blocked request...")
+                    remote_url = "%s://%s%s" % (
+                    scheme.decode(client_encoding), webserver.decode(client_encoding), url.decode(client_encoding))
                     requests.get(remote_url, stream=True, verify=False, hooks={'response': bypass_callback})
                 else:
                     conn.sendall(b"HTTP/1.1 403 Forbidden\r\n\r\n{\"status\":403}")
 
             sock_close(sock, is_ssl)
 
-            print("[*] Received %s chunks. (%s bytes per chunk)" % (str(i), str(buffer_size)))
+            logger.info("[*] Received %s chunks. (%s bytes per chunk)" % (str(i), str(buffer_size)))
 
         # stateful mode
         elif server_connection_type == "stateful":
@@ -348,15 +360,16 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
             }
 
             # get client address
-            print ("[*] resolving the client address...")
+            logger.info("[*] resolving the client address...")
             while len(resolved_address_list) == 0:
                 try:
                     _, query_data = jsonrpc2_encode('get_client_address')
-                    query = requests.post(server_url, headers=proxy_data['headers'], data=query_data, timeout=1, auth=auth)
+                    query = requests.post(server_url, headers=proxy_data['headers'], data=query_data, timeout=1,
+                                          auth=auth)
                     if query.status_code == 200:
                         result = query.json()['result']
                         resolved_address_list.append(result['data'])
-                    print ("[*] resolved IP: %s" % (result['data']))
+                    logger.info("[*] resolved IP: %s" % (result['data']))
                 except requests.exceptions.ReadTimeout as e:
                     pass
             proxy_data['data']['client_address'] = resolved_address_list[0]
@@ -365,19 +378,22 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
             def relay_connect(id, raw_data, proxy_data):
                 try:
                     # The tunnel connect forever until the client destroy it
-                    relay = requests.post(server_url, headers=proxy_data['headers'], data=raw_data, stream=True, timeout=None, auth=auth)
+                    relay = requests.post(server_url, headers=proxy_data['headers'], data=raw_data, stream=True,
+                                          timeout=None, auth=auth)
                     for chunk in relay.iter_content(chunk_size=buffer_size):
                         jsondata = json.loads(chunk.decode(client_encoding, errors='ignore'))
                         if jsondata['jsonrpc'] == "2.0" and ("error" in jsondata):
                             e = jsondata['error']
-                            print ("[*] Error received from the relay server: (%s) %s" % (str(e['code']), str(e['message'])))
+                            logger.error("[*] Error received from the relay server: (%s) %s" % (
+                            str(e['code']), str(e['message'])))
                 except requests.exceptions.ReadTimeout as e:
                     pass
+
             id, raw_data = jsonrpc2_encode('relay_connect', proxy_data['data'])
             start_new_thread(relay_connect, (id, raw_data, proxy_data))
 
             # wait for the relay
-            print ("[*] waiting for the relay... %s" % (id))
+            logger.info("[*] waiting for the relay... %s" % id)
             max_reties = 30
             t = 0
             while t < max_reties and not id in accepted_relay:
@@ -385,11 +401,11 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                 t += 1
             if t < max_reties:
                 sock = accepted_relay[id]
-                print ("[*] connected the relay. %s" % (id))
+                logger.info("[*] connected the relay. %s" % id)
                 sendall(sock, conn, data)
             else:
                 resolved_address_list.remove(resolved_address_list[0])
-                print ("[*] the relay is gone. %s" % (id))
+                logger.info("[*] the relay is gone. %s" % id)
                 sock_close(sock, is_ssl)
                 return
 
@@ -406,13 +422,13 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                     add_filtered_host(webserver.decode(client_encoding), '127.0.0.1')
                     raise Exception("Filtered response")
                 conn.send(chunk)
-                if len(buffered) > buffer_size*2:
-                    buffered = buffered[-buffer_size*2:]
+                if len(buffered) > buffer_size * 2:
+                    buffered = buffered[-buffer_size * 2:]
                 i += 1
 
             sock_close(sock, is_ssl)
 
-            print("[*] Received %s chunks. (%s bytes per chunk)" % (str(i), str(buffer_size)))
+            logger.info("[*] Received %s chunks. (%s bytes per chunk)" % (str(i), str(buffer_size)))
 
         # stateless mode
         elif server_connection_type == "stateless":
@@ -435,7 +451,7 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
             }
             _, raw_data = jsonrpc2_encode('relay_request', proxy_data['data'])
 
-            print("[*] Sending %s bytes..." % (str(len(raw_data))))
+            logger.info("[*] Sending %s bytes..." % (str(len(raw_data))))
 
             i = 0
             relay = requests.post(server_url, headers=proxy_data['headers'], data=raw_data, stream=True, auth=auth)
@@ -446,11 +462,11 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                     add_filtered_host(webserver.decode(client_encoding), '127.0.0.1')
                     raise Exception("Filtered response")
                 conn.send(chunk)
-                if len(buffered) > buffer_size*2:
-                    buffered = buffered[-buffer_size*2:]
+                if len(buffered) > buffer_size * 2:
+                    buffered = buffered[-buffer_size * 2:]
                 i += 1
 
-            print("[*] Received %s chunks. (%s bytes per chunk)" % (str(i), str(buffer_size)))
+            logger.info("[*] Received %s chunks. (%s bytes per chunk)" % (str(i), str(buffer_size)))
 
         # nothing at all
         else:
@@ -460,14 +476,15 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
             else:
                 raise Exception("Unsupported connection type")
 
-        print("[*] Request and received. Done. %s" % (str(addr[0])))
+        logger.info("[*] Request and received. Done. %s" % (str(addr[0])))
         conn.close()
     except Exception as e:
         print(traceback.format_exc())
-        print("[*] Exception on requesting the data. Cause: %s" % (str(e)))
+        logger.error("[*] Exception on requesting the data.", exc_info=e)
         conn.sendall(b"HTTP/1.1 403 Forbidden\r\n\r\n{\"status\":403}")
         conn.close()
 
+
 # journaling a filtered hosts
 def add_filtered_host(domain, ip_address):
     hosts_path = './filtered.hosts'
@@ -480,30 +497,36 @@ def add_filtered_host(domain, ip_address):
         with open(hosts_path, 'w') as file:
             file.writelines(lines)
 
-def start():    #Main Program
+
+def start():  #Main Program
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.bind(('', listening_port))
         sock.listen(max_connection)
-        print("[*] Server started successfully [ %d ]" %(listening_port))
+        logger.info("[*] Server started successfully [ %d ]" % listening_port)
     except Exception as e:
-        print("[*] Unable to Initialize Socket:", str(e))
+        logger.error("[*] Unable to Initialize Socket", exc_info=e)
         sys.exit(2)
 
     while True:
         try:
-            conn, addr = sock.accept() #Accept connection from client browser
-            data = conn.recv(buffer_size) #Recieve client data
-            start_new_thread(conn_string, (conn, data, addr)) #Starting a thread
+            conn, addr = sock.accept()  #Accept connection from client browser
+            data = conn.recv(buffer_size)  #Recieve client data
+            start_new_thread(conn_string, (conn, data, addr))  #Starting a thread
         except KeyboardInterrupt:
             sock.close()
-            print("\n[*] Graceful Shutdown")
+            logger.info("[*] Graceful Shutdown")
             sys.exit(1)
 
-if __name__== "__main__":
-    # load extensions
-    for s in use_extensions.split(','):
-        Extension.register(s)
+
+if __name__ == "__main__":
+    # Fix Value error
+    if use_extensions:
+        # load extensions
+        for s in use_extensions.split(','):
+            Extension.register(s)
+    else:
+        logger.warning("[*] No extensions registered")
 
     # start Caterpillar
     start()

smtp.py

@@ -12,21 +12,25 @@
 
 import asyncore
 from smtpd import SMTPServer
+
 import re
+import sys
 import json
 import requests
 
 from decouple import config
 from requests.auth import HTTPBasicAuth
-from base import extract_credentials, jsonrpc2_create_id, jsonrpc2_encode, jsonrpc2_result_encode
+from base import extract_credentials, jsonrpc2_create_id, jsonrpc2_encode, jsonrpc2_result_encode, Logger
+
+logger = Logger(name="smtp")
 
 try:
     smtp_host = config('SMTP_HOST', default='127.0.0.1')
     smtp_port = config('SMTP_PORT', default=25, cast=int)
     _username, _password, server_url = extract_credentials(config('SERVER_URL', default=''))
 except KeyboardInterrupt:
-    print("\n[*] User has requested an interrupt")
-    print("[*] Application Exiting.....")
+    logger.warning("[*] User has requested an interrupt")
+    logger.warning("[*] Application Exiting.....")
     sys.exit()
 
 auth = None
@@ -73,13 +77,13 @@ class CaterpillarSMTPServer(SMTPServer):
             if response.status_code == 200:
                 type, id, method, rpcdata = jsonrpc2_decode(response.text)
                 if rpcdata['success']:
-                    print("[*] Email sent successfully.")
+                    logger.info("[*] Email sent successfully.")
                 else:
                     raise Exception("(%s) %s" % (str(rpcdata['code']), rpcdata['message']))
             else:
                 raise Exception("Status %s" % (str(response.status_code)))
         except Exception as e:
-            print("[*] Failed to send email:", str(e))
+            logger.error("[*] Failed to send email", exc_info=e)
 
 # Start SMTP server
 smtp_server = CaterpillarSMTPServer((smtp_host, smtp_port), None)

web.py

@@ -10,27 +10,25 @@
 # Updated at: 2024-07-10
 #
 
-from flask import Flask, request, redirect, url_for, render_template
 import os
 import sys
-import json
-import importlib
-
-import hashlib
 from decouple import config
+from flask import Flask, request, render_template
+from base import Extension, jsonrpc2_error_encode, Logger
 
-from base import Extension, jsonrpc2_create_id, jsonrpc2_result_encode, jsonrpc2_error_encode
-
+# TODO: 나중에 Flask 커스텀 핸들러 구현 해야 함
+logger = Logger(name="web")
 app = Flask(__name__)
 app.config['UPLOAD_FOLDER'] = 'data/'
-
 if not os.path.exists(app.config['UPLOAD_FOLDER']):
     os.makedirs(app.config['UPLOAD_FOLDER'])
 
+
 @app.route('/')
 def upload_form():
     return render_template('upload.html')
 
+
 @app.route('/upload', methods=['POST'])
 def process_upload():
     # make connection profile from Flask request
@@ -42,10 +40,11 @@ def process_upload():
     params = {
         'filename': filename
     }
-    
+
     # just do it
     return Extension.dispatch_rpcmethod(method, 'call', '', params, conn)
 
+
 @app.route('/jsonrpc2', methods=['POST'])
 def process_jsonrpc2():
     # make connection profile from Flask request
@@ -61,40 +60,48 @@ def process_jsonrpc2():
         'message': "Not vaild JSON-RPC 2.0 request"
     })
 
+
 def jsonrpc2_server(conn, id, method, params):
     return Extension.dispatch_rpcmethod(method, "call", id, params, conn)
 
+
 class Connection():
     def send(self, data):
         self.messages.append(data)
 
     def recv(self, size):
-        print ("Not allowed method")
+        logger.info("Not allowed method")
 
     def close(self):
-        print ("Not allowed method")
+        logger.info("Not allowed method")
 
     def __init__(self, req):
         self.messages = []
         self.request = req
 
+
 if __name__ == "__main__":
-    # initalization
+    # initialization
     try:
         listening_port = config('PORT', default=5555, cast=int)
         client_encoding = config('CLIENT_ENCODING', default='utf-8')
+        use_extensions = config('USE_EXTENSIONS', default='')
     except KeyboardInterrupt:
-        print("\n[*] User has requested an interrupt")
-        print("[*] Application Exiting.....")
+        logger.warning("[*] User has requested an interrupt")
+        logger.warning("[*] Application Exiting.....")
         sys.exit()
     except Exception as e:
-        print("[*] Failed to initialize:", str(e))
+        logger.error("[*] Failed to initialize", exc_info=e)
 
     # set environment of Extension
     Extension.set_protocol('http')
 
-    # load extensions
-    for s in use_extensions.split(','):
-        Extension.register(s)
+    # Fix Value error
+    if use_extensions:
+        # load extensions
+        for s in use_extensions.split(','):
+            Extension.register(s)
+    else:
+        logger.warning("[*] No extensions registered")
 
     app.run(debug=True, host='0.0.0.0', port=listening_port)