2498 lines
105 KiB
C++
2498 lines
105 KiB
C++
/*
|
|
* Bluehound - Continuous BLE/Classic Bluetooth scanner with time-searchable logging
|
|
* Built for embedded devices with WiFi streaming support
|
|
*/
|
|
|
|
#include <simpleble/SimpleBLE.h>
|
|
#include <sqlite3.h>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <csignal>
|
|
#include <atomic>
|
|
#include <mutex>
|
|
#include <vector>
|
|
#include <set>
|
|
#include <map>
|
|
#include <cmath>
|
|
|
|
// HTTP server library - using cpp-httplib (single header)
|
|
#include "httplib.h"
|
|
|
|
// Classic Bluetooth support
|
|
#include "classic_bluetooth.h"
|
|
|
|
// Configuration
|
|
struct Config {
|
|
int scan_duration_ms = 5000; // Scan for 5 seconds per cycle
|
|
int scan_interval_ms = 1000; // Wait 1 second between scans
|
|
std::string db_path = "ble_scans.db";
|
|
int http_port = 8080;
|
|
bool enable_http_server = true;
|
|
int max_db_entries = 1000000; // Rotate after 1M entries
|
|
};
|
|
|
|
// Global state
|
|
std::atomic<bool> running(true);
|
|
std::mutex db_mutex;
|
|
std::set<std::string> enumerated_devices; // Track devices we've already enumerated
|
|
std::mutex enumerated_mutex;
|
|
Config config;
|
|
|
|
// Forward declarations
|
|
std::string get_timestamp();
|
|
|
|
// Signal handler for graceful shutdown
|
|
void signal_handler(int signal) {
|
|
std::cout << "\nReceived signal " << signal << ", shutting down gracefully..." << std::endl;
|
|
running = false;
|
|
}
|
|
|
|
// BLE UUID Decoder - Standard Services
|
|
std::string decode_service_uuid(const std::string& uuid) {
|
|
static const std::map<std::string, std::string> services = {
|
|
{"1800", "Generic Access"},
|
|
{"1801", "Generic Attribute"},
|
|
{"1804", "Tx Power"},
|
|
{"180A", "Device Information"},
|
|
{"180D", "Heart Rate"},
|
|
{"180F", "Battery Service"},
|
|
{"1810", "Blood Pressure"},
|
|
{"1812", "Human Interface Device"},
|
|
{"1816", "Cycling Speed and Cadence"},
|
|
{"1818", "Cycling Power"},
|
|
{"181A", "Environmental Sensing"},
|
|
{"181B", "Body Composition"},
|
|
{"181C", "User Data"},
|
|
{"181D", "Weight Scale"}
|
|
};
|
|
|
|
std::string upper_uuid = uuid;
|
|
std::transform(upper_uuid.begin(), upper_uuid.end(), upper_uuid.begin(), ::toupper);
|
|
|
|
// Extract 16-bit UUID from 128-bit format (0000XXXX-0000-1000-8000-00805f9b34fb)
|
|
if (upper_uuid.length() >= 8 && upper_uuid.substr(0, 4) == "0000") {
|
|
upper_uuid = upper_uuid.substr(4, 4);
|
|
} else if (upper_uuid.length() > 4) {
|
|
return ""; // Custom vendor UUID
|
|
}
|
|
|
|
auto it = services.find(upper_uuid);
|
|
return (it != services.end()) ? it->second : "";
|
|
}
|
|
|
|
// BLE UUID Decoder - Standard Characteristics
|
|
std::string decode_characteristic_uuid(const std::string& uuid) {
|
|
static const std::map<std::string, std::string> characteristics = {
|
|
{"2A00", "Device Name"},
|
|
{"2A01", "Appearance"},
|
|
{"2A04", "Peripheral Preferred Connection Parameters"},
|
|
{"2A05", "Service Changed"},
|
|
{"2A07", "Tx Power Level"},
|
|
{"2A19", "Battery Level"},
|
|
{"2A23", "System ID"},
|
|
{"2A24", "Model Number String"},
|
|
{"2A25", "Serial Number String"},
|
|
{"2A26", "Firmware Revision String"},
|
|
{"2A27", "Hardware Revision String"},
|
|
{"2A28", "Software Revision String"},
|
|
{"2A29", "Manufacturer Name String"},
|
|
{"2A37", "Heart Rate Measurement"},
|
|
{"2A38", "Body Sensor Location"},
|
|
{"2A49", "Blood Pressure Feature"},
|
|
{"2A4A", "HID Information"},
|
|
{"2A50", "PnP ID"},
|
|
{"2A6E", "Temperature"},
|
|
{"2A6F", "Humidity"},
|
|
{"2A9E", "Weight Measurement"}
|
|
};
|
|
|
|
std::string upper_uuid = uuid;
|
|
std::transform(upper_uuid.begin(), upper_uuid.end(), upper_uuid.begin(), ::toupper);
|
|
|
|
// Extract 16-bit UUID from 128-bit format (0000XXXX-0000-1000-8000-00805f9b34fb)
|
|
if (upper_uuid.length() >= 8 && upper_uuid.substr(0, 4) == "0000") {
|
|
upper_uuid = upper_uuid.substr(4, 4);
|
|
} else if (upper_uuid.length() > 4) {
|
|
return ""; // Custom vendor UUID
|
|
}
|
|
|
|
auto it = characteristics.find(upper_uuid);
|
|
return (it != characteristics.end()) ? it->second : "";
|
|
}
|
|
|
|
// Get characteristic description
|
|
std::string get_characteristic_description(const std::string& uuid) {
|
|
static const std::map<std::string, std::string> descriptions = {
|
|
{"2A19", "Battery charge level (0-100%)"},
|
|
{"2A00", "Human-readable device name"},
|
|
{"2A29", "Name of device manufacturer"},
|
|
{"2A24", "Device model number"},
|
|
{"2A26", "Firmware version"},
|
|
{"2A37", "Heart rate in beats per minute"},
|
|
{"2A6E", "Temperature in Celsius"},
|
|
{"2A6F", "Relative humidity percentage"},
|
|
{"2A50", "Product ID information"},
|
|
{"2A07", "Transmit power level"}
|
|
};
|
|
|
|
std::string upper_uuid = uuid;
|
|
std::transform(upper_uuid.begin(), upper_uuid.end(), upper_uuid.begin(), ::toupper);
|
|
|
|
// Extract 16-bit UUID from 128-bit format
|
|
if (upper_uuid.length() >= 8 && upper_uuid.substr(0, 4) == "0000") {
|
|
upper_uuid = upper_uuid.substr(4, 4);
|
|
} else if (upper_uuid.length() > 4) {
|
|
return "";
|
|
}
|
|
|
|
auto it = descriptions.find(upper_uuid);
|
|
return (it != descriptions.end()) ? it->second : "";
|
|
}
|
|
|
|
// Security Assessment Structure
|
|
struct Vulnerability {
|
|
std::string name;
|
|
std::string severity; // HIGH, MEDIUM, LOW
|
|
std::string description;
|
|
std::string cve;
|
|
};
|
|
|
|
struct SecurityAssessment {
|
|
std::string device_address;
|
|
std::string risk_level; // HIGH, MEDIUM, LOW, NONE
|
|
std::vector<Vulnerability> vulnerabilities;
|
|
std::vector<std::string> recommendations;
|
|
};
|
|
|
|
// Apple Continuity Data Structure
|
|
struct AppleContinuityData {
|
|
std::string device_type;
|
|
std::string device_model;
|
|
int battery_level;
|
|
bool battery_charging;
|
|
bool airpods_in_ear;
|
|
bool airpods_case_lid_open;
|
|
std::string airpods_case_battery;
|
|
std::string airpods_left_battery;
|
|
std::string airpods_right_battery;
|
|
std::string proximity_pairing_status;
|
|
std::string handoff_data;
|
|
std::string nearby_action;
|
|
std::string raw_data;
|
|
};
|
|
|
|
// Decode Apple Continuity/Proximity data
|
|
AppleContinuityData decode_apple_continuity(const SimpleBLE::ByteArray& data) {
|
|
AppleContinuityData result;
|
|
result.battery_level = -1;
|
|
result.battery_charging = false;
|
|
result.airpods_in_ear = false;
|
|
result.airpods_case_lid_open = false;
|
|
|
|
if (data.empty()) return result;
|
|
|
|
// Convert to hex string for analysis
|
|
std::stringstream hex_stream;
|
|
for (uint8_t byte : data) {
|
|
hex_stream << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
|
|
}
|
|
result.raw_data = hex_stream.str();
|
|
|
|
// Apple uses different message types in manufacturer data
|
|
if (data.size() < 2) return result;
|
|
|
|
uint8_t message_type = data[0];
|
|
|
|
// Type 0x02: Handoff
|
|
if (message_type == 0x02) {
|
|
result.handoff_data = "Handoff enabled (clipboard, call switching)";
|
|
}
|
|
// Type 0x05: AirDrop
|
|
else if (message_type == 0x05) {
|
|
result.handoff_data = "AirDrop discoverable";
|
|
}
|
|
// Type 0x07: AirPods/AirTag
|
|
else if (message_type == 0x07 && data.size() >= 27) {
|
|
// AirPods status
|
|
result.device_type = "AirPods";
|
|
|
|
uint8_t status = data[6];
|
|
result.airpods_in_ear = (status & 0x01) != 0;
|
|
result.airpods_case_lid_open = (status & 0x02) != 0;
|
|
|
|
// Battery levels (4-bit each, 0-10 scale)
|
|
uint8_t battery_data = data[7];
|
|
result.battery_level = (battery_data >> 4) * 10; // Left AirPod
|
|
|
|
if (data.size() >= 10) {
|
|
int left = (data[8] >> 4) & 0x0F;
|
|
int right = data[8] & 0x0F;
|
|
int case_battery = (data[9] >> 4) & 0x0F;
|
|
|
|
if (left <= 10) result.airpods_left_battery = std::to_string(left * 10) + "%";
|
|
if (right <= 10) result.airpods_right_battery = std::to_string(right * 10) + "%";
|
|
if (case_battery <= 10) result.airpods_case_battery = std::to_string(case_battery * 10) + "%";
|
|
}
|
|
}
|
|
// Type 0x09: AirPlay
|
|
else if (message_type == 0x09) {
|
|
result.handoff_data = "AirPlay target available";
|
|
}
|
|
// Type 0x0C: Proximity Pairing
|
|
else if (message_type == 0x0C && data.size() >= 3) {
|
|
result.proximity_pairing_status = "Proximity pairing active";
|
|
uint8_t device_type_byte = data[2];
|
|
|
|
switch (device_type_byte) {
|
|
case 0x01: result.device_type = "iPhone"; break;
|
|
case 0x02: result.device_type = "iPad"; break;
|
|
case 0x03: result.device_type = "Apple Watch"; break;
|
|
case 0x0E: result.device_type = "AirPods"; break;
|
|
case 0x0F: result.device_type = "AirPods Pro"; break;
|
|
case 0x13: result.device_type = "AirPods Max"; break;
|
|
default: result.device_type = "Unknown Apple Device"; break;
|
|
}
|
|
}
|
|
// Type 0x10: Nearby Action
|
|
else if (message_type == 0x10) {
|
|
result.nearby_action = "Device requesting action (AirTag, FindMy)";
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Check if service list contains a specific service
|
|
bool has_service(const std::vector<std::string>& services, const std::string& target) {
|
|
for (const auto& service : services) {
|
|
std::string lower_service = service;
|
|
std::string lower_target = target;
|
|
std::transform(lower_service.begin(), lower_service.end(), lower_service.begin(), ::tolower);
|
|
std::transform(lower_target.begin(), lower_target.end(), lower_target.begin(), ::tolower);
|
|
|
|
if (lower_service.find(lower_target) != std::string::npos) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Assess device security based on services and characteristics
|
|
SecurityAssessment assess_device_security(
|
|
const std::string& address,
|
|
const std::vector<std::string>& services,
|
|
bool is_paired,
|
|
bool is_connectable,
|
|
const std::string& device_name
|
|
) {
|
|
SecurityAssessment assessment;
|
|
assessment.device_address = address;
|
|
|
|
// Check for OBEX services (HIGH risk - file transfer)
|
|
if (has_service(services, "obex object push") || has_service(services, "1105")) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Unsecured File Transfer",
|
|
"HIGH",
|
|
"Device accepts file transfers without authentication",
|
|
"CVE-2020-13543"
|
|
});
|
|
assessment.recommendations.push_back("Disable OBEX Object Push service");
|
|
assessment.recommendations.push_back("Enable PIN protection for file transfers");
|
|
}
|
|
|
|
if (has_service(services, "obex file transfer") || has_service(services, "1106")) {
|
|
assessment.vulnerabilities.push_back({
|
|
"File System Access",
|
|
"HIGH",
|
|
"Full filesystem access via OBEX FTP",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Disable OBEX File Transfer service");
|
|
assessment.recommendations.push_back("Restrict filesystem access permissions");
|
|
}
|
|
|
|
// Check for Serial Port service (MEDIUM risk)
|
|
if (has_service(services, "serial port") || has_service(services, "1101")) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Open Serial Port",
|
|
"MEDIUM",
|
|
"Serial port service available without authentication",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Disable unused serial port services");
|
|
assessment.recommendations.push_back("Require authentication for SPP connections");
|
|
}
|
|
|
|
// Check for HID service (MEDIUM risk - input injection)
|
|
if (has_service(services, "human interface device") || has_service(services, "1812")) {
|
|
assessment.vulnerabilities.push_back({
|
|
"HID Service Exposed",
|
|
"MEDIUM",
|
|
"HID service allows input injection attacks",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Verify HID pairing before accepting connections");
|
|
assessment.recommendations.push_back("Disable HID if not needed");
|
|
}
|
|
|
|
// Check for Audio services (LOW risk - eavesdropping)
|
|
if (has_service(services, "audio") || has_service(services, "110a") || has_service(services, "110b")) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Audio Streaming",
|
|
"LOW",
|
|
"Audio service allows unauthorized streaming",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Require pairing for audio connections");
|
|
assessment.recommendations.push_back("Set device to non-discoverable when not in use");
|
|
}
|
|
|
|
// Check for unpaired but connectable devices (LOW risk)
|
|
if (!is_paired && is_connectable) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Discoverable Mode",
|
|
"LOW",
|
|
"Device is discoverable and not paired",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Set device to non-discoverable mode");
|
|
assessment.recommendations.push_back("Enable pairing timeout");
|
|
}
|
|
|
|
// Check for Android devices (potential BlueBorne)
|
|
std::string lower_name = device_name;
|
|
std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
|
|
if (lower_name.find("android") != std::string::npos && services.size() > 5) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Potential BlueBorne Vulnerability",
|
|
"HIGH",
|
|
"Android device may be vulnerable to RCE if unpatched",
|
|
"CVE-2017-1000251"
|
|
});
|
|
assessment.recommendations.push_back("Update device to latest firmware immediately");
|
|
assessment.recommendations.push_back("Apply BlueBorne security patches");
|
|
}
|
|
|
|
// Calculate overall risk level
|
|
bool has_high = false;
|
|
bool has_medium = false;
|
|
|
|
for (const auto& vuln : assessment.vulnerabilities) {
|
|
if (vuln.severity == "HIGH") has_high = true;
|
|
if (vuln.severity == "MEDIUM") has_medium = true;
|
|
}
|
|
|
|
if (has_high) {
|
|
assessment.risk_level = "HIGH";
|
|
} else if (has_medium) {
|
|
assessment.risk_level = "MEDIUM";
|
|
} else if (!assessment.vulnerabilities.empty()) {
|
|
assessment.risk_level = "LOW";
|
|
} else {
|
|
assessment.risk_level = "NONE";
|
|
}
|
|
|
|
// Add general recommendations for high/medium risk
|
|
if (assessment.risk_level == "HIGH" || assessment.risk_level == "MEDIUM") {
|
|
assessment.recommendations.push_back("Disable Bluetooth when not in use");
|
|
assessment.recommendations.push_back("Keep device firmware updated");
|
|
}
|
|
|
|
// Remove duplicate recommendations
|
|
std::sort(assessment.recommendations.begin(), assessment.recommendations.end());
|
|
assessment.recommendations.erase(
|
|
std::unique(assessment.recommendations.begin(), assessment.recommendations.end()),
|
|
assessment.recommendations.end()
|
|
);
|
|
|
|
return assessment;
|
|
}
|
|
|
|
// Passive vulnerability assessment (no connection required)
|
|
SecurityAssessment assess_device_passive(
|
|
const std::string& address,
|
|
const std::string& device_name,
|
|
const std::string& company_name,
|
|
bool is_connectable,
|
|
const std::string& manufacturer_data
|
|
) {
|
|
SecurityAssessment assessment;
|
|
assessment.device_address = address;
|
|
|
|
std::string lower_name = device_name;
|
|
std::string lower_company = company_name;
|
|
std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), ::tolower);
|
|
std::transform(lower_company.begin(), lower_company.end(), lower_company.begin(), ::tolower);
|
|
|
|
// Known vulnerable devices by name/manufacturer
|
|
if (lower_name.find("android") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Potential BlueBorne Target",
|
|
"HIGH",
|
|
"Android device potentially vulnerable to BlueBorne if unpatched (2017)",
|
|
"CVE-2017-1000251"
|
|
});
|
|
assessment.recommendations.push_back("Update Android to latest security patches");
|
|
assessment.recommendations.push_back("Verify BlueBorne fix is applied");
|
|
}
|
|
|
|
// Old Samsung devices
|
|
if (lower_company.find("samsung") != std::string::npos &&
|
|
(lower_name.find("galaxy s") != std::string::npos || lower_name.find("galaxy note") != std::string::npos)) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Legacy Samsung Device",
|
|
"MEDIUM",
|
|
"Older Samsung devices had Bluetooth vulnerabilities in 2019-2020",
|
|
"CVE-2019-16400"
|
|
});
|
|
assessment.recommendations.push_back("Check for firmware updates");
|
|
}
|
|
|
|
// Apple devices with older iOS
|
|
if (lower_company.find("apple") != std::string::npos &&
|
|
(lower_name.find("iphone") != std::string::npos || lower_name.find("ipad") != std::string::npos)) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Apple BLE Privacy Concern",
|
|
"LOW",
|
|
"Apple devices may leak tracking information via BLE advertising",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Keep iOS updated");
|
|
assessment.recommendations.push_back("Disable Bluetooth when not in use");
|
|
}
|
|
|
|
// Fitness trackers - common privacy issues
|
|
if (lower_name.find("fitbit") != std::string::npos ||
|
|
lower_name.find("garmin") != std::string::npos ||
|
|
lower_name.find("xiaomi") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Fitness Tracker Privacy",
|
|
"LOW",
|
|
"Fitness devices may broadcast health data in clear text",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Check privacy settings in companion app");
|
|
}
|
|
|
|
// IoT devices - typically less secure
|
|
if (lower_name.find("smart") != std::string::npos ||
|
|
lower_name.find("lock") != std::string::npos ||
|
|
lower_name.find("sensor") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"IoT Device Security",
|
|
"MEDIUM",
|
|
"IoT devices often have outdated firmware and weak security",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Update firmware regularly");
|
|
assessment.recommendations.push_back("Check manufacturer security bulletins");
|
|
}
|
|
|
|
// Devices that are connectable but not bonded - easy targets
|
|
if (is_connectable) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Connectable Without Pairing",
|
|
"LOW",
|
|
"Device accepts connections without requiring pairing first",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Enable pairing requirements");
|
|
assessment.recommendations.push_back("Set device to non-discoverable when not in use");
|
|
}
|
|
|
|
// Check for weak random address (privacy issue)
|
|
if (address.find("00:00:00") != std::string::npos ||
|
|
address.find("FF:FF:FF") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Weak Random Address",
|
|
"LOW",
|
|
"Device may not properly randomize Bluetooth address",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Check device privacy settings");
|
|
}
|
|
|
|
// Calculate risk level
|
|
bool has_high = false;
|
|
bool has_medium = false;
|
|
for (const auto& vuln : assessment.vulnerabilities) {
|
|
if (vuln.severity == "HIGH") has_high = true;
|
|
if (vuln.severity == "MEDIUM") has_medium = true;
|
|
}
|
|
|
|
if (has_high) {
|
|
assessment.risk_level = "HIGH";
|
|
} else if (has_medium) {
|
|
assessment.risk_level = "MEDIUM";
|
|
} else if (!assessment.vulnerabilities.empty()) {
|
|
assessment.risk_level = "LOW";
|
|
} else {
|
|
assessment.risk_level = "NONE";
|
|
}
|
|
|
|
// Remove duplicate recommendations
|
|
std::sort(assessment.recommendations.begin(), assessment.recommendations.end());
|
|
assessment.recommendations.erase(
|
|
std::unique(assessment.recommendations.begin(), assessment.recommendations.end()),
|
|
assessment.recommendations.end()
|
|
);
|
|
|
|
return assessment;
|
|
}
|
|
|
|
// Active vulnerability assessment (attempts connection)
|
|
SecurityAssessment assess_device_active(
|
|
sqlite3* db,
|
|
SimpleBLE::Peripheral& peripheral,
|
|
const SecurityAssessment& passive_assessment
|
|
) {
|
|
SecurityAssessment assessment = passive_assessment;
|
|
std::string address = peripheral.address();
|
|
|
|
try {
|
|
std::cout << "[ACTIVE SCAN] Testing " << address << " for vulnerabilities..." << std::endl;
|
|
|
|
// Test 1: Can we connect without pairing?
|
|
bool connected_unpaired = false;
|
|
if (!peripheral.is_paired()) {
|
|
try {
|
|
peripheral.connect();
|
|
if (peripheral.is_connected()) {
|
|
connected_unpaired = true;
|
|
assessment.vulnerabilities.push_back({
|
|
"Connects Without Pairing",
|
|
"MEDIUM",
|
|
"Device accepts connections without requiring pairing/authentication",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Require pairing before allowing connections");
|
|
std::cout << "[ACTIVE SCAN] ✓ Connected without pairing" << std::endl;
|
|
}
|
|
} catch (...) {
|
|
std::cout << "[ACTIVE SCAN] ✗ Connection requires pairing" << std::endl;
|
|
}
|
|
}
|
|
|
|
// Test 2: Enumerate services (if connected)
|
|
if (peripheral.is_connected()) {
|
|
try {
|
|
auto services = peripheral.services();
|
|
std::vector<std::string> service_names;
|
|
|
|
for (auto& service : services) {
|
|
std::string service_uuid = service.uuid();
|
|
std::string service_name = decode_service_uuid(service_uuid);
|
|
if (!service_name.empty()) {
|
|
service_names.push_back(service_name);
|
|
}
|
|
service_names.push_back(service_uuid);
|
|
|
|
// Check for OBEX services
|
|
if (service_uuid.find("1105") != std::string::npos ||
|
|
service_uuid.find("1106") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"OBEX Service Accessible",
|
|
"HIGH",
|
|
"File transfer service accessible without authentication",
|
|
"CVE-2020-13543"
|
|
});
|
|
assessment.recommendations.push_back("Disable OBEX services");
|
|
std::cout << "[ACTIVE SCAN] ✓ OBEX service found" << std::endl;
|
|
}
|
|
|
|
// Check for Serial Port
|
|
if (service_uuid.find("1101") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Serial Port Accessible",
|
|
"MEDIUM",
|
|
"Serial port service accessible without authentication",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Disable serial port or require authentication");
|
|
std::cout << "[ACTIVE SCAN] ✓ Serial Port found" << std::endl;
|
|
}
|
|
|
|
// Check for HID
|
|
if (service_uuid.find("1812") != std::string::npos) {
|
|
assessment.vulnerabilities.push_back({
|
|
"HID Service Accessible",
|
|
"MEDIUM",
|
|
"Keyboard/mouse service accessible - potential input injection",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Verify HID pairing requirements");
|
|
std::cout << "[ACTIVE SCAN] ✓ HID service found" << std::endl;
|
|
}
|
|
}
|
|
|
|
// Test 3: Try to read characteristics without pairing
|
|
if (connected_unpaired && !services.empty()) {
|
|
int readable_without_auth = 0;
|
|
for (auto& service : services) {
|
|
auto characteristics = service.characteristics();
|
|
for (auto& characteristic : characteristics) {
|
|
if (characteristic.can_read()) {
|
|
try {
|
|
SimpleBLE::ByteArray data = peripheral.read(
|
|
SimpleBLE::BluetoothUUID(service.uuid()),
|
|
SimpleBLE::BluetoothUUID(characteristic.uuid())
|
|
);
|
|
readable_without_auth++;
|
|
} catch (...) {
|
|
// Read failed - good, requires auth
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (readable_without_auth > 0) {
|
|
assessment.vulnerabilities.push_back({
|
|
"Unauthenticated Characteristic Access",
|
|
"HIGH",
|
|
std::string("Can read ") + std::to_string(readable_without_auth) +
|
|
" characteristics without authentication",
|
|
""
|
|
});
|
|
assessment.recommendations.push_back("Enable authentication for all characteristics");
|
|
std::cout << "[ACTIVE SCAN] ✓ " << readable_without_auth
|
|
<< " characteristics readable without auth" << std::endl;
|
|
}
|
|
}
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "[ACTIVE SCAN] Error enumerating services: " << e.what() << std::endl;
|
|
}
|
|
|
|
// Disconnect after testing
|
|
try {
|
|
peripheral.disconnect();
|
|
} catch (...) {}
|
|
}
|
|
|
|
std::cout << "[ACTIVE SCAN] Complete for " << address << std::endl;
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "[ACTIVE SCAN] Error: " << e.what() << std::endl;
|
|
}
|
|
|
|
// Recalculate risk level
|
|
bool has_high = false;
|
|
bool has_medium = false;
|
|
for (const auto& vuln : assessment.vulnerabilities) {
|
|
if (vuln.severity == "HIGH") has_high = true;
|
|
if (vuln.severity == "MEDIUM") has_medium = true;
|
|
}
|
|
|
|
if (has_high) {
|
|
assessment.risk_level = "HIGH";
|
|
} else if (has_medium) {
|
|
assessment.risk_level = "MEDIUM";
|
|
} else if (!assessment.vulnerabilities.empty()) {
|
|
assessment.risk_level = "LOW";
|
|
} else {
|
|
assessment.risk_level = "NONE";
|
|
}
|
|
|
|
// Remove duplicate vulnerabilities and recommendations
|
|
std::sort(assessment.recommendations.begin(), assessment.recommendations.end());
|
|
assessment.recommendations.erase(
|
|
std::unique(assessment.recommendations.begin(), assessment.recommendations.end()),
|
|
assessment.recommendations.end()
|
|
);
|
|
|
|
return assessment;
|
|
}
|
|
|
|
// Classic Bluetooth vulnerability assessment
|
|
SecurityAssessment assess_classic_device(const ClassicBluetooth::ClassicDevice& device) {
|
|
SecurityAssessment assessment;
|
|
assessment.device_address = device.address;
|
|
assessment.risk_level = "NONE";
|
|
|
|
// Check for OBEX services (file transfer without auth)
|
|
for (const auto& service : device.services) {
|
|
if (service.uuid == "1105") { // OBEX Object Push
|
|
Vulnerability vuln;
|
|
vuln.name = "OBEX Object Push Service";
|
|
vuln.severity = "HIGH";
|
|
vuln.description = "Device accepts file transfers without authentication via OBEX Object Push";
|
|
vuln.cve = "CVE-2020-13543";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Disable OBEX Object Push service");
|
|
assessment.recommendations.push_back("Enable PIN protection for file transfers");
|
|
}
|
|
|
|
if (service.uuid == "1106") { // OBEX File Transfer
|
|
Vulnerability vuln;
|
|
vuln.name = "OBEX File Transfer Service";
|
|
vuln.severity = "HIGH";
|
|
vuln.description = "Full filesystem access available via OBEX FTP without proper authentication";
|
|
vuln.cve = "CVE-2020-13543";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Disable OBEX File Transfer service");
|
|
assessment.recommendations.push_back("Restrict filesystem access permissions");
|
|
}
|
|
|
|
if (service.uuid == "1101") { // Serial Port Profile (SPP)
|
|
Vulnerability vuln;
|
|
vuln.name = "Serial Port Profile Exposed";
|
|
vuln.severity = "MEDIUM";
|
|
vuln.description = "Serial port service allows unauthorized command execution";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Disable unused Serial Port services");
|
|
assessment.recommendations.push_back("Require authentication for SPP connections");
|
|
}
|
|
|
|
if (service.uuid == "1812") { // HID Service
|
|
Vulnerability vuln;
|
|
vuln.name = "HID Service Accessible";
|
|
vuln.severity = "MEDIUM";
|
|
vuln.description = "Human Interface Device service allows input injection attacks";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Verify HID pairing before accepting connections");
|
|
assessment.recommendations.push_back("Disable HID if not needed");
|
|
}
|
|
|
|
if (service.uuid == "1103") { // Dialup Networking
|
|
Vulnerability vuln;
|
|
vuln.name = "Dialup Networking Service";
|
|
vuln.severity = "LOW";
|
|
vuln.description = "Legacy DUN service may have security weaknesses";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Disable DUN if not actively used");
|
|
}
|
|
}
|
|
|
|
// Check for Android devices (BlueBorne risk)
|
|
if (device.device_class.major_class == "Phone" && device.device_class.minor_class == "Smartphone") {
|
|
// Check if device name suggests Android
|
|
std::string name_lower = device.name;
|
|
std::transform(name_lower.begin(), name_lower.end(), name_lower.begin(), ::tolower);
|
|
|
|
if (name_lower.find("android") != std::string::npos ||
|
|
name_lower.find("galaxy") != std::string::npos ||
|
|
name_lower.find("pixel") != std::string::npos) {
|
|
Vulnerability vuln;
|
|
vuln.name = "Potential BlueBorne Target";
|
|
vuln.severity = "HIGH";
|
|
vuln.description = "Android device may be vulnerable to BlueBorne remote code execution if unpatched";
|
|
vuln.cve = "CVE-2017-1000251";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Update Android to latest security patches");
|
|
assessment.recommendations.push_back("Verify BlueBorne patches are applied");
|
|
}
|
|
}
|
|
|
|
// Check for IoT/Smart devices
|
|
if (device.device_class.major_class == "Peripheral" || device.device_class.major_class == "Toy") {
|
|
Vulnerability vuln;
|
|
vuln.name = "IoT Device Security Risk";
|
|
vuln.severity = "MEDIUM";
|
|
vuln.description = "IoT and peripheral devices often have outdated firmware and weak security";
|
|
assessment.vulnerabilities.push_back(vuln);
|
|
assessment.recommendations.push_back("Check for firmware updates");
|
|
assessment.recommendations.push_back("Review device pairing and authentication settings");
|
|
}
|
|
|
|
// Calculate risk level
|
|
for (const auto& vuln : assessment.vulnerabilities) {
|
|
if (vuln.severity == "HIGH") {
|
|
assessment.risk_level = "HIGH";
|
|
break;
|
|
} else if (vuln.severity == "MEDIUM" && assessment.risk_level != "HIGH") {
|
|
assessment.risk_level = "MEDIUM";
|
|
} else if (vuln.severity == "LOW" && assessment.risk_level == "NONE") {
|
|
assessment.risk_level = "LOW";
|
|
}
|
|
}
|
|
|
|
// Add general recommendations for Classic BT
|
|
if (!assessment.vulnerabilities.empty()) {
|
|
assessment.recommendations.push_back("Disable Bluetooth when not in use");
|
|
assessment.recommendations.push_back("Keep device firmware updated");
|
|
assessment.recommendations.push_back("Set device to non-discoverable mode when not pairing");
|
|
}
|
|
|
|
// Remove duplicate recommendations
|
|
std::sort(assessment.recommendations.begin(), assessment.recommendations.end());
|
|
assessment.recommendations.erase(
|
|
std::unique(assessment.recommendations.begin(), assessment.recommendations.end()),
|
|
assessment.recommendations.end()
|
|
);
|
|
|
|
return assessment;
|
|
}
|
|
|
|
// Store security assessment in database
|
|
void store_security_assessment(sqlite3* db, const SecurityAssessment& assessment) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
// Convert vulnerabilities to JSON string
|
|
std::stringstream vulns_json;
|
|
vulns_json << "[";
|
|
for (size_t i = 0; i < assessment.vulnerabilities.size(); i++) {
|
|
if (i > 0) vulns_json << ",";
|
|
vulns_json << "{\"name\":\"" << assessment.vulnerabilities[i].name << "\","
|
|
<< "\"severity\":\"" << assessment.vulnerabilities[i].severity << "\","
|
|
<< "\"description\":\"" << assessment.vulnerabilities[i].description << "\"";
|
|
if (!assessment.vulnerabilities[i].cve.empty()) {
|
|
vulns_json << ",\"cve\":\"" << assessment.vulnerabilities[i].cve << "\"";
|
|
}
|
|
vulns_json << "}";
|
|
}
|
|
vulns_json << "]";
|
|
|
|
// Convert recommendations to JSON array
|
|
std::stringstream recs_json;
|
|
recs_json << "[";
|
|
for (size_t i = 0; i < assessment.recommendations.size(); i++) {
|
|
if (i > 0) recs_json << ",";
|
|
recs_json << "\"" << assessment.recommendations[i] << "\"";
|
|
}
|
|
recs_json << "]";
|
|
|
|
const char* upsert_sql = R"(
|
|
INSERT INTO security_assessments (device_address, risk_level, vulnerabilities, recommendations, last_assessed)
|
|
VALUES (?, ?, ?, ?, datetime('now'))
|
|
ON CONFLICT(device_address)
|
|
DO UPDATE SET risk_level = excluded.risk_level,
|
|
vulnerabilities = excluded.vulnerabilities,
|
|
recommendations = excluded.recommendations,
|
|
last_assessed = datetime('now');
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, upsert_sql, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, assessment.device_address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, assessment.risk_level.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, vulns_json.str().c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 4, recs_json.str().c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
}
|
|
|
|
// Map company ID to company name
|
|
std::string get_company_name(uint16_t company_id) {
|
|
static const std::map<uint16_t, std::string> companies = {
|
|
{0x0001, "Nokia"}, {0x0002, "Intel"}, {0x0004, "TDK"},
|
|
{0x0006, "Microsoft"}, {0x0007, "Lucent"}, {0x0008, "Motorola"},
|
|
{0x0009, "Infineon"}, {0x000A, "Qualcomm"}, {0x000B, "Silicon Wave"},
|
|
{0x000C, "Digianswer"}, {0x000D, "Texas Instruments"}, {0x000F, "Broadcom"},
|
|
{0x0012, "CSR"}, {0x0013, "Atmel"}, {0x0014, "Mitsubishi"},
|
|
{0x0015, "RTX"}, {0x0018, "GCT Semiconductor"}, {0x0019, "Marvell"},
|
|
{0x001D, "Sony"}, {0x001E, "Hanback"}, {0x0020, "ST Microelectronics"},
|
|
{0x0025, "NXP"}, {0x002E, "Plantronics"}, {0x0030, "Dynastream"},
|
|
{0x0031, "Timex"}, {0x0039, "Bose"}, {0x003A, "Sony Ericsson"},
|
|
{0x003C, "Harman"}, {0x003D, "NXP Semiconductors"}, {0x0046, "MediaTek"},
|
|
{0x004C, "Apple"}, {0x004E, "LG Electronics"}, {0x0050, "Huawei"},
|
|
{0x005B, "Toshiba"}, {0x005D, "Polar Electro"}, {0x0067, "HP"},
|
|
{0x0075, "Samsung"}, {0x007C, "HTC"}, {0x0080, "Lenovo"},
|
|
{0x00E0, "Google"}, {0x00E5, "Garmin"}, {0x0106, "Xiaomi"},
|
|
{0x0117, "Fitbit"}, {0x0131, "Tile"}, {0x0157, "Xiaomi"},
|
|
{0x0171, "Amazon"}, {0x01A0, "OnePlus"}, {0x0276, "Fitbit"},
|
|
{0x02E5, "Garmin"}, {0x0499, "Ruuvi Innovations"}
|
|
};
|
|
|
|
auto it = companies.find(company_id);
|
|
return (it != companies.end()) ? it->second : "Unknown";
|
|
}
|
|
|
|
// Calculate estimated distance from TX power and RSSI
|
|
double calculate_distance(int16_t tx_power, int16_t rssi) {
|
|
// If TX power is invalid or not advertised, use RSSI-only estimation
|
|
if (tx_power == -32768 || tx_power == 0) {
|
|
// Empirical RSSI to distance mapping (calibrated for typical BLE devices at 0 dBm TX)
|
|
// Based on real-world measurements
|
|
if (rssi >= -35) return 0.5; // Immediate proximity (< 0.5m)
|
|
if (rssi >= -45) return 1.0; // Very close (0.5-1m)
|
|
if (rssi >= -55) return 2.0; // Close (1-2m)
|
|
if (rssi >= -65) return 5.0; // Near (2-5m)
|
|
if (rssi >= -75) return 10.0; // Medium (5-10m)
|
|
if (rssi >= -85) return 20.0; // Far (10-20m)
|
|
return 30.0; // Very far (>20m)
|
|
}
|
|
|
|
// If TX power is available, use path loss formula
|
|
// Formula: distance = 10 ^ ((TX_Power - RSSI) / (10 * N))
|
|
// N = 2.0 for free space, 3.0-4.0 for indoor with obstacles
|
|
const double N = 2.0; // More accurate for typical indoor environments
|
|
|
|
double distance = std::pow(10.0, (tx_power - rssi) / (10.0 * N));
|
|
return distance;
|
|
}
|
|
|
|
// Get address type as string
|
|
std::string get_address_type_string(SimpleBLE::BluetoothAddressType type) {
|
|
switch (type) {
|
|
case SimpleBLE::BluetoothAddressType::PUBLIC:
|
|
return "PUBLIC";
|
|
case SimpleBLE::BluetoothAddressType::RANDOM:
|
|
return "RANDOM";
|
|
default:
|
|
return "UNSPECIFIED";
|
|
}
|
|
}
|
|
|
|
// Enumerate characteristics for a connected device
|
|
bool enumerate_characteristics(sqlite3* db, SimpleBLE::Peripheral& peripheral) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string address = peripheral.address();
|
|
std::string name = peripheral.identifier();
|
|
|
|
try {
|
|
auto services = peripheral.services();
|
|
|
|
for (auto& service : services) {
|
|
std::string service_uuid = service.uuid();
|
|
auto characteristics = service.characteristics();
|
|
|
|
for (auto& characteristic : characteristics) {
|
|
std::string char_uuid = characteristic.uuid();
|
|
|
|
// Build properties string
|
|
std::stringstream props;
|
|
bool can_read = characteristic.can_read();
|
|
bool can_write = characteristic.can_write_request() || characteristic.can_write_command();
|
|
bool can_notify = characteristic.can_notify();
|
|
bool can_indicate = characteristic.can_indicate();
|
|
|
|
if (can_read) props << "READ,";
|
|
if (can_write) props << "WRITE,";
|
|
if (can_notify) props << "NOTIFY,";
|
|
if (can_indicate) props << "INDICATE,";
|
|
|
|
std::string properties = props.str();
|
|
if (!properties.empty()) {
|
|
properties.pop_back(); // Remove trailing comma
|
|
}
|
|
|
|
// Insert into database
|
|
const char* insert_sql = R"(
|
|
INSERT OR REPLACE INTO device_characteristics
|
|
(device_address, device_name, service_uuid, characteristic_uuid, properties)
|
|
VALUES (?, ?, ?, ?, ?);
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
int rc = sqlite3_prepare_v2(db, insert_sql, -1, &stmt, nullptr);
|
|
if (rc == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, service_uuid.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 4, char_uuid.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 5, properties.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::cout << "[" << get_timestamp() << "] Enumerated characteristics for " << address << std::endl;
|
|
return true;
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error enumerating characteristics for " << address << ": " << e.what() << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Connect to device and enumerate characteristics (runs in background)
|
|
void connect_and_enumerate(sqlite3* db, SimpleBLE::Peripheral peripheral) {
|
|
std::string address = peripheral.address();
|
|
|
|
try {
|
|
std::cout << "[" << get_timestamp() << "] Attempting to connect to " << address << "..." << std::endl;
|
|
|
|
peripheral.connect();
|
|
|
|
if (peripheral.is_connected()) {
|
|
std::cout << "[" << get_timestamp() << "] Connected to " << address << std::endl;
|
|
|
|
enumerate_characteristics(db, peripheral);
|
|
|
|
// Run ACTIVE security assessment after enumeration
|
|
try {
|
|
// First, get passive assessment from database
|
|
SecurityAssessment passive_assessment;
|
|
passive_assessment.device_address = address;
|
|
passive_assessment.risk_level = "NONE";
|
|
|
|
// Load existing passive assessment if available
|
|
{
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
const char* query = "SELECT risk_level, vulnerabilities FROM security_assessments WHERE device_address = ?;";
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
passive_assessment.risk_level = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
|
// Parse vulnerabilities JSON if needed
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
}
|
|
|
|
// Perform active assessment
|
|
SecurityAssessment assessment = assess_device_active(db, peripheral, passive_assessment);
|
|
|
|
store_security_assessment(db, assessment);
|
|
std::cout << "[" << get_timestamp() << "] Active security assessment: " << address
|
|
<< " - Risk: " << assessment.risk_level
|
|
<< " (" << assessment.vulnerabilities.size() << " vulnerabilities)" << std::endl;
|
|
|
|
// Try to extract additional tracking information
|
|
try {
|
|
std::cout << "[INFO EXTRACT] Attempting to read device information..." << std::endl;
|
|
|
|
std::string manufacturer_name = "";
|
|
std::string model_number = "";
|
|
std::string firmware_version = "";
|
|
std::string hardware_version = "";
|
|
std::string serial_number = "";
|
|
|
|
// Look for Device Information Service (0x180A)
|
|
auto services = peripheral.services();
|
|
for (auto& service : services) {
|
|
std::string service_uuid = service.uuid();
|
|
|
|
// Device Information Service
|
|
if (service_uuid.find("180a") != std::string::npos ||
|
|
service_uuid.find("180A") != std::string::npos) {
|
|
|
|
auto characteristics = service.characteristics();
|
|
for (auto& characteristic : characteristics) {
|
|
std::string char_uuid = characteristic.uuid();
|
|
|
|
try {
|
|
if (characteristic.can_read()) {
|
|
SimpleBLE::ByteArray data = peripheral.read(
|
|
SimpleBLE::BluetoothUUID(service.uuid()),
|
|
SimpleBLE::BluetoothUUID(characteristic.uuid())
|
|
);
|
|
|
|
std::string value(data.begin(), data.end());
|
|
|
|
// Manufacturer Name (0x2A29)
|
|
if (char_uuid.find("2a29") != std::string::npos ||
|
|
char_uuid.find("2A29") != std::string::npos) {
|
|
manufacturer_name = value;
|
|
std::cout << "[INFO EXTRACT] Manufacturer: " << value << std::endl;
|
|
}
|
|
// Model Number (0x2A24)
|
|
else if (char_uuid.find("2a24") != std::string::npos ||
|
|
char_uuid.find("2A24") != std::string::npos) {
|
|
model_number = value;
|
|
std::cout << "[INFO EXTRACT] Model: " << value << std::endl;
|
|
}
|
|
// Firmware Version (0x2A26)
|
|
else if (char_uuid.find("2a26") != std::string::npos ||
|
|
char_uuid.find("2A26") != std::string::npos) {
|
|
firmware_version = value;
|
|
std::cout << "[INFO EXTRACT] Firmware: " << value << std::endl;
|
|
}
|
|
// Hardware Version (0x2A27)
|
|
else if (char_uuid.find("2a27") != std::string::npos ||
|
|
char_uuid.find("2A27") != std::string::npos) {
|
|
hardware_version = value;
|
|
std::cout << "[INFO EXTRACT] Hardware: " << value << std::endl;
|
|
}
|
|
// Serial Number (0x2A25)
|
|
else if (char_uuid.find("2a25") != std::string::npos ||
|
|
char_uuid.find("2A25") != std::string::npos) {
|
|
serial_number = value;
|
|
std::cout << "[INFO EXTRACT] Serial: " << value << std::endl;
|
|
}
|
|
}
|
|
} catch (...) {
|
|
// Some characteristics may require pairing/encryption
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Store tracking data
|
|
{
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
const char* upsert_sql = R"(
|
|
INSERT INTO device_tracking_data
|
|
(device_address, manufacturer_name, device_model, firmware_version, hardware_version, serial_number, last_updated)
|
|
VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
|
|
ON CONFLICT(device_address)
|
|
DO UPDATE SET
|
|
manufacturer_name = COALESCE(excluded.manufacturer_name, manufacturer_name),
|
|
device_model = COALESCE(excluded.device_model, device_model),
|
|
firmware_version = COALESCE(excluded.firmware_version, firmware_version),
|
|
hardware_version = COALESCE(excluded.hardware_version, hardware_version),
|
|
serial_number = COALESCE(excluded.serial_number, serial_number),
|
|
last_updated = datetime('now');
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, upsert_sql, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, manufacturer_name.empty() ? nullptr : manufacturer_name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, model_number.empty() ? nullptr : model_number.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 4, firmware_version.empty() ? nullptr : firmware_version.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 5, hardware_version.empty() ? nullptr : hardware_version.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 6, serial_number.empty() ? nullptr : serial_number.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
}
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "[INFO EXTRACT] Error: " << e.what() << std::endl;
|
|
}
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error assessing security for " << address << ": " << e.what() << std::endl;
|
|
}
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
peripheral.disconnect();
|
|
std::cout << "[" << get_timestamp() << "] Disconnected from " << address << std::endl;
|
|
}
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error connecting to " << address << ": " << e.what() << std::endl;
|
|
}
|
|
}
|
|
|
|
// Get current timestamp in ISO 8601 format
|
|
std::string get_timestamp() {
|
|
auto now = std::chrono::system_clock::now();
|
|
auto time_t_now = std::chrono::system_clock::to_time_t(now);
|
|
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
now.time_since_epoch()) % 1000;
|
|
|
|
std::stringstream ss;
|
|
ss << std::put_time(std::localtime(&time_t_now), "%Y-%m-%d %H:%M:%S");
|
|
ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
|
|
return ss.str();
|
|
}
|
|
|
|
// Initialize SQLite database
|
|
bool init_database(sqlite3** db) {
|
|
int rc = sqlite3_open(config.db_path.c_str(), db);
|
|
if (rc != SQLITE_OK) {
|
|
std::cerr << "Cannot open database: " << sqlite3_errmsg(*db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
const char* create_table_sql = R"(
|
|
CREATE TABLE IF NOT EXISTS ble_scans (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
device_address TEXT NOT NULL,
|
|
device_name TEXT,
|
|
rssi INTEGER,
|
|
manufacturer_data TEXT,
|
|
scan_date DATE,
|
|
scan_time TIME,
|
|
scan_hour INTEGER,
|
|
scan_minute INTEGER,
|
|
address_type TEXT,
|
|
tx_power INTEGER,
|
|
mtu INTEGER,
|
|
is_connectable BOOLEAN,
|
|
service_uuids TEXT,
|
|
company_id INTEGER,
|
|
company_name TEXT,
|
|
estimated_distance REAL,
|
|
protocol_type TEXT DEFAULT 'BLE',
|
|
device_class_major TEXT,
|
|
device_class_minor TEXT,
|
|
device_class_cod INTEGER,
|
|
sdp_services TEXT
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_timestamp ON ble_scans(timestamp);
|
|
CREATE INDEX IF NOT EXISTS idx_scan_date ON ble_scans(scan_date);
|
|
CREATE INDEX IF NOT EXISTS idx_scan_time ON ble_scans(scan_time);
|
|
CREATE INDEX IF NOT EXISTS idx_device_address ON ble_scans(device_address);
|
|
CREATE INDEX IF NOT EXISTS idx_scan_hour ON ble_scans(scan_hour);
|
|
CREATE INDEX IF NOT EXISTS idx_company_name ON ble_scans(company_name);
|
|
|
|
CREATE TABLE IF NOT EXISTS device_distance_history (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
device_address TEXT NOT NULL,
|
|
device_name TEXT,
|
|
rssi INTEGER,
|
|
tx_power INTEGER,
|
|
estimated_distance REAL,
|
|
scan_date DATE,
|
|
scan_hour INTEGER
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_distance_timestamp ON device_distance_history(timestamp);
|
|
CREATE INDEX IF NOT EXISTS idx_distance_device ON device_distance_history(device_address);
|
|
CREATE INDEX IF NOT EXISTS idx_distance_date ON device_distance_history(scan_date);
|
|
|
|
CREATE TABLE IF NOT EXISTS device_characteristics (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
discovered_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
device_address TEXT NOT NULL,
|
|
device_name TEXT,
|
|
service_uuid TEXT,
|
|
characteristic_uuid TEXT,
|
|
properties TEXT,
|
|
UNIQUE(device_address, service_uuid, characteristic_uuid)
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_char_device ON device_characteristics(device_address);
|
|
|
|
CREATE TABLE IF NOT EXISTS device_nicknames (
|
|
device_address TEXT PRIMARY KEY,
|
|
nickname TEXT NOT NULL,
|
|
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS security_assessments (
|
|
device_address TEXT PRIMARY KEY,
|
|
risk_level TEXT NOT NULL,
|
|
vulnerabilities TEXT,
|
|
recommendations TEXT,
|
|
last_assessed DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_security_risk ON security_assessments(risk_level);
|
|
|
|
CREATE TABLE IF NOT EXISTS device_tracking_data (
|
|
device_address TEXT PRIMARY KEY,
|
|
device_type TEXT,
|
|
device_model TEXT,
|
|
manufacturer_name TEXT,
|
|
firmware_version TEXT,
|
|
hardware_version TEXT,
|
|
serial_number TEXT,
|
|
apple_continuity_data TEXT,
|
|
pairing_status TEXT,
|
|
last_seen_location TEXT,
|
|
tracking_identifiers TEXT,
|
|
additional_info TEXT,
|
|
last_updated DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_tracking_device ON device_tracking_data(device_address);
|
|
)";
|
|
|
|
char* err_msg = nullptr;
|
|
rc = sqlite3_exec(*db, create_table_sql, nullptr, nullptr, &err_msg);
|
|
if (rc != SQLITE_OK) {
|
|
std::cerr << "SQL error: " << err_msg << std::endl;
|
|
sqlite3_free(err_msg);
|
|
return false;
|
|
}
|
|
|
|
std::cout << "Database initialized: " << config.db_path << std::endl;
|
|
return true;
|
|
}
|
|
|
|
// Log BLE scan result to database with enhanced fields
|
|
bool log_scan_result(sqlite3* db, SimpleBLE::Peripheral& peripheral) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
auto now = std::chrono::system_clock::now();
|
|
auto time_t_now = std::chrono::system_clock::to_time_t(now);
|
|
auto tm_now = std::localtime(&time_t_now);
|
|
|
|
std::string address = peripheral.address();
|
|
std::string name = peripheral.identifier();
|
|
int rssi = peripheral.rssi();
|
|
int16_t tx_power = peripheral.tx_power();
|
|
uint16_t mtu = peripheral.mtu();
|
|
bool is_connectable = peripheral.is_connectable();
|
|
std::string address_type = get_address_type_string(peripheral.address_type());
|
|
|
|
// Extract manufacturer data
|
|
std::string manufacturer_data = "";
|
|
uint16_t company_id = 0;
|
|
std::string company_name = "";
|
|
auto mfg_data = peripheral.manufacturer_data();
|
|
if (!mfg_data.empty()) {
|
|
std::stringstream ss;
|
|
for (const auto& pair : mfg_data) {
|
|
company_id = pair.first; // Use the first company ID found
|
|
company_name = get_company_name(company_id);
|
|
ss << std::hex << std::setfill('0') << std::setw(4) << pair.first << ":";
|
|
for (uint8_t byte : pair.second) {
|
|
ss << std::hex << std::setfill('0') << std::setw(2) << (int)byte;
|
|
}
|
|
ss << ";";
|
|
}
|
|
manufacturer_data = ss.str();
|
|
}
|
|
|
|
// Get service UUIDs
|
|
std::string service_uuids = "";
|
|
auto services = peripheral.services();
|
|
if (!services.empty()) {
|
|
std::stringstream ss;
|
|
for (size_t i = 0; i < services.size(); i++) {
|
|
ss << services[i].uuid();
|
|
if (i < services.size() - 1) ss << ",";
|
|
}
|
|
service_uuids = ss.str();
|
|
}
|
|
|
|
// Calculate estimated distance
|
|
double estimated_distance = calculate_distance(tx_power, rssi);
|
|
|
|
const char* insert_sql = R"(
|
|
INSERT INTO ble_scans
|
|
(device_address, device_name, rssi, manufacturer_data, scan_date, scan_time, scan_hour, scan_minute,
|
|
address_type, tx_power, mtu, is_connectable, service_uuids, company_id, company_name, estimated_distance)
|
|
VALUES (?, ?, ?, ?, date('now', 'localtime'), time('now', 'localtime'), ?, ?,
|
|
?, ?, ?, ?, ?, ?, ?, ?);
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
int rc = sqlite3_prepare_v2(db, insert_sql, -1, &stmt, nullptr);
|
|
if (rc != SQLITE_OK) {
|
|
std::cerr << "Failed to prepare statement: " << sqlite3_errmsg(db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 3, rssi);
|
|
sqlite3_bind_text(stmt, 4, manufacturer_data.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 5, tm_now->tm_hour);
|
|
sqlite3_bind_int(stmt, 6, tm_now->tm_min);
|
|
sqlite3_bind_text(stmt, 7, address_type.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 8, tx_power);
|
|
sqlite3_bind_int(stmt, 9, mtu);
|
|
sqlite3_bind_int(stmt, 10, is_connectable ? 1 : 0);
|
|
sqlite3_bind_text(stmt, 11, service_uuids.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 12, company_id);
|
|
sqlite3_bind_text(stmt, 13, company_name.c_str(), -1, SQLITE_TRANSIENT);
|
|
if (estimated_distance >= 0) {
|
|
sqlite3_bind_double(stmt, 14, estimated_distance);
|
|
} else {
|
|
sqlite3_bind_null(stmt, 14);
|
|
}
|
|
|
|
rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
|
|
if (rc != SQLITE_DONE) {
|
|
std::cerr << "Failed to insert data: " << sqlite3_errmsg(db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// Also log to distance history if distance is available
|
|
if (estimated_distance >= 0) {
|
|
const char* distance_sql = R"(
|
|
INSERT INTO device_distance_history
|
|
(device_address, device_name, rssi, tx_power, estimated_distance, scan_date, scan_hour)
|
|
VALUES (?, ?, ?, ?, ?, date('now', 'localtime'), ?);
|
|
)";
|
|
|
|
sqlite3_stmt* dist_stmt;
|
|
rc = sqlite3_prepare_v2(db, distance_sql, -1, &dist_stmt, nullptr);
|
|
if (rc == SQLITE_OK) {
|
|
sqlite3_bind_text(dist_stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(dist_stmt, 2, name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(dist_stmt, 3, rssi);
|
|
sqlite3_bind_int(dist_stmt, 4, tx_power);
|
|
sqlite3_bind_double(dist_stmt, 5, estimated_distance);
|
|
sqlite3_bind_int(dist_stmt, 6, tm_now->tm_hour);
|
|
sqlite3_step(dist_stmt);
|
|
sqlite3_finalize(dist_stmt);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Log Classic Bluetooth device to database
|
|
bool log_classic_device(sqlite3* db, const ClassicBluetooth::ClassicDevice& device) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
auto now = std::chrono::system_clock::now();
|
|
auto time_t_now = std::chrono::system_clock::to_time_t(now);
|
|
auto tm_now = std::localtime(&time_t_now);
|
|
|
|
// Serialize SDP services to JSON
|
|
std::stringstream sdp_json;
|
|
sdp_json << "[";
|
|
for (size_t i = 0; i < device.services.size(); i++) {
|
|
sdp_json << "{\"uuid\":\"" << device.services[i].uuid << "\","
|
|
<< "\"name\":\"" << device.services[i].name << "\","
|
|
<< "\"rfcomm_channel\":" << (int)device.services[i].rfcomm_channel << "}";
|
|
if (i < device.services.size() - 1) sdp_json << ",";
|
|
}
|
|
sdp_json << "]";
|
|
|
|
const char* insert_sql = R"(
|
|
INSERT INTO ble_scans
|
|
(device_address, device_name, rssi, scan_date, scan_time, scan_hour, scan_minute,
|
|
is_connectable, company_name, protocol_type, device_class_major, device_class_minor,
|
|
device_class_cod, sdp_services)
|
|
VALUES (?, ?, ?, date('now', 'localtime'), time('now', 'localtime'), ?, ?,
|
|
?, ?, 'CLASSIC', ?, ?, ?, ?);
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
int rc = sqlite3_prepare_v2(db, insert_sql, -1, &stmt, nullptr);
|
|
if (rc != SQLITE_OK) {
|
|
std::cerr << "Failed to prepare statement: " << sqlite3_errmsg(db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, device.address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, device.name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 3, device.rssi);
|
|
sqlite3_bind_int(stmt, 4, tm_now->tm_hour);
|
|
sqlite3_bind_int(stmt, 5, tm_now->tm_min);
|
|
sqlite3_bind_int(stmt, 6, device.is_connected ? 1 : 0);
|
|
sqlite3_bind_text(stmt, 7, "Classic Bluetooth", -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 8, device.device_class.major_class.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 9, device.device_class.minor_class.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 10, device.device_class.class_of_device);
|
|
sqlite3_bind_text(stmt, 11, sdp_json.str().c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
rc = sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
|
|
if (rc != SQLITE_DONE) {
|
|
std::cerr << "Failed to insert Classic device: " << sqlite3_errmsg(db) << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Perform BLE scan
|
|
void perform_scan(sqlite3* db) {
|
|
auto adapters = SimpleBLE::Adapter::get_adapters();
|
|
|
|
if (adapters.empty()) {
|
|
std::cerr << "No Bluetooth adapters found" << std::endl;
|
|
return;
|
|
}
|
|
|
|
auto adapter = adapters[0];
|
|
std::cout << "Using adapter: " << adapter.identifier() << " [" << adapter.address() << "]" << std::endl;
|
|
|
|
adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
|
|
std::string address = peripheral.address();
|
|
std::string name = peripheral.identifier();
|
|
int rssi = peripheral.rssi();
|
|
int16_t tx_power = peripheral.tx_power();
|
|
double distance = calculate_distance(tx_power, rssi);
|
|
bool is_connectable = peripheral.is_connectable();
|
|
|
|
std::cout << "[" << get_timestamp() << "] Found: " << address
|
|
<< " | Name: " << (name.empty() ? "<unnamed>" : name)
|
|
<< " | RSSI: " << rssi << " dBm";
|
|
|
|
if (distance >= 0) {
|
|
std::cout << " | Distance: ~" << std::fixed << std::setprecision(1) << distance << "m";
|
|
}
|
|
|
|
// Extract company name and decode Apple data
|
|
std::string company_name = "Unknown";
|
|
AppleContinuityData apple_data;
|
|
auto mfg_data = peripheral.manufacturer_data();
|
|
if (!mfg_data.empty()) {
|
|
for (const auto& pair : mfg_data) {
|
|
company_name = get_company_name(pair.first);
|
|
std::cout << " | " << company_name;
|
|
|
|
// If Apple device, decode continuity data
|
|
if (pair.first == 0x004C) { // Apple company ID
|
|
apple_data = decode_apple_continuity(pair.second);
|
|
|
|
// Log decoded Apple data
|
|
if (!apple_data.device_type.empty()) {
|
|
std::cout << " [" << apple_data.device_type << "]";
|
|
}
|
|
if (apple_data.battery_level >= 0) {
|
|
std::cout << " [Battery: " << apple_data.battery_level << "%]";
|
|
}
|
|
if (!apple_data.airpods_left_battery.empty()) {
|
|
std::cout << " [L:" << apple_data.airpods_left_battery
|
|
<< " R:" << apple_data.airpods_right_battery
|
|
<< " Case:" << apple_data.airpods_case_battery << "]";
|
|
}
|
|
|
|
// Store Apple continuity data
|
|
try {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
std::stringstream apple_json;
|
|
apple_json << "{"
|
|
<< "\"device_type\":\"" << apple_data.device_type << "\","
|
|
<< "\"battery\":" << apple_data.battery_level << ","
|
|
<< "\"airpods_left\":\"" << apple_data.airpods_left_battery << "\","
|
|
<< "\"airpods_right\":\"" << apple_data.airpods_right_battery << "\","
|
|
<< "\"airpods_case\":\"" << apple_data.airpods_case_battery << "\","
|
|
<< "\"in_ear\":" << (apple_data.airpods_in_ear ? "true" : "false") << ","
|
|
<< "\"case_open\":" << (apple_data.airpods_case_lid_open ? "true" : "false") << ","
|
|
<< "\"handoff\":\"" << apple_data.handoff_data << "\","
|
|
<< "\"raw\":\"" << apple_data.raw_data << "\""
|
|
<< "}";
|
|
|
|
const char* upsert_sql = R"(
|
|
INSERT INTO device_tracking_data (device_address, device_type, apple_continuity_data, last_updated)
|
|
VALUES (?, ?, ?, datetime('now'))
|
|
ON CONFLICT(device_address)
|
|
DO UPDATE SET apple_continuity_data = excluded.apple_continuity_data, last_updated = datetime('now');
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, upsert_sql, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, apple_data.device_type.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 3, apple_json.str().c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
} catch (...) {}
|
|
}
|
|
break; // Show first company only
|
|
}
|
|
}
|
|
|
|
if (is_connectable) {
|
|
std::cout << " | Connectable";
|
|
}
|
|
|
|
std::cout << std::endl;
|
|
|
|
log_scan_result(db, peripheral);
|
|
|
|
// Perform PASSIVE security assessment immediately (no connection needed)
|
|
try {
|
|
SecurityAssessment passive_assessment = assess_device_passive(
|
|
address,
|
|
peripheral.identifier(),
|
|
company_name,
|
|
is_connectable,
|
|
"" // manufacturer_data - could extract from peripheral if available
|
|
);
|
|
|
|
// Store passive assessment
|
|
store_security_assessment(db, passive_assessment);
|
|
std::cout << "[PASSIVE SCAN] " << address << " - Risk: " << passive_assessment.risk_level;
|
|
if (!passive_assessment.vulnerabilities.empty()) {
|
|
std::cout << " (" << passive_assessment.vulnerabilities.size() << " issues)";
|
|
}
|
|
std::cout << std::endl;
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Error in passive assessment: " << e.what() << std::endl;
|
|
}
|
|
|
|
// Optionally connect to connectable devices we haven't enumerated yet
|
|
if (is_connectable) {
|
|
std::lock_guard<std::mutex> lock(enumerated_mutex);
|
|
if (enumerated_devices.find(address) == enumerated_devices.end()) {
|
|
enumerated_devices.insert(address);
|
|
|
|
// Launch connection in background thread
|
|
std::thread([db, peripheral]() mutable {
|
|
connect_and_enumerate(db, peripheral);
|
|
}).detach();
|
|
}
|
|
}
|
|
});
|
|
|
|
// Initialize Classic Bluetooth scanner
|
|
ClassicBluetooth::Scanner classic_scanner;
|
|
classic_scanner.set_device_found_callback([db](const ClassicBluetooth::ClassicDevice& device) {
|
|
std::cout << "[" << get_timestamp() << "] Classic BT Found: " << device.address
|
|
<< " | Name: " << device.name
|
|
<< " | RSSI: " << device.rssi << " dBm"
|
|
<< " | Class: " << device.device_class.major_class
|
|
<< " (" << device.device_class.minor_class << ")"
|
|
<< " | Services: " << device.services.size()
|
|
<< std::endl;
|
|
|
|
// Perform security assessment
|
|
SecurityAssessment assessment = assess_classic_device(device);
|
|
if (!assessment.vulnerabilities.empty()) {
|
|
std::cout << "[CLASSIC SECURITY] " << device.address
|
|
<< " - Risk: " << assessment.risk_level
|
|
<< " (" << assessment.vulnerabilities.size() << " vulnerabilities)"
|
|
<< std::endl;
|
|
store_security_assessment(db, assessment);
|
|
}
|
|
|
|
// Log to database
|
|
log_classic_device(db, device);
|
|
});
|
|
|
|
int scan_cycle = 0;
|
|
while (running) {
|
|
try {
|
|
// BLE scan every cycle
|
|
std::cout << "\n[" << get_timestamp() << "] Starting BLE scan..." << std::endl;
|
|
adapter.scan_for(config.scan_duration_ms);
|
|
std::cout << "[" << get_timestamp() << "] BLE scan complete." << std::endl;
|
|
|
|
// Classic Bluetooth inquiry every 3 cycles (less frequent due to longer duration)
|
|
if (scan_cycle % 3 == 0) {
|
|
std::cout << "[" << get_timestamp() << "] Starting Classic Bluetooth inquiry..." << std::endl;
|
|
classic_scanner.start_inquiry(10); // 10 second inquiry
|
|
|
|
// Wait for inquiry to complete
|
|
std::this_thread::sleep_for(std::chrono::seconds(11));
|
|
std::cout << "[" << get_timestamp() << "] Classic Bluetooth inquiry complete." << std::endl;
|
|
}
|
|
|
|
scan_cycle++;
|
|
std::cout << "[" << get_timestamp() << "] Scan cycle " << scan_cycle << " complete. Waiting..." << std::endl;
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(config.scan_interval_ms));
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "Scan error: " << e.what() << std::endl;
|
|
std::this_thread::sleep_for(std::chrono::seconds(5));
|
|
}
|
|
}
|
|
}
|
|
|
|
// HTTP API handlers
|
|
void setup_http_server(httplib::Server& server, sqlite3* db) {
|
|
// Add CORS headers to all responses
|
|
server.set_post_routing_handler([](const httplib::Request&, httplib::Response& res) {
|
|
res.set_header("Access-Control-Allow-Origin", "*");
|
|
res.set_header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
|
|
res.set_header("Access-Control-Allow-Headers", "Content-Type");
|
|
});
|
|
|
|
// Handle preflight OPTIONS requests for CORS
|
|
server.Options(R"(/.*)", [](const httplib::Request&, httplib::Response& res) {
|
|
res.status = 204;
|
|
});
|
|
|
|
// Health check endpoint
|
|
server.Get("/health", [](const httplib::Request&, httplib::Response& res) {
|
|
res.set_content("{\"status\":\"ok\"}", "application/json");
|
|
});
|
|
|
|
// Get recent scans
|
|
server.Get("/scans/recent", [db](const httplib::Request& req, httplib::Response& res) {
|
|
int limit = 100;
|
|
if (req.has_param("limit")) {
|
|
limit = std::stoi(req.get_param_value("limit"));
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT timestamp, device_address, device_name, rssi, address_type, "
|
|
"tx_power, mtu, is_connectable, service_uuids, company_name, estimated_distance, "
|
|
"protocol_type, device_class_major, device_class_minor, sdp_services "
|
|
"FROM ble_scans ORDER BY timestamp DESC LIMIT ?;";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_int(stmt, 1, limit);
|
|
|
|
std::stringstream json;
|
|
json << "{\"scans\":[";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
json << "{\"timestamp\":\"" << sqlite3_column_text(stmt, 0) << "\","
|
|
<< "\"address\":\"" << sqlite3_column_text(stmt, 1) << "\","
|
|
<< "\"name\":\"" << (sqlite3_column_text(stmt, 2) ? (const char*)sqlite3_column_text(stmt, 2) : "") << "\","
|
|
<< "\"rssi\":" << sqlite3_column_int(stmt, 3) << ","
|
|
<< "\"address_type\":\"" << (sqlite3_column_text(stmt, 4) ? (const char*)sqlite3_column_text(stmt, 4) : "") << "\","
|
|
<< "\"tx_power\":" << sqlite3_column_int(stmt, 5) << ","
|
|
<< "\"mtu\":" << sqlite3_column_int(stmt, 6) << ","
|
|
<< "\"is_connectable\":" << (sqlite3_column_int(stmt, 7) ? "true" : "false") << ","
|
|
<< "\"service_uuids\":\"" << (sqlite3_column_text(stmt, 8) ? (const char*)sqlite3_column_text(stmt, 8) : "") << "\","
|
|
<< "\"company_name\":\"" << (sqlite3_column_text(stmt, 9) ? (const char*)sqlite3_column_text(stmt, 9) : "") << "\"";
|
|
|
|
if (sqlite3_column_type(stmt, 10) != SQLITE_NULL) {
|
|
json << ",\"distance\":" << std::fixed << std::setprecision(1) << sqlite3_column_double(stmt, 10);
|
|
}
|
|
|
|
json << ",\"protocol_type\":\"" << (sqlite3_column_text(stmt, 11) ? (const char*)sqlite3_column_text(stmt, 11) : "BLE") << "\"";
|
|
|
|
if (sqlite3_column_type(stmt, 12) != SQLITE_NULL) {
|
|
json << ",\"device_class_major\":\"" << sqlite3_column_text(stmt, 12) << "\"";
|
|
}
|
|
if (sqlite3_column_type(stmt, 13) != SQLITE_NULL) {
|
|
json << ",\"device_class_minor\":\"" << sqlite3_column_text(stmt, 13) << "\"";
|
|
}
|
|
if (sqlite3_column_type(stmt, 14) != SQLITE_NULL) {
|
|
json << ",\"sdp_services\":" << sqlite3_column_text(stmt, 14);
|
|
}
|
|
|
|
json << "}";
|
|
}
|
|
|
|
json << "]}";
|
|
sqlite3_finalize(stmt);
|
|
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Query by date
|
|
server.Get("/scans/date/:date", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string date = req.path_params.at("date");
|
|
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT timestamp, device_address, device_name, rssi FROM ble_scans "
|
|
"WHERE scan_date = ? ORDER BY timestamp;";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, date.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
std::stringstream json;
|
|
json << "{\"date\":\"" << date << "\",\"scans\":[";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
json << "{\"timestamp\":\"" << sqlite3_column_text(stmt, 0) << "\","
|
|
<< "\"address\":\"" << sqlite3_column_text(stmt, 1) << "\","
|
|
<< "\"name\":\"" << sqlite3_column_text(stmt, 2) << "\","
|
|
<< "\"rssi\":" << sqlite3_column_int(stmt, 3) << "}";
|
|
}
|
|
|
|
json << "]}";
|
|
sqlite3_finalize(stmt);
|
|
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Query by hour range
|
|
server.Get("/scans/hour/:hour", [db](const httplib::Request& req, httplib::Response& res) {
|
|
int hour = std::stoi(req.path_params.at("hour"));
|
|
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT timestamp, device_address, device_name, rssi FROM ble_scans "
|
|
"WHERE scan_hour = ? ORDER BY timestamp DESC LIMIT 1000;";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_int(stmt, 1, hour);
|
|
|
|
std::stringstream json;
|
|
json << "{\"hour\":" << hour << ",\"scans\":[";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
json << "{\"timestamp\":\"" << sqlite3_column_text(stmt, 0) << "\","
|
|
<< "\"address\":\"" << sqlite3_column_text(stmt, 1) << "\","
|
|
<< "\"name\":\"" << sqlite3_column_text(stmt, 2) << "\","
|
|
<< "\"rssi\":" << sqlite3_column_int(stmt, 3) << "}";
|
|
}
|
|
|
|
json << "]}";
|
|
sqlite3_finalize(stmt);
|
|
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Statistics endpoint
|
|
server.Get("/stats", [db](const httplib::Request&, httplib::Response& res) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT COUNT(*) as total, "
|
|
"COUNT(DISTINCT device_address) as unique_devices, "
|
|
"MIN(timestamp) as first_scan, "
|
|
"MAX(timestamp) as last_scan FROM ble_scans;";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
std::stringstream json;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
json << "{\"total_scans\":" << sqlite3_column_int(stmt, 0) << ","
|
|
<< "\"unique_devices\":" << sqlite3_column_int(stmt, 1) << ","
|
|
<< "\"first_scan\":\"" << sqlite3_column_text(stmt, 2) << "\","
|
|
<< "\"last_scan\":\"" << sqlite3_column_text(stmt, 3) << "\"}";
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Get device scan count
|
|
server.Get("/device/:address/count", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT COUNT(*) as count FROM ble_scans WHERE device_address = ?;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
std::stringstream json;
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
json << "{\"address\":\"" << address << "\","
|
|
<< "\"count\":" << sqlite3_column_int(stmt, 0) << "}";
|
|
} else {
|
|
json << "{\"address\":\"" << address << "\",\"count\":0}";
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Get distance history for a device
|
|
server.Get("/distance/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
int limit = req.has_param("limit") ? std::stoi(req.get_param_value("limit")) : 100;
|
|
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT timestamp, rssi, tx_power, estimated_distance FROM device_distance_history "
|
|
"WHERE device_address = ? ORDER BY timestamp DESC LIMIT ?;";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 2, limit);
|
|
|
|
std::stringstream json;
|
|
json << "{\"address\":\"" << address << "\",\"history\":[";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
json << "{\"timestamp\":\"" << sqlite3_column_text(stmt, 0) << "\","
|
|
<< "\"rssi\":" << sqlite3_column_int(stmt, 1) << ","
|
|
<< "\"tx_power\":" << sqlite3_column_int(stmt, 2) << ","
|
|
<< "\"distance\":" << std::fixed << std::setprecision(1) << sqlite3_column_double(stmt, 3) << "}";
|
|
}
|
|
|
|
json << "]}";
|
|
sqlite3_finalize(stmt);
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Get characteristics for a device
|
|
server.Get("/characteristics/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT service_uuid, characteristic_uuid, properties, discovered_at "
|
|
"FROM device_characteristics WHERE device_address = ? ORDER BY discovered_at DESC;";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
std::stringstream json;
|
|
json << "{\"address\":\"" << address << "\",\"characteristics\":[";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
std::string service_uuid = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
|
std::string char_uuid = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
|
|
std::string properties = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
|
|
|
|
std::string service_name = decode_service_uuid(service_uuid);
|
|
std::string char_name = decode_characteristic_uuid(char_uuid);
|
|
std::string char_desc = get_characteristic_description(char_uuid);
|
|
|
|
json << "{\"service\":\"" << service_uuid << "\","
|
|
<< "\"service_name\":\"" << service_name << "\","
|
|
<< "\"characteristic\":\"" << char_uuid << "\","
|
|
<< "\"characteristic_name\":\"" << char_name << "\","
|
|
<< "\"description\":\"" << char_desc << "\","
|
|
<< "\"properties\":\"" << properties << "\","
|
|
<< "\"discovered_at\":\"" << sqlite3_column_text(stmt, 3) << "\"}";
|
|
}
|
|
|
|
json << "]}";
|
|
sqlite3_finalize(stmt);
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Read characteristic value
|
|
server.Get("/read/:address/:service/:characteristic", [](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::string service_uuid = req.path_params.at("service");
|
|
std::string char_uuid = req.path_params.at("characteristic");
|
|
|
|
try {
|
|
auto adapters = SimpleBLE::Adapter::get_adapters();
|
|
if (adapters.empty()) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"No Bluetooth adapters found\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
auto adapter = adapters[0];
|
|
auto peripherals = adapter.scan_get_results();
|
|
|
|
SimpleBLE::Peripheral target_peripheral;
|
|
bool found = false;
|
|
|
|
for (auto& peripheral : peripherals) {
|
|
if (peripheral.identifier() == address || peripheral.address() == address) {
|
|
target_peripheral = peripheral;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
res.status = 404;
|
|
res.set_content("{\"error\":\"Device not found or not in range\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
if (!target_peripheral.is_connected()) {
|
|
std::cout << "[READ] Connecting to " << address << "..." << std::endl;
|
|
target_peripheral.connect();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
}
|
|
|
|
SimpleBLE::BluetoothUUID service(service_uuid);
|
|
SimpleBLE::BluetoothUUID characteristic(char_uuid);
|
|
|
|
SimpleBLE::ByteArray data = target_peripheral.read(service, characteristic);
|
|
|
|
// Disconnect after reading
|
|
if (target_peripheral.is_connected()) {
|
|
target_peripheral.disconnect();
|
|
}
|
|
|
|
// Convert byte array to hex string and interpret based on characteristic type
|
|
std::stringstream json;
|
|
json << "{\"address\":\"" << address << "\","
|
|
<< "\"service\":\"" << service_uuid << "\","
|
|
<< "\"characteristic\":\"" << char_uuid << "\","
|
|
<< "\"raw\":\"";
|
|
|
|
for (uint8_t byte : data) {
|
|
json << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
|
|
}
|
|
json << "\",";
|
|
|
|
// Decode specific known characteristics
|
|
std::string upper_char = char_uuid;
|
|
std::transform(upper_char.begin(), upper_char.end(), upper_char.begin(), ::toupper);
|
|
|
|
if (upper_char.find("2A19") != std::string::npos && data.size() >= 1) {
|
|
// Battery Level (0-100%)
|
|
json << "\"value\":" << (int)data[0] << ","
|
|
<< "\"unit\":\"%\",\"type\":\"battery\"";
|
|
} else if (upper_char.find("2A00") != std::string::npos ||
|
|
upper_char.find("2A29") != std::string::npos ||
|
|
upper_char.find("2A24") != std::string::npos ||
|
|
upper_char.find("2A26") != std::string::npos) {
|
|
// String characteristics (Device Name, Manufacturer, Model, Firmware)
|
|
std::string text(data.begin(), data.end());
|
|
json << "\"value\":\"" << text << "\",\"type\":\"string\"";
|
|
} else if (upper_char.find("2A6E") != std::string::npos && data.size() >= 2) {
|
|
// Temperature (signed 16-bit)
|
|
int16_t temp = (data[1] << 8) | data[0];
|
|
json << "\"value\":" << (temp / 100.0) << ","
|
|
<< "\"unit\":\"°C\",\"type\":\"temperature\"";
|
|
} else if (upper_char.find("2A37") != std::string::npos && data.size() >= 2) {
|
|
// Heart Rate
|
|
uint8_t bpm = data[1];
|
|
json << "\"value\":" << (int)bpm << ","
|
|
<< "\"unit\":\"bpm\",\"type\":\"heart_rate\"";
|
|
} else {
|
|
json << "\"value\":null,\"type\":\"unknown\"";
|
|
}
|
|
|
|
json << "}";
|
|
res.set_content(json.str(), "application/json");
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "[READ] Error: " << e.what() << std::endl;
|
|
|
|
std::string error_msg = e.what();
|
|
std::stringstream json;
|
|
|
|
// Check for encryption/pairing errors
|
|
if (error_msg.find("Encryption") != std::string::npos ||
|
|
error_msg.find("insufficient") != std::string::npos ||
|
|
error_msg.find("Authentication") != std::string::npos) {
|
|
res.status = 403;
|
|
json << "{\"error\":\"Device requires pairing/bonding\","
|
|
<< "\"details\":\"This characteristic is encrypted and requires you to pair with the device first. "
|
|
<< "Pair via System Settings → Bluetooth, then try again.\","
|
|
<< "\"requires_pairing\":true}";
|
|
} else if (error_msg.find("not in range") != std::string::npos ||
|
|
error_msg.find("not found") != std::string::npos) {
|
|
res.status = 404;
|
|
json << "{\"error\":\"Device not found\","
|
|
<< "\"details\":\"Device is not currently in range or not responding.\"}";
|
|
} else if (error_msg.find("timeout") != std::string::npos ||
|
|
error_msg.find("Timed out") != std::string::npos) {
|
|
res.status = 504;
|
|
json << "{\"error\":\"Connection timeout\","
|
|
<< "\"details\":\"Device did not respond in time. It may be too far away or busy.\"}";
|
|
} else {
|
|
res.status = 500;
|
|
json << "{\"error\":\"" << error_msg << "\"}";
|
|
}
|
|
|
|
res.set_content(json.str(), "application/json");
|
|
}
|
|
});
|
|
|
|
// ESP32 sensor data ingestion endpoint
|
|
server.Post("/esp32/scan", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
try {
|
|
// Parse JSON from ESP32
|
|
std::string body = req.body;
|
|
std::cout << "[ESP32] Received data from sensor node (" << body.length() << " bytes)" << std::endl;
|
|
|
|
// Very basic JSON parsing (production should use a proper JSON library)
|
|
size_t device_name_pos = body.find("\"device_name\":\"");
|
|
std::string device_name = "ESP32";
|
|
if (device_name_pos != std::string::npos) {
|
|
size_t start = device_name_pos + 15;
|
|
size_t end = body.find("\"", start);
|
|
device_name = body.substr(start, end - start);
|
|
}
|
|
|
|
// Extract scans array
|
|
size_t scans_pos = body.find("\"scans\":[");
|
|
if (scans_pos == std::string::npos) {
|
|
res.status = 400;
|
|
res.set_content("{\"status\":\"error\",\"message\":\"No scans array found\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
// Count devices by looking for address fields
|
|
int device_count = 0;
|
|
size_t pos = 0;
|
|
while ((pos = body.find("\"address\":", pos)) != std::string::npos) {
|
|
device_count++;
|
|
|
|
// Extract device data
|
|
size_t addr_start = body.find("\"", pos + 10) + 1;
|
|
size_t addr_end = body.find("\"", addr_start);
|
|
std::string address = body.substr(addr_start, addr_end - addr_start);
|
|
|
|
// Extract name
|
|
size_t name_pos = body.find("\"name\":\"", pos);
|
|
std::string name = "";
|
|
if (name_pos != std::string::npos && name_pos < pos + 500) {
|
|
size_t name_start = name_pos + 8;
|
|
size_t name_end = body.find("\"", name_start);
|
|
name = body.substr(name_start, name_end - name_start);
|
|
}
|
|
|
|
// Extract RSSI
|
|
size_t rssi_pos = body.find("\"rssi\":", pos);
|
|
int rssi = 0;
|
|
if (rssi_pos != std::string::npos && rssi_pos < pos + 500) {
|
|
size_t rssi_start = rssi_pos + 7;
|
|
size_t rssi_end = body.find_first_of(",}", rssi_start);
|
|
rssi = std::stoi(body.substr(rssi_start, rssi_end - rssi_start));
|
|
}
|
|
|
|
// Extract company_name
|
|
size_t company_pos = body.find("\"company_name\":\"", pos);
|
|
std::string company = "";
|
|
if (company_pos != std::string::npos && company_pos < pos + 500) {
|
|
size_t company_start = company_pos + 16;
|
|
size_t company_end = body.find("\"", company_start);
|
|
company = body.substr(company_start, company_end - company_start);
|
|
}
|
|
|
|
// Insert into database with source indication
|
|
const char* insert_sql = R"(
|
|
INSERT INTO ble_scans
|
|
(device_address, device_name, rssi, manufacturer_data, scan_date, scan_time, scan_hour, scan_minute, company_name)
|
|
VALUES (?, ?, ?, ?, date('now', 'localtime'), time('now', 'localtime'), ?, ?, ?);
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, insert_sql, -1, &stmt, nullptr) == SQLITE_OK) {
|
|
auto now = std::chrono::system_clock::now();
|
|
auto time_t_now = std::chrono::system_clock::to_time_t(now);
|
|
auto tm_now = std::localtime(&time_t_now);
|
|
|
|
std::string source_data = "ESP32:" + device_name;
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, name.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 3, rssi);
|
|
sqlite3_bind_text(stmt, 4, source_data.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int(stmt, 5, tm_now->tm_hour);
|
|
sqlite3_bind_int(stmt, 6, tm_now->tm_min);
|
|
sqlite3_bind_text(stmt, 7, company.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
sqlite3_step(stmt);
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
|
|
pos = addr_end;
|
|
}
|
|
|
|
std::cout << "[ESP32] Stored " << device_count << " scans from " << device_name << std::endl;
|
|
|
|
std::stringstream json;
|
|
json << "{\"status\":\"ok\",\"received\":" << device_count << ",\"source\":\"" << device_name << "\"}";
|
|
res.set_content(json.str(), "application/json");
|
|
|
|
} catch (const std::exception& e) {
|
|
std::cerr << "[ESP32] Error processing data: " << e.what() << std::endl;
|
|
res.status = 500;
|
|
res.set_content("{\"status\":\"error\",\"message\":\"Processing error\"}", "application/json");
|
|
}
|
|
});
|
|
|
|
// Get device nickname
|
|
server.Get("/nickname/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT nickname FROM device_nicknames WHERE device_address = ?;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
std::string nickname = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
|
std::stringstream json;
|
|
json << "{\"address\":\"" << address << "\",\"nickname\":\"" << nickname << "\"}";
|
|
res.set_content(json.str(), "application/json");
|
|
} else {
|
|
res.status = 404;
|
|
res.set_content("{\"error\":\"No nickname found\"}", "application/json");
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
});
|
|
|
|
// Set device nickname
|
|
server.Post("/nickname/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::string body = req.body;
|
|
|
|
// Extract nickname from JSON body
|
|
size_t nickname_pos = body.find("\"nickname\":\"");
|
|
if (nickname_pos == std::string::npos) {
|
|
res.status = 400;
|
|
res.set_content("{\"error\":\"Missing nickname field\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
size_t nickname_start = nickname_pos + 12;
|
|
size_t nickname_end = body.find("\"", nickname_start);
|
|
std::string nickname = body.substr(nickname_start, nickname_end - nickname_start);
|
|
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
const char* upsert_sql = R"(
|
|
INSERT INTO device_nicknames (device_address, nickname, updated_at)
|
|
VALUES (?, ?, datetime('now'))
|
|
ON CONFLICT(device_address)
|
|
DO UPDATE SET nickname = excluded.nickname, updated_at = datetime('now');
|
|
)";
|
|
|
|
sqlite3_stmt* stmt;
|
|
if (sqlite3_prepare_v2(db, upsert_sql, -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(stmt, 2, nickname.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
if (sqlite3_step(stmt) == SQLITE_DONE) {
|
|
std::stringstream json;
|
|
json << "{\"status\":\"ok\",\"address\":\"" << address << "\",\"nickname\":\"" << nickname << "\"}";
|
|
res.set_content(json.str(), "application/json");
|
|
} else {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Failed to save nickname\"}", "application/json");
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
});
|
|
|
|
// Delete device nickname
|
|
server.Delete("/nickname/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
const char* delete_sql = "DELETE FROM device_nicknames WHERE device_address = ?;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, delete_sql, -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
if (sqlite3_step(stmt) == SQLITE_DONE) {
|
|
res.set_content("{\"status\":\"ok\"}", "application/json");
|
|
} else {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Failed to delete nickname\"}", "application/json");
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
});
|
|
|
|
// Get all nicknames
|
|
server.Get("/nicknames", [db](const httplib::Request&, httplib::Response& res) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT device_address, nickname FROM device_nicknames;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
std::stringstream json;
|
|
json << "{\"nicknames\":{";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
std::string address = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
|
std::string nickname = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
|
|
json << "\"" << address << "\":\"" << nickname << "\"";
|
|
}
|
|
|
|
json << "}}";
|
|
sqlite3_finalize(stmt);
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Get security assessment for a device
|
|
server.Get("/security/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT risk_level, vulnerabilities, recommendations, last_assessed "
|
|
"FROM security_assessments WHERE device_address = ?;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
std::string risk_level = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
|
std::string vulnerabilities = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
|
|
std::string recommendations = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
|
|
std::string last_assessed = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 3));
|
|
|
|
std::stringstream json;
|
|
json << "{\"address\":\"" << address << "\","
|
|
<< "\"risk_level\":\"" << risk_level << "\","
|
|
<< "\"vulnerabilities\":" << vulnerabilities << ","
|
|
<< "\"recommendations\":" << recommendations << ","
|
|
<< "\"last_assessed\":\"" << last_assessed << "\"}";
|
|
|
|
res.set_content(json.str(), "application/json");
|
|
} else {
|
|
res.status = 404;
|
|
res.set_content("{\"error\":\"No security assessment found\",\"message\":\"Device not yet assessed\"}", "application/json");
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
});
|
|
|
|
// Get all security assessments
|
|
server.Get("/security", [db](const httplib::Request&, httplib::Response& res) {
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT device_address, risk_level, last_assessed FROM security_assessments ORDER BY risk_level DESC;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
std::stringstream json;
|
|
json << "{\"assessments\":[";
|
|
bool first = true;
|
|
|
|
while (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
if (!first) json << ",";
|
|
first = false;
|
|
|
|
std::string address = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
|
std::string risk_level = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
|
|
std::string last_assessed = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
|
|
|
|
json << "{\"address\":\"" << address << "\","
|
|
<< "\"risk_level\":\"" << risk_level << "\","
|
|
<< "\"last_assessed\":\"" << last_assessed << "\"}";
|
|
}
|
|
|
|
json << "]}";
|
|
sqlite3_finalize(stmt);
|
|
res.set_content(json.str(), "application/json");
|
|
});
|
|
|
|
// Get tracking data for a device
|
|
server.Get("/tracking/:address", [db](const httplib::Request& req, httplib::Response& res) {
|
|
std::string address = req.path_params.at("address");
|
|
std::lock_guard<std::mutex> lock(db_mutex);
|
|
|
|
std::string query = "SELECT * FROM device_tracking_data WHERE device_address = ?;";
|
|
sqlite3_stmt* stmt;
|
|
|
|
if (sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {
|
|
res.status = 500;
|
|
res.set_content("{\"error\":\"Database error\"}", "application/json");
|
|
return;
|
|
}
|
|
|
|
sqlite3_bind_text(stmt, 1, address.c_str(), -1, SQLITE_TRANSIENT);
|
|
|
|
if (sqlite3_step(stmt) == SQLITE_ROW) {
|
|
std::stringstream json;
|
|
json << "{\"address\":\"" << address << "\",";
|
|
|
|
// Get all columns
|
|
if (sqlite3_column_text(stmt, 1)) json << "\"device_type\":\"" << sqlite3_column_text(stmt, 1) << "\",";
|
|
if (sqlite3_column_text(stmt, 2)) json << "\"device_model\":\"" << sqlite3_column_text(stmt, 2) << "\",";
|
|
if (sqlite3_column_text(stmt, 3)) json << "\"manufacturer_name\":\"" << sqlite3_column_text(stmt, 3) << "\",";
|
|
if (sqlite3_column_text(stmt, 4)) json << "\"firmware_version\":\"" << sqlite3_column_text(stmt, 4) << "\",";
|
|
if (sqlite3_column_text(stmt, 5)) json << "\"hardware_version\":\"" << sqlite3_column_text(stmt, 5) << "\",";
|
|
if (sqlite3_column_text(stmt, 6)) json << "\"serial_number\":\"" << sqlite3_column_text(stmt, 6) << "\",";
|
|
if (sqlite3_column_text(stmt, 7)) json << "\"apple_continuity\":" << sqlite3_column_text(stmt, 7) << ",";
|
|
if (sqlite3_column_text(stmt, 8)) json << "\"pairing_status\":\"" << sqlite3_column_text(stmt, 8) << "\",";
|
|
if (sqlite3_column_text(stmt, 11)) json << "\"additional_info\":\"" << sqlite3_column_text(stmt, 11) << "\",";
|
|
json << "\"last_updated\":\"" << sqlite3_column_text(stmt, 12) << "\"}";
|
|
|
|
res.set_content(json.str(), "application/json");
|
|
} else {
|
|
res.status = 404;
|
|
res.set_content("{\"error\":\"No tracking data found\"}", "application/json");
|
|
}
|
|
|
|
sqlite3_finalize(stmt);
|
|
});
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
std::cout << "Bluehound v1.0" << std::endl;
|
|
std::cout << "==============\n" << std::endl;
|
|
|
|
// Setup signal handlers
|
|
signal(SIGINT, signal_handler);
|
|
signal(SIGTERM, signal_handler);
|
|
|
|
// Initialize database
|
|
sqlite3* db;
|
|
if (!init_database(&db)) {
|
|
return 1;
|
|
}
|
|
|
|
// Start HTTP server in separate thread
|
|
std::thread http_thread;
|
|
httplib::Server server;
|
|
|
|
if (config.enable_http_server) {
|
|
setup_http_server(server, db);
|
|
|
|
http_thread = std::thread([&server]() {
|
|
std::cout << "Starting HTTP server on port " << config.http_port << std::endl;
|
|
std::cout << "API Endpoints:" << std::endl;
|
|
std::cout << " - GET /health" << std::endl;
|
|
std::cout << " - GET /scans/recent?limit=N" << std::endl;
|
|
std::cout << " - GET /scans/date/YYYY-MM-DD" << std::endl;
|
|
std::cout << " - GET /scans/hour/HH" << std::endl;
|
|
std::cout << " - GET /stats\n" << std::endl;
|
|
|
|
server.listen("0.0.0.0", config.http_port);
|
|
});
|
|
}
|
|
|
|
// Start BLE scanning
|
|
perform_scan(db);
|
|
|
|
// Cleanup
|
|
if (config.enable_http_server) {
|
|
server.stop();
|
|
if (http_thread.joinable()) {
|
|
http_thread.join();
|
|
}
|
|
}
|
|
|
|
sqlite3_close(db);
|
|
std::cout << "Shutdown complete." << std::endl;
|
|
|
|
return 0;
|
|
}
|