anti ddos.py

import socket
import threading
from http.server import HTTPServer, BaseHTTPRequestHandler
import time

# Constants for rate limiting and security
UDP_MAX_PACKETS_PER_SECOND = 5

# Store client connections for rate limiting
tcp_connections = {}
udp_connections = {}

# Define a list of allowed IP addresses
ALLOWED_IPS = ["127.0.0.1", "192.168.1.1"]

# Dynamic rate limiting parameters
MAX_ALLOWED_CONNECTIONS = 10
RATE_LIMIT_ADJUST_INTERVAL = 60  # Adjust rate limits every 60 seconds

# Define rate limits for various protocols
RATE_LIMITS = {
    "TCP/IP": 5,
    "SMTP": 5,
    "FTP": 5,
    "SFTP": 5,
    "HTTP": 10,
    "HTTPS": 5,
    "TELNET": 5,
    "POP3": 5,
    "IMAP": 5,
    "SSH": 5,
    "Gopher": 5
}

def adjust_rate_limits():
    while True:
        time.sleep(RATE_LIMIT_ADJUST_INTERVAL)
        
        # Gather statistics on traffic patterns (e.g., connection rates)
        tcp_connection_count = sum(tcp_connections.values())
        udp_packet_count = sum(udp_connections.values())

        # Adjust rate limits based on traffic patterns
        for protocol, rate_limit in RATE_LIMITS.items():
            if protocol == "TCP/IP" and tcp_connection_count > rate_limit:
                RATE_LIMITS[protocol] += 1  # Increase rate limit
            else:
                RATE_LIMITS[protocol] = 5  # Reset to default

        # Log rate limit adjustments (for demonstration)
        for protocol, rate_limit in RATE_LIMITS.items():
            print(f"Adjusted rate limit - {protocol}: {rate_limit}/s")

        # Clear connection counters
        tcp_connections.clear()
        udp_connections.clear()

# Dummy HTTP request handler for demonstration
class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        client_address = self.client_address[0]

        # Rate limiting for HTTP requests
        if client_address not in tcp_connections:
            tcp_connections[client_address] = 0
        tcp_connections[client_address] += 1

        if tcp_connections[client_address] > RATE_LIMITS["HTTP"]:
            self.send_response(429)
            self.end_headers()
            self.wfile.write(b"Rate limit exceeded")
            return

        # IP filtering
        if client_address not in ALLOWED_IPS:
            self.send_response(403)
            self.end_headers()
            self.wfile.write(b"Forbidden")
            return

        self.send_response(200)
        self.end_headers()
        self.wfile.write(b"Hello, world!")

def start_tcp_server():
    tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    tcp_server.bind(("0.0.0.0", 8888))
    tcp_server.listen(5)
    print("TCP server listening on port 8888")

    while True:
        client_socket, client_address = tcp_server.accept()

        # Identify the protocol based on the port or other characteristics
        # Implement rate limiting and logic for each protocol here
        protocol = "TCP/IP"

        if protocol not in RATE_LIMITS:
            print(f"Unsupported protocol: {protocol}")
            client_socket.close()
            continue

        if client_address[0] not in tcp_connections:
            tcp_connections[client_address[0]] = 0
        tcp_connections[client_address[0]] += 1

        if tcp_connections[client_address[0]] > RATE_LIMITS[protocol]:
            print(f"{protocol} connection from {client_address[0]} blocked due to rate limiting")
            client_socket.close()
            continue

        # IP filtering
        if client_address[0] not in ALLOWED_IPS:
            print(f"{protocol} connection from {client_address[0]} blocked due to IP filtering")
            client_socket.close()
            continue

        print(f"Accepted {protocol} connection from {client_address[0]}")

        try:
            # Your protocol-specific logic here
            pass
        except Exception as e:
            print(f"Error handling {protocol} connection: {str(e)}")
        finally:
            client_socket.close()

def start_http_server():
    http_server = HTTPServer(("0.0.0.0", 8080), RequestHandler)
    print("HTTP server listening on port 8080")

    http_server.serve_forever()

# Implement similar functions for other protocols like SMTP, FTP, SFTP, POP3, IMAP, SSH, and Gopher.

if __name__ == "__main__":
    # Start the rate limit adjustment thread
    rate_limit_adjustment_thread = threading.Thread(target=adjust_rate_limits)
    rate_limit_adjustment_thread.daemon = True

    # Start TCP and HTTP servers in separate threads
    tcp_thread = threading.Thread(target=start_tcp_server)
    http_thread = threading.Thread(target=start_http_server)

    rate_limit_adjustment_thread.start()
    tcp_thread.start()
    http_thread.start()

    rate_limit_adjustment_thread.join()
    tcp_thread.join()
    http_thread.join()