WATCH DOGS GO WARS

WHAT IS THIS?

You walk out the door with a calculator-sized device. You stroll down the street — and it silently collects data about the wireless world around you. You come home, open the map, and see the digital footprint of your walk on a world map.

This is not a simulation. The data is real. Watch Dogs Go Wars is a wardriving platform connected to a retro game that turns wireless infrastructure exploration into a cyberpunk adventure.

Think Pokémon Go, but instead of catching fictional creatures — you scan the real world around you. Legally. Ethically. With style.

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 gangs 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

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.

GANG 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 gang 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. Gangs can harden their AP with repeated scans. The more times your gang 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 gang 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

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 — gangs, leaderboard, competition, badges
• Open API — anyone can integrate their device
• 100% legal — passive listening to publicly available data

LINKS

COMMUNITY VIDEOS

Videos created by the community with the #wdgwars hashtag.

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