WATCH DOGS GO WARS

THE CONCEPT

You play as a hacker with a portable terminal. Your mission: discover, map, and earn points for exploring the digital world around you. Form teams with other players, cover cities together, compete on the leaderboard, earn badges.

On the map — in real-time — simulated cyberattacks inspired by Watch Dogs and actual news from cybersecurity portals appear. Each event at a real location on the map, in the local language.

THE GEAR

The absolute foundation is the ESP32-C5 running projectZero firmware — it scans WiFi and BLE networks, captures handshakes, and collects data about the wireless infrastructure around you. Without it — no wardriving. This is the heart of the entire system, everything else is an add-on.

The main terminal is the ClockworkPi uConsole (EU shop) — a portable retro-cyberpunk computer with a 5" screen, keyboard, and battery. This is where the game runs, where you see what the ESP32 scans, where you manage your missions.

The next key component is the AIO v2 by Hacker Gadgets — an All-In-One module that extends the uConsole with: GPS for geolocation, LoRa for mesh communication (MeshCore), SDR for intercepting ADS-B aircraft signals. One device, three superpowers, plug & play.

Then there are accessories that extend capabilities:

• Flipper Zero — RF security research multi-tool. SubGHz, RFID, NFC, IR — works as an additional module feeding data to the game
• LILYGO T-Watch Ultra — a modest but capable substitute for those without an AIO. Supports NFC and WiFi wardriving on your wrist. Fewer features, but still in the game
• Biscuit — community-built portable wardriving devices, natively supported by WDGWars (integration in progress)
• Devices running Bruce Firmware (WDGWars fork) — my own fork of the popular Bruce Predatory Firmware for ESP32, with upload-to-platform baked in. Cardputer, M5Stick, any ESP32 that runs Bruce — all of it works straight from the device, no computer needed

The game is written almost entirely in Python — which means the barrier to entry for developers is low. We're counting on community growth and new plugins for additional accessories. Got an ESP32 with an antenna? A Raspberry Pi with a WiFi card? If you can generate a CSV with data — the platform will take it. And if you can write a Python plugin — the game will run it.

And thanks to an open REST API with documentation and examples in Python, C, Bash, and JavaScript — integrating your own apps, scripts, or firmware with Watch Dogs Go Wars is a matter of a few lines of code. Got your own project collecting data? Hook it up to our API and your data will appear on the global map alongside every other wardriver.

TEAM TERRITORY WARS

This is not a passive WiFi tracker. This is a war game for control over digital territory. Every Access Point on the map belongs to the team that last scanned it. Want to take enemy turf? Drive to their territory — physically, with your device — and scan the same networks. The system transfers ownership.

But it's not that simple. Teams can harden their AP with repeated scans. The more times your team scans the same point — the harder it is to capture. The enemy needs to attack multiple times to break through, while you can rebuild the defense with a single scan.

On the map, colored team zones grow and shrink in real-time. Captures are logged as events — you see who's attacking whom, how many AP were captured, where on the map the war is raging. Real strategy: who defends, who attacks, when to strike, when to retreat.

INTEGRATIONS

The platform keeps growing. The latest successful integration is Bruce Predatory Firmware — a popular ESP32 firmware used by the wardriving and security research community. Bruce scans WiFi/BLE networks, saves data in WiGLE CSV format, and can now upload directly to WDGoWars with one click — no computer, no cable, straight from the device.

How to set up WDGoWars upload in Bruce:

• 1. Register at wdgwars.pl and generate an API key in your profile
• 2. In Bruce: WiFi → Settings — configure your WiFi
• 3. In Bruce: GPS → Wardriving — scan networks
• 4. In Bruce: Files → SD → BruceWardriving — select a CSV file
• 5. Select WDGoWars Upload — enter your API key and done!

We're working on more integrations:

• Kismet — advanced WiFi/BLE/Zigbee sniffer for Linux
• Pwnagotchi — AI-driven wardriving companion
• Custom ESP32 firmware — anything that generates WiGLE CSV can upload data

Everything is connected through an open REST API — two upload methods (simple CSV multipart for firmware, advanced JSON with HMAC-SHA256 for apps), badge sync, territory feed, map data. Full documentation with code examples in Python, C, Bash, and JavaScript is available in the Help section after logging in.

DEVELOPER API

REST API for uploading data from any wardriving device. Two methods available:

Method 1: CSV Upload (simple)

Send a raw CSV/LOG file (WiGLE/Bruce format) as multipart. The server parses it. Ideal for firmware (Bruce, Kismet, Marauder).

Accepted format — WigleWifi-1.6 (generated by Bruce, Kismet, WiGLE app):

WigleWifi-1.6,appRelease=...,model=...,device=...,board=...,brand=...
MAC,SSID,AuthMode,FirstSeen,Channel,Frequency,RSSI,CurrentLatitude,CurrentLongitude,AltitudeMeters,AccuracyMeters,RCOIs,MfgrId,Type
AA:BB:CC:DD:EE:FF,MyNetwork,[WPA2_PSK],2026-04-09 12:00:00,6,2437,-45,52.2297,21.0122,120,10,,0,WIFI

curl -X POST "https://wdgwars.pl/api/upload-csv" \
  -H "X-API-Key: YOUR_64_CHAR_HEX_KEY" \
  -F "file=@wardriving.csv"

import requests

API_KEY = "your-64-char-hex-key"
with open("wardriving.csv", "rb") as f:
    resp = requests.post(
        "https://wdgwars.pl/api/upload-csv",
        headers={"X-API-Key": API_KEY},
        files={"file": ("wardriving.csv", f, "text/csv")}
    )
print(resp.json())

// Bruce / ESP32 — replace Wigle Upload with WDGoWars:
// 1. Open CSV from SD card (same file as for Wigle)
// 2. HTTP POST multipart/form-data to:
//    https://wdgwars.pl/api/upload-csv
// 3. Replace Basic Auth with header:
//    X-API-Key: <key from WDGoWars profile>
// 4. Form field: file = CSV contents
//
// Same as Wigle Upload — raw file, server parses
// the WigleWifi-1.6 format automatically.

Bruce Predatory Firmware

WDGoWars integration is already available — early build, pending inclusion in official Bruce. Upload directly from ESP32 — no computer needed. Download firmware

1. Generate an API key in your WDGoWars profile
2. In Bruce: WiFi → Settings — connect to WiFi
3. In Bruce: GPS → Wardriving — scan WiFi/BLE networks
4. In Bruce: Files → SD → BruceWardriving — select a CSV file
5. Select WDGoWars Upload — enter your API key and done!

Method 2: JSON Upload (advanced)

Full control — build JSON payload, sign with HMAC-SHA256. Ideal for games and desktop apps.

Code examples

import json, base64, hmac, hashlib, secrets, urllib.request

API_KEY = "your-64-char-hex-key-here"
URL = "https://wdgwars.pl/api/upload"

payload = {"networks": [{"bssid":"AA:BB:CC:DD:EE:FF","ssid":"MyWiFi",
  "auth":"WPA2","channel":6,"rssi":-45,"lat":52.23,"lon":21.01,
  "type":"WIFI","first_seen":"2026-04-05 12:00:00"}]}

data_b64 = base64.b64encode(json.dumps(payload).encode()).decode()
nonce = secrets.token_hex(8)
sig = hmac.new(API_KEY.encode(), (nonce + data_b64).encode(),
               hashlib.sha256).hexdigest()

body = json.dumps({"data": data_b64, "nonce": nonce, "sig": sig}).encode()
req = urllib.request.Request(URL, data=body, headers={
    "X-API-Key": API_KEY, "Content-Type": "application/json"})
resp = urllib.request.urlopen(req)
print(json.loads(resp.read()))

#!/bin/bash
API_KEY="your-key" URL="https://wdgwars.pl/api/upload"
DATA_B64=$(echo -n "$PAYLOAD" | base64 -w0)
NONCE=$(openssl rand -hex 8)
SIG=$(echo -n "${NONCE}${DATA_B64}" | openssl dgst -sha256 -hmac "$API_KEY" -hex | awk '{print $2}')
curl -X POST "$URL" -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  -d "{\"data\":\"$DATA_B64\",\"nonce\":\"$NONCE\",\"sig\":\"$SIG\"}"

// Node.js
const crypto = require('crypto');
const https = require('https');

const API_KEY = 'your-64-char-hex-key';
const payload = { networks: [{ bssid: 'AA:BB:CC:DD:EE:FF', ssid: 'MyWiFi',
  auth: 'WPA2', channel: 6, rssi: -50, lat: 52.23, lon: 21.01,
  type: 'WIFI', first_seen: '2026-04-09 12:00:00' }] };

const data_b64 = Buffer.from(JSON.stringify(payload)).toString('base64');
const nonce = crypto.randomBytes(8).toString('hex');
const sig = crypto.createHmac('sha256', API_KEY)
    .update(nonce + data_b64).digest('hex');

const body = JSON.stringify({ data: data_b64, nonce, sig });
const req = https.request({ hostname: 'wdgwars.pl', path: '/api/upload',
    method: 'POST', headers: { 'X-API-Key': API_KEY,
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(body) }
}, res => { let d=''; res.on('data',c=>d+=c);
    res.on('end',()=>console.log(JSON.parse(d))); });
req.write(body); req.end();

// ESP32 / Arduino — requires: ArduinoJson, WiFiClientSecure, mbedtls
// 1. Build JSON payload from scanner data
// 2. Base64 encode payload
// 3. Generate 16-char hex nonce (esp_random())
// 4. HMAC-SHA256(key=API_KEY, data=nonce+base64)
// 5. POST to https://wdgwars.pl/api/upload
//
// Full implementation in projectZero firmware:
// https://github.com/LOCOSP/projectZero

Method 3: User Info (for integrations)

Lightweight endpoint returning the logged-in user's stats. Used by third-party apps (e.g. Biscuit) to validate API keys and display user dashboards.

Response (JSON):

{
  "ok": true,
  "username": "locosp",
  "wifi": 37469,
  "ble": 2109,
  "aircraft": 22,
  "mesh": 93,
  "total": 39619,
  "badges": ["first_blood", "wifi_10k", "gang_leader", ...],
  "gang": "Watch Dogs OG's"
}

Invalid or revoked key → 401 {"ok":false,"error":"Invalid API key"}. Use this to validate the key when a user pastes it into your app.

Notes on duplicates & limits

• Max file size: 35 MB for /api/upload-csv
• Duplicates in the file are fine — multiple beacon captures of the same AP are merged into a single record with the strongest RSSI + averaged GPS (better trilateration). The response includes a merged_samples count.
• 1h cooldown per AP per user — scoring the same AP by the same user doesn't stack more than once an hour, but later scans still refine its position.
• Daily cap: 500,000 new APs per user per day (24h rolling window).
• Rate limit: 30 requests/minute per API key. Exceeding returns 429.

WHAT'S ON THE MAP

FOR CONTENT CREATORS

If you create content about cybersecurity, hardware hacking, wardriving, retro computing, or hacking:

• Looks insane — dark map, pulsing markers, glitch effects, simulated cyberattacks, gameplay video background
• Real hardware — not a pixel game, real devices, real walks through the city
• Community — teams, leaderboard, competition, badges
• Open API — anyone can integrate their device
• 100% legal — passive listening to publicly available data

BRANDING

Full name: WDGoWars (one word) — sometimes: Watch Dogs Go Wars, WDG, wdgwars. DO NOT use: WDGWars, Watch Dogs: Go Wars, WatchDogWars.

Official logo (PNG, transparent background)

Download logo

Palette (dark)

#f0abfc#00e5ff#a855f7#c4b5fd#0d1117

Usage rules:

• Do not modify the logo (no stretching, recoloring, adding text underneath)
• Minimum size: 64px wide (smaller → gorilla becomes unreadable)
• On light backgrounds — wrap it in a dark box or halo (logo is designed for dark mode)
• Favicon/icon without text: /static/favicon.ico

Hashtags: #wdgwars #wardriving #watchdogsgo

LINKS

COMMUNITY VIDEOS

Videos created by the community with the #wdgwars hashtag.

No videos yet — be the first! Add #wdgwars to your YouTube video.

FOR YOUTUBERS — HOW TO GET FEATURED 📡