See Invisible 📡

A digital radar for mapping the invisible electromagnetic environment around you.

See Invisible scans for WiFi access points and Bluetooth Low Energy (BLE) devices, translating raw signal strength (RSSI) into a 2D spatial heatmap. It turns your laptop into a passive RF reconnaissance tool, visualizing the digital density of your immediate surroundings.

Why this project is interesting

• Passive Reconnaissance: Uses standard OS-level tools and BLE libraries to "see" devices without active pairing or connection.
• RF-to-Spatial Mapping: Implements a heuristic that maps signal decay (dBm) to radial distance, creating a "radar" view of digital infrastructure.
• Heterogeneous Data Normalization: Unifies Windows netsh output and BLE advertisement packets into a standardized JSON schema.

Key Features

• Dual-Spectrum Scanning: Simultaneous WiFi and Bluetooth LE discovery.
• Standardized Data Schema: Converts raw vendor-specific data into a uniform format for analysis.
• High-Fidelity Visualizations: Generates dark-mode radar heatmaps with signal path gradients and proximity-based scaling.
• Persistent Logging: Saves both raw hardware output and processed standard data for historical tracking.

Architecture Overview

The system operates as a data pipeline from hardware interface to visual output:

1. Ingestion: app.py triggers concurrent scans. WiFi is gathered via subprocess calls to netsh, while Bluetooth is captured via an asynchronous callback loop using bleak.
2. Normalization: utils/utils.py maps various signal metrics (Percentage vs dBm) into a unified object.
3. Visualization: plot.py consumes the JSON artifacts, calculating polar coordinates for each device based on signal strength and generating a Matplotlib-based heatmap.

graph TD
    A[User Execution] --> B[app.py CLI]
    B --> C[WiFi Scan - netsh]
    B --> D[BLE Scan - bleak]
    C --> E[Data Normalization]
    D --> E
    E --> F[JSON Storage - data/raw]
    E --> G[JSON Storage - data/standard]
    F --> H[plot.py Visualization]
    H --> I[Heatmap PNG Output]

Loading

Tech Stack

• Language: Python 3.x
• Bluetooth: bleak (Cross-platform BLE support)
• Visualization: matplotlib, numpy
• OS Interface: subprocess (for Windows netsh interaction)

Project Structure

see-invisible/
├── app.py              # Main CLI entrypoint for scanning
├── plot.py             # Visualization engine for generating heatmaps
├── utils/
│   ├── scan.py         # Hardware-specific scanning implementations
│   └── utils.py        # Data formatting and persistence logic
├── data/               # Persistent storage for scans
│   ├── raw/            # Original hardware output (vendor-specific)
│   └── standard/       # Unified schema output
└── requirements.txt    # Project dependencies

Local Setup

1. Prerequisites: Python 3.8+ and a Windows environment (for WiFi scanning).
2. Install Dependencies:

   pip install -r requirements.txt
   pip install matplotlib numpy

3. Run a Scan:

   python app.py --display

4. Generate Visualization:

   # Use the path to a raw JSON file generated in data/raw/
   python plot.py --infile data/raw/network_scan_raw_YYYYMMDD_HHMMSS.json

Implementation Details

Signal-to-Distance Heuristic

The visualization uses a linear mapping fallback for signal strength:

• -50 dBm (and stronger) is treated as 100% signal (Near).
• -100 dBm (and weaker) is treated as 0% signal (Far).
• Distance from center = MAX_DISTANCE * (1 - Signal%).

Windows-Specific WiFi Hook

WiFi scanning is implemented via netsh wlan show networks mode=bssid. This allows the tool to see individual BSSIDs (physical access points) rather than just SSIDs (network names), providing a more accurate count of physical hardware in range.

Limitations & Technical Tradeoffs

• OS Specificity: WiFi scanning currently relies on Windows netsh. Linux (nmcli) or macOS (airport) support is not yet implemented.
• RSSI Noise: Signal strength (RSSI) is heavily influenced by physical obstacles (walls, bodies), leading to "distance" jitter.
• Scanning Latency: BLE scans are hardcoded to 5 seconds to ensure a representative sample of advertisement packets, making "real-time" updates slightly delayed.

Future Improvements

• Cross-Platform WiFi: Implement Linux/macOS drivers for the scanning utility.
• Triangulation: Support multi-point scanning to estimate absolute (X, Y) coordinates rather than just radial distance.
• Real-time Dashboard: Replace static Matplotlib output with a live Plotly or Dash interface.