Skip to content

Latest commit

 

History

History
206 lines (168 loc) · 6.71 KB

readme.md

File metadata and controls

206 lines (168 loc) · 6.71 KB

What This Code Does

  1. Public Server (public_server.go):

    • Acts as a central hub for tunneling traffic between a client (browser or external user) and a local server (behind NAT).
    • WebSocket connections:
      • Local servers connect to this public server using WebSocket.
      • Public server maintains a map of active WebSocket connections and routes requests accordingly.
    • Reverse Proxy:
      • Routes HTTP(S) requests to the appropriate local server based on active connections.
    • Additional Features:
      • IP whitelisting (restricts access to allowed CIDRs).
      • Rate limiting using golang.org/x/time/rate.
      • Prometheus metrics for monitoring.

  2. Local Server (local_server.go):

    • Connects to the public server over WebSocket.
    • Forwards any requests received via the public server to its own local HTTP server.
    • Automatically attempts to reconnect if disconnected.

How It Works

  1. Setup:

    • You deploy public_server.go on a VPS with a public IP.
    • You run local_server.go on your local machine (behind NAT or firewall).
    • Local server connects to the public server's WebSocket endpoint.

  2. Traffic Flow:

    • A user sends a request to the public server's address.
    • The public server proxies this request to the local server over the WebSocket connection.
    • The local server processes the request and sends the response back to the public server, which forwards it to the user.

Features

  1. WebSocket Communication:

    • Efficient and keeps connections alive for real-time communication.

  2. Round-Robin Load Balancing:

    • Balances traffic between multiple local servers.

  3. Prometheus Metrics:

    • Exposes metrics for monitoring active connections and request counts.

  4. Security Features:

    • TLS support for encrypted communication.
    • IP whitelisting and rate limiting.

What You Can Use This For

  • Webhook Testing:
    • Similar to ngrok, expose a local development server for webhook integration.
  • Remote Access:
    • Access your local server (e.g., dashboard or API) from anywhere.
  • Load Balancing:
    • Distribute incoming requests to multiple local servers.
  • Custom Proxy:
    • Tailor it to your needs (e.g., adding authentication or specific routing rules).

USAGE

Prerequisites

  1. Local Machine (Kali Linux):

    • Install Golang: Ensure you have Go installed. Verify with go version.
    • Install git: Use sudo apt install git to get Git for cloning repositories.
    • Open necessary ports for your local server (default: 3000).

  2. Server (Azure Ubuntu VM in my case):

    • Install aaPanel: if it's already installed, you can use it to manage configurations like firewalls, certificates, and server monitoring.
    • Open required ports in Azure's Network Security Group (NSG):
      • 8080: HTTP public server.
      • 8443: HTTPS public server (if TLS enabled).
      • 9090: Metrics server for Prometheus.

Server-Side Setup (Azure VM)

1. Install Dependencies

  • Update the system: 
    sudo apt update && sudo apt upgrade -y
  • Install Go: 
    sudo apt install golang -y
go version  # Confirm installation
  • Install Git: 
    sudo apt install git -y

2. Set Up Project Files

  • Clone your repository or create a new directory: 
    git clone https://github.com/JeninSutradhar/Go-Reverse-Proxy
cd Go-Reverse-Proxy
  • Create or modify the config.yaml file: 
    local_servers:
  - "http://<YOUR-LOCAL-MACHINE-IP>:3000"  # Replace with your local machine's server address if needed
whitelist_cidr:
  - "0.0.0.0/0"  # Allow all (or replace with specific CIDRs for security)
rate_limit: 100
  • Generate TLS certificates (optional, for HTTPS): 
    sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout server.key -out server.crt \
-subj "/C=US/ST=State/L=City/O=Organization/OU=Unit/CN=yourdomain.com"

3. Run the Public Server

  • Build and run the server:

    go build -o public_server public_server.go
./public_server -publicAddr :8080 -publicTLSAddr :8443 -metricsAddr :9090 -config config.yaml

  • Use aaPanel: Add the application as a managed process if desired.

Local Machine Setup (Kali Linux)

1. Install Dependencies

  • Ensure Go is installed: 
    sudo apt install golang -y
go version  # Confirm installation

2. Set Up Project Files

  • Clone your repository or copy the files: 
    git clone https://github.com/your-repo/tunneling-system.git
cd tunneling-system

3. Run the Local Server

  • Modify the local_server.go connection address to match the Azure VM's public IP: 
    publicServerAddr = flag.String("publicServerAddr", "ws://<Azure_Public_IP>:8080/ws", "Public server WebSocket address")
  • Build and run the local server: 
    go build -o local_server local_server.go
./local_server -publicServerAddr ws://<Azure_Public_IP>:8080/ws -localServiceAddr localhost:3000

Verify the Setup

  1. Local Server Status:

    • Open a browser and visit http://localhost:3000 on your Kali Linux machine to ensure your local server is running.

  2. Public Server Access:

    • Access the Azure server:
      • Metrics: http://<Azure_Public_IP>:9090/metrics
      • Proxy Endpoint: http://<Azure_Public_IP>:8080
    • Test the tunnel:
      • Access the proxied local server via http://<Azure_Public_IP>:8080.

Optional Improvements

  1. Add TLS on Public Server:

    • Use https://<Azure_Public_IP>:8443 for secure connections.

  2. Automate Startup:

    • Use systemd to create service files for the public server and local server:

      sudo nano /etc/systemd/system/public_server.service

      Example file:

      [Unit]
Description=Public Server
After=network.target

[Service]
ExecStart=/path/to/public_server -publicAddr :8080 -publicTLSAddr :8443 -metricsAddr :9090 -config config.yaml
Restart=always

[Install]
WantedBy=multi-user.target

      Enable and start:

      sudo systemctl enable public_server
sudo systemctl start public_server

Security Tips

  1. Restrict CIDR in config.yaml to your development IP or network.
  2. Secure Firewall Rules:
    • Only open necessary ports on Azure and aaPanel.
  3. Authentication:
    • Add authentication (API keys or tokens) to WebSocket and HTTP endpoints.