fix: use_extension value extension

base.py

@@ -23,6 +23,7 @@ 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)
@@ -35,9 +36,11 @@ 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):
     data = {
         "jsonrpc": "2.0",
@@ -48,6 +51,7 @@ def jsonrpc2_encode(method, params = None):
     data['id'] = id
     return (id, json.dumps(data))
 
+
 def jsonrpc2_result_encode(result, id=''):
     data = {
         "jsonrpc": "2.0",
@@ -56,6 +60,7 @@ def jsonrpc2_result_encode(result, id = ''):
     }
     return json.dumps(data)
 
+
 def jsonrpc2_error_encode(error, id=''):
     data = {
         "jsonrpc": "2.0",
@@ -64,6 +69,7 @@ def jsonrpc2_error_encode(error, id = ''):
     }
     return json.dumps(data)
 
+
 class Extension():
     extensions = []
     protocols = []
@@ -176,7 +182,7 @@ class Extension():
 class Logger(logging.Logger):
     def __init__(self, name: str, level: int = logging.NOTSET):
         super().__init__(name, level)
-        self.formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        self.formatter = logging.Formatter('[%(asctime)s] %(levelname)s %(module)s: %(message)s')
 
         if not os.path.isdir("logs"):
             os.mkdir("logs")

server.py

@@ -76,6 +76,7 @@ auth = None
 if _username:
     auth = HTTPBasicAuth(_username, _password)
 
+
 def parse_first_data(data):
     parsed_data = (b'', b'', b'', b'', b'')
 
@@ -114,6 +115,7 @@ def parse_first_data(data):
 
     return parsed_data
 
+
 def conn_string(conn, data, addr):
     # JSON-RPC 2.0 request
     def process_jsonrpc2(data):
@@ -151,6 +153,7 @@ def conn_string(conn, data, addr):
 
     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
@@ -165,6 +168,7 @@ def jsonrpc2_server(conn, id, method, params):
 
     #return in conn_string()
 
+
 def proxy_connect(webserver, conn):
     hostname = webserver.decode(client_encoding)
     certpath = "%s/%s.crt" % (certdir.rstrip('/'), hostname)
@@ -177,7 +181,9 @@ 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:
         logger.error("[*] Skipped generating the certificate.", exc_info=e)
@@ -193,6 +199,7 @@ def proxy_connect(webserver, conn):
 
     return (conn, data)
 
+
 def proxy_check_filtered(data, webserver, port, scheme, method, url):
     filtered = False
 
@@ -203,6 +210,7 @@ def proxy_check_filtered(data, webserver, port, scheme, method, url):
 
     return filtered
 
+
 def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
     try:
         logger.info("[*] Started the request. %s" % (str(addr[0])))
@@ -217,7 +225,8 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
                 #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:
@@ -319,7 +328,8 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
 
                 if is_ssl and method == b'GET':
                     logger.info("[*] Trying to bypass blocked request...")
-                    remote_url = "%s://%s%s" % (scheme.decode(client_encoding), webserver.decode(client_encoding), url.decode(client_encoding))
+                    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}")
@@ -351,7 +361,8 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
             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'])
@@ -364,14 +375,17 @@ 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']
-                            logger.error("[*] 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))
 
@@ -467,6 +481,7 @@ def proxy_server(webserver, port, scheme, method, url, conn, addr, data):
         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'
@@ -479,6 +494,7 @@ def add_filtered_host(domain, ip_address):
         with open(hosts_path, 'w') as file:
             file.writelines(lines)
 
+
 def start():  #Main Program
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -499,6 +515,7 @@ def start():    #Main Program
             logger.info("[*] Graceful Shutdown")
             sys.exit(1)
 
+
 if __name__ == "__main__":
     # load extensions
     for s in use_extensions.split(','):

web.py

@@ -10,30 +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_create_id, jsonrpc2_result_encode, jsonrpc2_error_encode, Logger
+from base import Extension, jsonrpc2_error_encode, Logger
 
 # 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
@@ -49,6 +44,7 @@ def process_upload():
     # 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
@@ -64,9 +60,11 @@ 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)
@@ -81,11 +79,13 @@ class Connection():
         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:
         logger.warning("[*] User has requested an interrupt")
         logger.warning("[*] Application Exiting.....")
@@ -96,8 +96,12 @@ if __name__ == "__main__":
     # set environment of Extension
     Extension.set_protocol('http')
 
+    # 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)