rdxmaster/easy-net-visibility-sensor repository overview

⁠Easy Net Visibility

Network scanning agent and dashboard for complete visibility of all services running on your network

⁠Overview

Easy Net Visibility provides centralized visibility for all devices on your network. It consists of two main components that work together to discover, monitor, and report on network devices:

1. Server - Django-based web application providing a dashboard and API for device management
2. Sensor - Network scanning agent that discovers devices and reports to the server

Both components are containerized using Docker for easy deployment and scalability.

⁠How It Works

• Sensors scan your network using nmap to discover devices and identify open ports
• Fortigate Integration (optional) pulls device information from Fortigate firewalls for enhanced discovery
• Server aggregates data from multiple sensors and presents it through a web dashboard
• Notifications (optional) send real-time alerts via Pushover for network events

⁠Features

⁠Core Capabilities

• Automated Network Scanning - Continuous discovery of network devices using nmap
• Port Scanning - Identify open ports and running services on each device
• Multi-Sensor Architecture - Deploy multiple sensors across different network segments
• Web Dashboard - Centralized view of all discovered devices and services
• Device Management - Track device hostnames, IP addresses, MAC addresses, and vendors

⁠Advanced Features

• Fortigate Firewall Integration - Enhanced device discovery using FortiGate's Assets API
• Real-time Notifications - Pushover integration for instant alerts (see PUSHOVER.md⁠)
  • New device detection
  • Gateway/sensor timeout alerts
  • Device offline notifications (for important devices)
• Historical Tracking - Monitor when devices were first seen and last seen
• Flexible Database Support - Use SQLite (default) or external databases (MySQL, PostgreSQL)
• RESTful API - Programmatic access to device data
• Containerized Deployment - Easy deployment with Docker

⁠Supported Platforms

• Server: x86-64 Linux (tested on CoreOS/GCP)
• Sensor: x86 (Intel/AMD), ARM (Raspberry Pi), various Linux distributions (Raspbian, Yocto)

⁠Component Details

⁠Server (Django)

• Web Framework: Django with REST framework
• Database: SQLite (default) or external database (MySQL/PostgreSQL)
• Web Server: Gunicorn with optional nginx/Apache reverse proxy
• Authentication: HTTP Basic Auth or Django authentication
• Port: 8000 (default, can be changed)

⁠Sensor (Python)

• Scanner: nmap for network discovery and port scanning
• API Client: Communicates with server via REST API
• Configuration: INI file-based configuration
• Scheduling: Continuous scanning with configurable intervals
• Optional: Fortigate API integration

⁠Data Flow

1. Sensor scans network (nmap) or queries Fortigate
2. Sensor normalizes device data (IP, MAC, hostname, ports)
3. Sensor sends data to server via REST API
4. Server validates and stores data in database
5. Server triggers notifications for configured events
6. Web dashboard displays current and historical data

⁠Quick Start

⁠Prerequisites

• Docker installed on your system
• Network access from sensor to target network
• (Optional) Fortigate firewall with API access
• (Optional) Pushover account for notifications

⁠1. Deploy the Server

# Create directories for configuration and database
mkdir -p /opt/easy_net_visibility/conf
mkdir -p /opt/easy_net_visibility/db

# Create settings.json (see Configuration section below)
cat > /opt/easy_net_visibility/conf/settings.json << 'EOF'
{
  "DATABASES": {
    "default": {
      "ENGINE": "django.db.backends.sqlite3",
      "NAME": "db/db.sqlite3"
    }
  },
  "SECRET_KEY": "CHANGE-THIS-TO-A-RANDOM-SECRET-KEY",
  "DEBUG": "False",
  "STATIC_ROOT": "static"
}
EOF

# Pull the Docker image from Docker Hub
docker pull rdxmaster/easy-net-visibility-server-django:latest

# Or build locally from source
# docker build -t rdxmaster/easy-net-visibility-server-django easyNetVisibility/server/server_django/

# Run the server
docker run -d --restart=always \
    -p 8000:8000 \
    --volume="/opt/easy_net_visibility/conf:/opt/app/easy_net_visibility/conf:ro" \
    --volume="/opt/easy_net_visibility/db:/opt/app/easy_net_visibility/db:rw" \
    -e DJANGO_SUPERUSER_USERNAME=admin \
    -e DJANGO_SUPERUSER_PASSWORD=your_secure_password \
    -e [email protected] \
    --name=easy-net-visibility-server \
    rdxmaster/easy-net-visibility-server-django:latest

⁠2. Deploy the Sensor

# Create configuration directory
mkdir -p /opt/easynetvisibility

# Create config.ini (see Configuration section below)
cat > /opt/easynetvisibility/config.ini << 'EOF'
[ServerAPI]
serverURL=http://YOUR_SERVER_IP:8000
serverUsername=admin
serverPassword=your_secure_password
validateServerIdentity=False

[General]
interface=eth0
EOF

# Pull the Docker image from Docker Hub
docker pull rdxmaster/easy-net-visibility-sensor:latest

# Or build locally from source
# docker build -t rdxmaster/easy-net-visibility-sensor easyNetVisibility/client/

# Run the sensor
docker run -d --restart=always \
    --name=easy-net-visibility-sensor \
    --net=host \
    -v /opt/easynetvisibility:/opt/sensor/config \
    rdxmaster/easy-net-visibility-sensor:latest

⁠3. Access the Dashboard

Open your web browser and navigate to:

http://YOUR_SERVER_IP:8000

Login with the admin credentials you specified during deployment.

⁠4. (Optional) Setup HTTPS

For production deployments, it's recommended to use HTTPS. See the Installation⁠ section for reverse proxy configuration.