seg/trabalho5/proxy.py

import socket
import select
from threading import Thread
import time
import sys
import logging
import logging.handlers
from logging import config

BUFFER_SIZE = 32 * 1024
CURRENT_THREADS = 0
MAX_THREADS = 50
BACKLOG = 50
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        'stdout': {
            'class': 'logging.StreamHandler',
            'stream': sys.stdout,
            'formatter': 'verbose',
        },
        'sys-logger6': {
            'class': 'logging.handlers.SysLogHandler',
            "address": ("127.0.0.1", 514),
            'facility': "local6",
            'formatter': 'verbose',
        },
    },
    'loggers': {
        'PythonProxy': {
            'handlers': ['sys-logger6', 'stdout'],
            'level': logging.DEBUG,
            'propagate': True,
        },
    }
}
config.dictConfig(LOGGING)

class Logger:
    _instance = None
    def __init__(self):
        if self._instance is not None:
            raise Exception("Logger is a singleton!")

        self.logger = logging.getLogger('PythonProxy')
        self.logger.info('Initiating Proxy logger!')

    def info(self, message:str):
        self.logger.info(message)

    def critical(self, message:str):
        self.logger.critical(message)

    @classmethod
    def instance(self):
        if self._instance is None:
            self._instance = self()
        return self._instance


class Server:
    def __init__(self, host:str, port:int):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.bind((host, port))
        self.sock.listen(BACKLOG)
        print(f"Proxy executando em: http://{host}:{port}")

    def thread_check(self):
        global CURRENT_THREADS, MAX_THREADS
        while True:
            if CURRENT_THREADS >= MAX_THREADS:
                time.sleep(1)
            else:
                return

    def start(self):
        global CURRENT_THREADS
        while True:
            conn, client_addr = self.sock.accept()
            self.thread_check()

            CURRENT_THREADS += 1
            thread = Thread(target = self.handle_connection, args = (conn, client_addr, ))
            CURRENT_THREADS -= 1
            thread.start()

    def __del__(self):
        self.sock.close()

    def handle_connection(self, client_socket, client_address):
        request = client_socket.recv(BUFFER_SIZE)
        logger = Logger.instance()

        if len(request) == 0:
            client_socket.close()
            return

        try:
            raw_request = request.decode()
        except UnicodeDecodeError:
            client_socket.close()
            return

        if "CONNECT" in raw_request:
            client_socket.sendall(b"HTTP/1.1 200 Connection Established\r\n\r\n")
            request = client_socket.recv(BUFFER_SIZE)

        request_url = raw_request.split(' ')[1]
        request_host = ""
        request_port = 443 if 'https' in request_url else 80

        if request_url.startswith('http'):
            request_host = request_url.split('/')[2]
        else:
            request_host = request_url.split('/')[0]

        if request_host.startswith('www'):
            request_host = request_host[4:]

        if ':' in request_host:
            request_port = int(request_host.split(':')[1])
            request_host = request_host.split(':')[0]

        if "monitorando" in request_url.lower():
            body = open('forbidden.html', 'r').read()
            client_socket.sendall(b"HTTP/1.1 403 Forbidden\r\n\r\n")
            client_socket.sendall(body.encode())
            client_socket.close()
            logger.info(f"REQUEST [{client_address[0]}:{client_address[1]}] to [{request_host}:{request_port}] - 'Monitorando' - 403 Forbidden")
            return

        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.connect((request_host, request_port))
        server_socket.send(request)

        while True:
            triple = select.select([client_socket, server_socket], [], [], 10)[0]
            if not len(triple):
                break
            try:
                if server_socket in triple:
                    data = server_socket.recv(BUFFER_SIZE)
                    if not data:
                        break

                    try:
                        status_code = data.decode().split('\r\n')[0].split(' ')[1:]
                        status_code = ' '.join(status_code)
                        if is_valid_status_code(status_code):
                            logger.info(f"REQUEST [{client_address[0]}:{client_address[1]}] to [{request_host}:{request_port}] - {status_code}")
                    except UnicodeDecodeError:
                        logger.info(f"REQUEST [{client_address[0]}:{client_address[1]}] to [{request_host}:{request_port}]")
                        pass

                    client_socket.send(data)
                if client_socket in triple:
                    data = client_socket.recv(BUFFER_SIZE)
                    if not data:
                        break

                    server_socket.send(data)
            except ConnectionAbortedError:
                break

        server_socket.close()
        client_socket.close()

def is_valid_status_code(status_code: str):
    valid_starts = [str(i) for i in range(5)]
    if status_code.startswith(tuple(valid_starts)):
        return True
    return False

def check_code():
    import hashlib

    content = None
    shas256_hash = None

    with open(sys.argv[0], 'rb') as f:
        content = f.read()

    with open('proxy.sha256sum', 'r') as f:
        shas256_hash = f.read()

    hash = hashlib.sha256(content).hexdigest()

    if hash != shas256_hash:
        print('ERRO: Código do proxy está diferente!')
        exit(1)

    print('Arquivo do proxy verificado!')

if __name__ == '__main__':
    check_code()

    try:
        ser = Server(host="0.0.0.0", port=8080)
        ser.start()
    except KeyboardInterrupt:
        print("Desligando proxy...")
        exit(0)