add feature shortcuts

Author: 6C656C65

.gitignore

@@ -172,6 +172,7 @@ cython_debug/
 
 # Config file
 config/*.txt
+!config/*.example.txt
 
 # Certs folder
 certs/*.key

config.ini.example

@@ -18,6 +18,9 @@ filter_mode = local
 blocked_sites = config/blocked_sites.txt
 blocked_url = config/blocked_url.txt
 
+[Options]
+shortcuts = config/shortcuts.txt
+
 [Security]
 ssl_inspect = false
 inspect_ca_cert = certs/ca/cert.pem

config/.gitkeep

@@ -0,0 +1 @@
+example.com

config/blocked_sites.example.txt

@@ -0,0 +1 @@
+example2.com/about

config/blocked_url.example.txt

@@ -0,0 +1,3 @@
+f=https://facebook.com
+gh=https://github.com
+yt=https://youtube.com

config/shortcuts.example.txt

@@ -43,6 +43,11 @@
         type=str,
         help="Path to the block log file"
     )
+    parser.add_argument(
+        "--shortcuts",
+        type=str,
+        help="Path to the shortcuts file"
+    )
     parser.add_argument(
         "--html-403",
         type=str,
@@ -118,6 +123,11 @@
         if args.blocked_url
         else config.get('Filtering', 'blocked_url', fallback="config/blocked_url.txt")
     )
+    shortcuts = (
+        args.blocked_url
+        if args.blocked_url
+        else config.get('Options', 'shortcuts', fallback="config/shortcuts.txt")
+    )
     no_logging_access = (
         args.no_logging_access
         if args.no_logging_access
@@ -163,6 +173,7 @@
         ssl_inspect=ssl_inspect,
         blocked_sites=blocked_sites,
         blocked_url=blocked_url,
+        shortcuts=shortcuts,
         inspect_ca_cert=inspect_ca_cert,
         inspect_ca_key=inspect_ca_key,
         inspect_certs_folder=inspect_certs_folder

pyproxy.py

@@ -21,6 +21,7 @@
 from OpenSSL import crypto
 
 from utils.filter import filter_process
+from utils.shortcuts import shortcuts_process
 from utils.logger import configure_file_logger, configure_console_logger
 
 class ProxyServer:
@@ -33,7 +34,7 @@ class ProxyServer:
     # pylint: disable=too-many-locals
     def __init__(self, host, port, debug, access_log, block_log,
                  html_403, no_filter, filter_mode, no_logging_access, no_logging_block, ssl_inspect,
-                 blocked_sites, blocked_url, inspect_ca_cert, inspect_ca_key, inspect_certs_folder):
+                 blocked_sites, blocked_url, shortcuts, inspect_ca_cert, inspect_ca_key, inspect_certs_folder):
         """
         Initializes the ProxyServer instance with the provided configurations.
         """
@@ -46,11 +47,15 @@ def __init__(self, host, port, debug, access_log, block_log,
         self.no_logging_block = no_logging_block
         self.ssl_inspect = ssl_inspect
         self.filter_proc = None
-        self.queue = multiprocessing.Queue()
-        self.result_queue = multiprocessing.Queue()
+        self.filter_queue = multiprocessing.Queue()
+        self.filter_result_queue = multiprocessing.Queue()
+        self.shortcuts_proc = None
+        self.shortcuts_queue = multiprocessing.Queue()
+        self.shortcuts_result_queue = multiprocessing.Queue()
         self.console_logger = configure_console_logger()
         self.config_blocked_sites = blocked_sites
         self.config_blocked_url = blocked_url
+        self.config_shortcuts = shortcuts
         self.config_inspect_cert = inspect_ca_cert
         self.config_inspect_key = inspect_ca_key
         self.config_inspect_certs_folder = inspect_certs_folder
@@ -79,6 +84,7 @@ def start(self):
             self.console_logger.debug("[*] ssl_inspect = %s", self.ssl_inspect)
             self.console_logger.debug("[*] blocked_sites = %s", self.config_blocked_sites)
             self.console_logger.debug("[*] blocked_url = %s", self.config_blocked_url)
+            self.console_logger.debug("[*] shortcuts = %s", self.config_shortcuts)
             self.console_logger.debug("[*] inspect_ca_cert = %s", self.config_inspect_cert)
             self.console_logger.debug("[*] inspect_ca_key = %s", self.config_inspect_key)
             self.console_logger.debug(
@@ -116,14 +122,27 @@ def start(self):
             self.filter_proc = multiprocessing.Process(
                 target=filter_process,
                 args=(
-                    self.queue,
-                    self.result_queue,
+                    self.filter_queue,
+                    self.filter_result_queue,
                     self.filter_mode,
                     self.config_blocked_sites,
                     self.config_blocked_url
                 )
             )
             self.filter_proc.start()
+            self.console_logger.debug("[*] Starting the filter process...")
+
+        if self.config_shortcuts and os.path.isfile(self.config_shortcuts):
+            self.shortcuts_proc = multiprocessing.Process(
+                target=shortcuts_process,
+                args=(
+                    self.shortcuts_queue,
+                    self.shortcuts_result_queue,
+                    self.config_shortcuts
+                )
+            )
+            self.shortcuts_proc.start()
+            self.console_logger.debug("[*] Starting the shortcuts process...")
 
         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         server.bind(self.host_port)
@@ -176,9 +195,28 @@ def handle_http_request(self, client_socket, request):
         first_line = request.decode(errors='ignore').split("\n")[0]
         url = first_line.split(" ")[1]
 
+        if self.config_shortcuts:
+            domain, _ = self.parse_url(url)
+            print(url)
+            print(domain)
+            self.shortcuts_queue.put(domain)
+            shortcut_url = self.shortcuts_result_queue.get()
+            print(shortcut_url)
+            if shortcut_url:
+                response = (
+                    "HTTP/1.1 302 Found\r\n"
+                    "Location: {shortcut_url}\r\n"
+                    "Content-Length: 0\r\n"
+                    "\r\n"
+                ).format(shortcut_url=shortcut_url)
+                
+                client_socket.sendall(response.encode())
+                client_socket.close()
+                return
+
         if not self.no_filter:
-            self.queue.put(url)
-            result = self.result_queue.get()
+            self.filter_queue.put(url)
+            result = self.filter_result_queue.get()
             if result[1] == "Blocked":
                 if not self.no_logging_block:
                     self.block_logger.info(
@@ -218,16 +256,28 @@ def forward_request_to_server(self, client_socket, request, url):
             url (str): The target URL from the HTTP request.
         """
         server_host, server_port = self.parse_url(url)
-        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        server_socket.connect((server_host, server_port))
-        server_socket.sendall(request)
 
-        while True:
-            response = server_socket.recv(4096)
-            if len(response) > 0:
-                client_socket.send(response)
-            else:
-                break
+        try:
+            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            server_socket.connect((server_host, server_port))
+            server_socket.sendall(request)
+
+            while True:
+                response = server_socket.recv(4096)
+                if len(response) > 0:
+                    client_socket.send(response)
+                else:
+                    break
+        except Exception as e:
+            self.console_logger.error(f"Error connecting to the server {server_host}: {e}")
+            response = (
+                f"HTTP/1.1 502 Bad Gateway\r\n"
+                f"Content-Length: {len('Bad Gateway')} \r\n"
+                f"\r\n"
+                f"Bad Gateway"
+            )
+            client_socket.sendall(response.encode())
+            client_socket.close()            
 
     def parse_url(self, url):
         """
@@ -270,8 +320,8 @@ def handle_https_connection(self, client_socket, first_line):
         server_port = int(server_port)
 
         if not self.no_filter:
-            self.queue.put(target)
-            result = self.result_queue.get()
+            self.filter_queue.put(target)
+            result = self.filter_result_queue.get()
             if result[1] == "Blocked":
                 if not self.no_logging_block:
                     self.block_logger.info(
@@ -330,8 +380,8 @@ def handle_https_connection(self, client_socket, first_line):
                     full_url = f"https://{server_host}{path}"
 
                     if not self.no_filter:
-                        self.queue.put(f"{server_host}{path}")
-                        result = self.result_queue.get()
+                        self.filter_queue.put(f"{server_host}{path}")
+                        result = self.filter_result_queue.get()
                         if result[1] == "Blocked":
                             if not self.no_logging_block:
                                 self.block_logger.info(
@@ -381,17 +431,28 @@ def handle_https_connection(self, client_socket, first_line):
                 client_socket.close()
 
         else:
-            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            server_socket.connect((server_host, server_port))
-            client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
-            if not self.no_logging_access:
-                self.access_logger.info(
-                    "%s - %s - %s",
-                    client_socket.getpeername()[0],
-                    f"https://{server_host}",
-                    first_line
+            try:
+                server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                server_socket.connect((server_host, server_port))
+                client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
+                if not self.no_logging_access:
+                    self.access_logger.info(
+                        "%s - %s - %s",
+                        client_socket.getpeername()[0],
+                        f"https://{server_host}",
+                        first_line
+                    )
+                self.transfer_data_between_sockets(client_socket, server_socket)
+            except Exception as e:
+                self.console_logger.error(f"Error connecting to the server {server_host}: {e}")
+                response = (
+                    f"HTTP/1.1 502 Bad Gateway\r\n"
+                    f"Content-Length: {len('Bad Gateway')} \r\n"
+                    f"\r\n"
+                    f"Bad Gateway"
                 )
-            self.transfer_data_between_sockets(client_socket, server_socket)
+                client_socket.sendall(response.encode())
+                client_socket.close()  
 
     def transfer_data_between_sockets(self, client_socket, server_socket):
         """

utils/proxy.py

@@ -0,0 +1,92 @@
+"""
+filter.py
+
+This module contains functions and a process to filter and block domains and URLs.
+It loads blocked domain names and URLs from specified files, then listens for 
+incoming requests to check if the domain or URL should be blocked.
+
+Functions:
+- load_blacklist: Loads blocked FQDNs and URLs from files into sets for fast lookup.
+- filter_process: The process that checks whether a domain or URL is blocked.
+"""
+
+import multiprocessing
+import time
+import sys
+import threading
+import requests
+
+def load_shortcuts(shortcuts_path: str) -> dict:
+    """
+    Loads blocked FQDNs or URLs from a file or URL into a set for fast lookup.
+    
+    Args:
+        blocked_sites_path (str): The path or URL to the file containing blocked FQDNs.
+        blocked_url_path (str): The path or URL to the file containing blocked URLs.
+        filter_mode (str): Mode to determine if we load from local file or HTTP URL.
+    
+    Returns:
+        set: A set of blocked domains/URLs.
+    """
+    shortcuts = {}
+
+    with open(shortcuts_path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if "=" in line:
+                alias, url = line.split("=", 1) 
+                shortcuts[alias.strip()] = url.strip()
+
+    return shortcuts
+
+# pylint: disable=too-many-locals
+def shortcuts_process(
+    queue: multiprocessing.Queue,
+    result_queue: multiprocessing.Queue,
+    shortcuts_path: str
+) -> None:
+    """
+    Process that listens for requests and checks if the domain/URL should be blocked.
+    
+    Args:
+        queue (multiprocessing.Queue): A queue to receive URL/domain for checking.
+        result_queue (multiprocessing.Queue): A queue to send back the result of
+                the filtering (blocked or allowed).
+        filter_mode (str): Filter list mode (local or http).
+        blocked_sites_path (str): The path to the file containing blocked FQDNs.
+        blocked_url_path (str): The path to the file containing blocked URLs.
+    """
+    manager = multiprocessing.Manager()
+    shortcuts_data = manager.dict({
+        "shortcuts": load_shortcuts(shortcuts_path)
+    })
+
+    error_event = threading.Event()
+
+    def file_monitor() -> None:
+        try:
+            while True:
+                new_shortcuts = load_shortcuts(shortcuts_path)
+
+                shortcuts_data["shortcuts"] = new_shortcuts
+
+                time.sleep(5)
+        except (IOError, ValueError) as e:
+            print(f"File monitor error: {e}")
+            error_event.set()
+
+    monitor_thread = threading.Thread(target=file_monitor, daemon=True)
+    monitor_thread.start()
+
+    while True:
+        if error_event.is_set():
+            print("Error detected in file monitor thread, terminating process.")
+            sys.exit(1)
+
+        try:
+            alias = queue.get()
+            url = shortcuts_data["shortcuts"].get(alias)
+            result_queue.put(url)
+
+        except KeyboardInterrupt:
+            break