Files
ANSCORE/core/anslicensing/hwid.cpp
T
nghianguyenandClaude Fable 5 6f1d069d14 anslicensing: Linux hardware id uses PHYSICAL NICs only
The id is built from up to 6 enumerated MACs. On Linux getifaddrs() also
returns virtual interfaces — docker0 and the veth* pairs each container
creates, tun*/wg* from a VPN, br-*/virbr* bridges. Container veths carry
RANDOM MACs and appear/disappear with the containers, so the enumerated set
can differ between calls: the hardware id changes and an activated licence
silently stops matching its machine. Boxes running Docker (the Coder feature)
would hit this routinely.

This matters more on Linux than elsewhere because two of the four id
components are already constant there: the system-UUID slot is a literal and
GetHDDPropertyList is an empty function on non-Windows. The id rests on CPU id
+ MACs, so unstable MACs are most of the instability.

Filter mirrors what the Windows branch already does via WMI (PNPDeviceId LIKE
%PCI% — physical adapters only). The test is /sys/class/net/<name>/device,
the kernel's own record of a hardware-backed interface, so it stays correct as
new virtual-interface flavours appear; a name-prefix denylist is kept only for
environments without /sys. MACs are bucketed during the walk and chosen after
it, so a veth appearing earlier in the list cannot consume a slot and push a
real NIC out.

FAIL-SAFE: if no physical NIC is found, fall back to the unfiltered set. An
empty list would drop all MAC entropy and — with the UUID and disk slots
already constant — leave near-identical ids across different machines.

Windows and macOS/BSD paths are untouched (both #else branches preserve the
existing behaviour exactly). Logic verified against a simulated Docker host:
enp3s0/wlp2s0 accepted; lo, docker0, veth*, br-*, tun0 rejected.

ORDERING: this CHANGES the id on any Linux box that has virtual interfaces, so
it must land BEFORE the first Linux licences are issued — afterwards it would
invalidate them.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-28 19:34:26 +10:00

643 lines
18 KiB
C++

//
// Copyright (c) 2014 ANSCENTER. All rights reserved.
//
#include "precomp.h"
#ifdef _WIN32
#include "wmihelper.h"
#else // !_WIN32
#if defined(__i386__) || defined(__amd64__)
#include <cpuid.h>
#endif
#include <sys/types.h>
#include <sys/socket.h>
#include <ifaddrs.h>
#include <netinet/in.h>
#include <net/if.h>
#ifdef __linux__
# include <sys/ioctl.h>
# include <sys/stat.h> // stat() — physical-NIC test in linuxIsPhysicalNic
# include <netinet/in.h>
# include <unistd.h>
# include <string.h> // strncmp/strlen (same test)
// Match Linux to FreeBSD
# define AF_LINK AF_PACKET
#else
# include <net/if_dl.h>
#endif
#endif
#include <list>
#include <string>
#include <functional>
#include <algorithm>
#include <cctype>
#include <stdio.h>
#include <set>
#include "bitstream2.h"
#include "bitstream3.h"
#include "base32.h"
#include "crc32.h"
#include "hwid.h"
#include "except.h"
#include "uniconv.h"
using namespace std;
string HardwareId::hardwareId;
#ifndef _WIN32
const sockaddr_in* castToIP4(const sockaddr* addr) {
if (addr == NULL) {
return NULL;
}
else if (addr->sa_family == AF_INET) {
// An IPv4 address
return reinterpret_cast<const sockaddr_in*>(addr);
}
else {
// Not an IPv4 address
return NULL;
}
}
void GetCPUIDPropertyList(std::list<std::string>* propList)
{
unsigned int level = 1, eax = 0, ebx, ecx, edx = 0;
#if defined(__i386__) || defined(__amd64__)
__get_cpuid(level, &eax, &ebx, &ecx, &edx);
#endif
char buf[17];
sprintf(buf, "%08X%08X", edx, eax);
propList->push_back(buf);
}
#ifdef __linux__
// A PHYSICAL network interface, i.e. one backed by a real hardware device.
//
// Why this exists: the hardware id is built from up to 6 enumerated MACs, and
// on Linux getifaddrs() also returns VIRTUAL interfaces — docker0 and the
// veth* pairs a container creates, tun*/wg* from a VPN, br-*/virbr* bridges.
// Container veths get RANDOM MACs and come and go with the containers, so an
// unfiltered enumeration can hand back a different set on every call: the id
// changes and an activated licence silently stops matching its machine. Boxes
// running Docker (the Coder feature) hit this routinely.
//
// The test mirrors what the Windows branch already does via WMI ("PNPDeviceId
// LIKE %PCI%" — physical adapters only). /sys/class/net/<name>/device is a
// symlink to the backing device and exists ONLY for hardware-backed
// interfaces; virtual ones have no such link. That is the kernel's own answer,
// so it stays correct as new virtual-interface flavours appear — unlike a name
// denylist, which is kept only as a cheap second line of defence.
static bool linuxIsPhysicalNic(const char* ifname)
{
if (ifname == NULL || ifname[0] == '\0') return false;
// Names that are virtual by construction. Not exhaustive on purpose — the
// /sys check below is the real test; this only catches oddities where /sys
// is unavailable (unusual containers, minimal namespaces).
static const char* kVirtualPrefixes[] = {
"lo", "docker", "veth", "br-", "virbr", "tun", "tap", "wg",
"vmnet", "vboxnet", "zt", "ppp", "dummy", "kube", "cni", "flannel",
"lxc", "lxd", "nerdctl", "podman", "cali", "weave"
};
for (const char* prefix : kVirtualPrefixes) {
if (strncmp(ifname, prefix, strlen(prefix)) == 0) return false;
}
std::string path = std::string("/sys/class/net/") + ifname + "/device";
struct stat st;
// stat() (not lstat) so the symlink is followed — we want "the target
// exists", i.e. a real backing device.
return stat(path.c_str(), &st) == 0;
}
#endif // __linux__
void GetMACPropertyList(std::list<std::string>* propList, int maxCount)
{
// Head of the interface address linked list
ifaddrs* ifap = NULL;
int r = getifaddrs(&ifap);
if (r != 0) {
return;
}
ifaddrs* current = ifap;
if (current == NULL) {
return;
}
#ifdef __linux__
// Collected separately so physical NICs can be preferred wholesale. Taking
// them inline would let a veth that merely appears EARLIER in the list
// consume one of the maxCount slots and push a real NIC out.
std::list<std::string> physical;
std::list<std::string> fallback;
#endif
while (current != NULL && maxCount > 0) {
const sockaddr_in* interfaceAddress = castToIP4(current->ifa_addr);
const sockaddr_in* broadcastAddress = castToIP4(current->ifa_dstaddr);
const sockaddr_in* subnetMask = castToIP4(current->ifa_netmask);
if ((current->ifa_addr != NULL) && (current->ifa_addr->sa_family == AF_LINK)) {
#ifdef __linux__
struct ifreq ifr;
int fd = socket(AF_INET, SOCK_DGRAM, 0);
ifr.ifr_addr.sa_family = AF_INET;
strcpy(ifr.ifr_name, current->ifa_name);
ioctl(fd, SIOCGIFHWADDR, &ifr);
close(fd);
uint8_t* MAC = reinterpret_cast<uint8_t*>(ifr.ifr_hwaddr.sa_data);
#else // Posix/FreeBSD/Mac OS
sockaddr_dl* sdl = (struct sockaddr_dl*)current->ifa_addr;
uint8_t* MAC = reinterpret_cast<uint8_t*>(LLADDR(sdl));
#endif
if (MAC[0] != 0 || MAC[1] != 0 || MAC[2] != 0 || MAC[3] != 0 || MAC[4] != 0 || MAC[5] != 0)
{
char buf[18];
sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x", MAC[0], MAC[1], MAC[2], MAC[3], MAC[4], MAC[5]);
#ifdef __linux__
// Bucket now, choose after the walk (see the lists above).
// maxCount is NOT decremented here: the cap applies to the
// SELECTED set, not to whatever happened to be enumerated.
if (linuxIsPhysicalNic(current->ifa_name))
physical.push_back(buf);
else
fallback.push_back(buf);
#else
propList->push_back(buf);
maxCount--;
#endif
}
}
current = current->ifa_next;
}
freeifaddrs(ifap);
ifap = NULL;
#ifdef __linux__
// Physical NICs only — that is the whole point. FAIL-SAFE: if the filter
// found none (no /sys, an exotic NIC driver, a network namespace with only
// virtual links) fall back to the unfiltered set rather than returning
// nothing. An empty list would drop ALL MAC entropy from the id, and with
// the system-UUID and disk-serial slots already constant on Linux that
// would leave near-identical ids across different machines — far worse
// than an id that occasionally drifts.
std::list<std::string>& chosen = physical.empty() ? fallback : physical;
for (std::list<std::string>::const_iterator it = chosen.begin();
it != chosen.end() && maxCount > 0; ++it, --maxCount) {
propList->push_back(*it);
}
#endif
}
void GetHDDPropertyList(std::list<std::string>* propList, int maxCount)
{
}
#endif
unsigned short HardwareId::HashString(const char* str)
{
unsigned int crc = Crc32::Compute((const unsigned char*)str, strlen(str));
return (unsigned short)(crc >> 16);
}
unsigned short HardwareId::HashInt(int val)
{
unsigned char buf[4] = { (unsigned char)(val >> 24), (unsigned char)(val >> 16), (unsigned char)(val >> 8), (unsigned char)(val & 0xFF) };
unsigned int crc = Crc32::Compute(buf, 4);
return (unsigned short)(crc >> 16);
}
// LOCALE-INDEPENDENT trim from start (in place)
static inline void ltrim(std::string& s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
return ch != ' ' && ch != '\t' && ch != '\n' && ch != '\r' && ch != 0xA0;
}));
}
// LOCALE-INDEPENDENT trim from end (in place)
static inline void rtrim(std::string& s) {
s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
return ch != ' ' && ch != '\t' && ch != '\n' && ch != '\r' && ch != 0xA0;
}).base(), s.end());
}
// trim from both ends (in place)
static inline void trim(std::string& s) {
ltrim(s);
rtrim(s);
}
// LOCALE-INDEPENDENT uppercase conversion
static inline void toUpperInvariant(std::string& s) {
for (char& c : s) {
if (c >= 'a' && c <= 'z') {
c = c - 32;
}
}
}
// Normalize hardware string for consistent hashing
static std::string NormalizeHardwareString(const std::string& input) {
std::string s = input;
// Trim all types of whitespace
trim(s);
// Remove all remaining whitespace characters
s.erase(std::remove_if(s.begin(), s.end(), [](unsigned char c) {
return c <= 32 || c == 0xA0; // Remove control chars and non-breaking space
}), s.end());
// Locale-independent uppercase for ASCII
toUpperInvariant(s);
// Remove non-ASCII characters (Korean text, etc.)
s.erase(std::remove_if(s.begin(), s.end(), [](unsigned char c) {
return c > 127;
}), s.end());
return s;
}
const char* HardwareId::GetCurrentHardwareId()
{
#ifdef _WIN32
WmiHelper wmi;
#endif
// 147 bits are actually written below (3 version + 9 x 16-bit hashes). The
// previous size of 125 allocated only 16 bytes and the last two hash slots
// overflowed the heap block by 3 bytes (asymptomatic on the Windows heap,
// SIGSEGV under macOS malloc — found when ANSGateway enabled this code on
// POSIX). Only the first 16 bytes feed the base32 encode, so sizing the
// stream correctly changes no id on any platform.
BitStream3 bits(147);
list<string> propList;
unsigned char version = 1;
unsigned short hash1, hash2, hash3, hash4;
unsigned short h0 = HashInt(0);
bits.Write(&version, 3);
propList.clear();
#ifdef _WIN32
wmi.GetPropertyList("SELECT * FROM Win32_ComputerSystemProduct", "UUID", &propList);
hash1 = h0;
string s;
for (list<string>::iterator iter = propList.begin(); iter != propList.end(); iter++)
{
s = NormalizeHardwareString(*iter);
if ((s.length() > 1)
&& (s != "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
&& (s != "00000000000000000000000000000000"))
{
hash1 = HashString(s.c_str());
}
}
#else
propList.push_back("4294967296");
#endif
bits.WriteUInt16(hash1);
// CPU IDs - get up to 4 for better resilience
propList.clear();
#ifdef _WIN32
wmi.GetPropertyList("SELECT ProcessorId FROM Win32_Processor", "ProcessorId", &propList, 4);
#else
GetCPUIDPropertyList(&propList);
#endif
// Normalize CPU IDs
for (auto& cpu : propList) {
cpu = NormalizeHardwareString(cpu);
}
hash1 = (propList.size() > 0) ? HashString(propList.front().c_str()) : h0;
hash2 = (propList.size() > 1) ? HashString(propList.back().c_str()) : h0;
bits.WriteUInt16(hash1);
bits.WriteUInt16(hash2);
// MAC Addresses - get MORE adapters and sort for consistency
propList.clear();
#ifdef _WIN32
// Try physical PCI adapters first
wmi.GetPropertyList("SELECT MACAddress FROM Win32_NetworkAdapter WHERE (AdapterType = \"Ethernet 802.3\") AND (MACAddress IS NOT NULL) AND PNPDeviceId LIKE \"%PCI%\"", "MACAddress", &propList, 6);
// Fallback to VMBUS for VMs
if (propList.size() == 0)
{
wmi.GetPropertyList("SELECT MACAddress FROM Win32_NetworkAdapter WHERE (AdapterType = \"Ethernet 802.3\") AND (MACAddress IS NOT NULL) AND PNPDeviceId LIKE \"%VMBUS%\"", "MACAddress", &propList, 6);
}
#else
GetMACPropertyList(&propList, 6);
#endif
// Normalize and sort MAC addresses for consistent ordering
for (auto& mac : propList) {
mac = NormalizeHardwareString(mac);
}
propList.sort();
// Store up to 4 MAC hashes
auto macIter = propList.begin();
hash1 = (propList.size() > 0 && macIter != propList.end()) ? HashString((macIter++)->c_str()) : h0;
hash2 = (propList.size() > 1 && macIter != propList.end()) ? HashString((macIter++)->c_str()) : h0;
hash3 = (propList.size() > 2 && macIter != propList.end()) ? HashString((macIter++)->c_str()) : h0;
hash4 = (propList.size() > 3 && macIter != propList.end()) ? HashString((macIter++)->c_str()) : h0;
bits.WriteUInt16(hash1);
bits.WriteUInt16(hash2);
bits.WriteUInt16(hash3);
bits.WriteUInt16(hash4);
// HDD Serial Numbers - get more drives and sort
propList.clear();
#ifdef _WIN32
wmi.GetPropertyList("SELECT SerialNumber FROM Win32_PhysicalMedia WHERE SerialNumber IS NOT NULL", "SerialNumber", &propList, 4);
#else
GetHDDPropertyList(&propList, 4);
#endif
// Normalize and sort HDD serials
for (auto& serial : propList) {
serial = NormalizeHardwareString(serial);
}
propList.sort();
auto hddIter = propList.begin();
hash1 = (propList.size() > 0 && hddIter != propList.end()) ? HashString((hddIter++)->c_str()) : h0;
hash2 = (propList.size() > 1 && hddIter != propList.end()) ? HashString((hddIter++)->c_str()) : h0;
bits.WriteUInt16(hash1);
bits.WriteUInt16(hash2);
unsigned char* rawHwid = bits.GetBuffer();
BASE32 base32;
auto encHwid = base32.encode(rawHwid, 16);
hardwareId = encHwid.c_str();
hardwareId.erase(hardwareId.length() - 1);
unsigned i;
unsigned insertPos;
// separate character groups
for (i = 0, insertPos = 5; i < 4; i++)
{
hardwareId.insert(insertPos, "-");
insertPos += 6;
}
return hardwareId.c_str();
}
bool HardwareId::MatchCurrentHardwareId(const char* hwid)
{
#ifdef _WIN32
WmiHelper wmi;
#endif
unsigned short h0 = HashInt(0);
string hardwareId((char*)hwid);
for (int i = 0, erasePos = 0; i < 4; i++)
{
erasePos += 5;
hardwareId.erase(erasePos, 1);
}
BASE32 base32;
int bufLen;
int padLen;
int len = base32.encode_pad_length(((int)hardwareId.length() * 5 + 7) >> 3, &padLen);
if (len > (int)hardwareId.length())
hardwareId.append(len - hardwareId.length(), 'A');
if (padLen)
hardwareId.append(padLen, '=');
auto buf = base32.decode(hardwareId.c_str(), hardwareId.length(), &bufLen);
BitStream3 bits;
bits.Attach(buf.data(), 125);
unsigned char version = 0;
bits.Read(&version, 3);
if ((version & 0x7) > 1)
throw new LicensingException(STATUS_GENERIC_ERROR, "invalid hardware id version");
list<string> propList;
set<unsigned short> storedHashes; // Store all hashes from license
unsigned short hash1, hash2, hash3, hash4;
// Use a points-based matching system for resilience
int matchPoints = 0;
const int REQUIRED_POINTS = 2; // Need at least 2 components to match
// Read UUID hash
bits.ReadUInt16(&hash1);
if (version == 0)
{
// Legacy version 0 support (memory size based)
if (hash1 != h0)
{
unsigned long long memSize = 0;
#ifdef _WIN32
wmi.GetPropertyList("SELECT Capacity FROM Win32_PhysicalMemory", "Capacity", &propList);
#else
propList.push_back("4294967296");
#endif
if (propList.size() > 0)
{
for (list<string>::iterator iter = propList.begin(); iter != propList.end(); iter++)
{
memSize += _atoi64(iter->c_str());
}
memSize = memSize / (1024 * 1024);
if (hash1 != HashInt((int)memSize))
return false;
}
}
matchPoints += 2; // UUID/Memory match gives 2 points
}
else
{
// Version 1+ - UUID based
#ifdef _WIN32
wmi.GetPropertyList("SELECT * FROM Win32_ComputerSystemProduct", "UUID", &propList);
#endif
if (propList.size() > 0)
{
string s = NormalizeHardwareString(propList.front());
if ((s.length() > 1)
&& (s != "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
&& (s != "00000000000000000000000000000000"))
{
if (hash1 != h0 && hash1 == HashString(s.c_str()))
{
matchPoints += 2; // UUID match is worth 2 points (most stable)
}
}
}
}
// Read CPU hashes
bits.ReadUInt16(&hash1);
bits.ReadUInt16(&hash2);
storedHashes.clear();
if (hash1 != h0) storedHashes.insert(hash1);
if (hash2 != h0) storedHashes.insert(hash2);
propList.clear();
#ifdef _WIN32
wmi.GetPropertyList("SELECT ProcessorId FROM Win32_Processor", "ProcessorId", &propList, 4);
#else
GetCPUIDPropertyList(&propList);
#endif
// Check if ANY current CPU matches stored hashes
int cpuMatches = 0;
for (auto& cpu : propList) {
string s = NormalizeHardwareString(cpu);
unsigned short currentHash = HashString(s.c_str());
if (storedHashes.find(currentHash) != storedHashes.end()) {
cpuMatches++;
}
}
if (cpuMatches > 0) {
matchPoints += 1; // CPU match is worth 1 point
}
// Read MAC hashes (now 4 hashes for better resilience)
bits.ReadUInt16(&hash1);
bits.ReadUInt16(&hash2);
bits.ReadUInt16(&hash3);
bits.ReadUInt16(&hash4);
storedHashes.clear();
if (hash1 != h0) storedHashes.insert(hash1);
if (hash2 != h0) storedHashes.insert(hash2);
if (hash3 != h0) storedHashes.insert(hash3);
if (hash4 != h0) storedHashes.insert(hash4);
propList.clear();
#ifdef _WIN32
wmi.GetPropertyList("SELECT MACAddress FROM Win32_NetworkAdapter WHERE (AdapterType = \"Ethernet 802.3\") AND (MACAddress IS NOT NULL) AND PNPDeviceId LIKE \"%PCI%\"", "MACAddress", &propList, 10);
if (propList.size() == 0)
{
wmi.GetPropertyList("SELECT MACAddress FROM Win32_NetworkAdapter WHERE (AdapterType = \"Ethernet 802.3\") AND (MACAddress IS NOT NULL) AND PNPDeviceId LIKE \"%VMBUS%\"", "MACAddress", &propList, 10);
}
#else
GetMACPropertyList(&propList, 10);
#endif
// Check if ANY current MAC address matches stored hashes
int macMatches = 0;
for (auto& mac : propList) {
string s = NormalizeHardwareString(mac);
unsigned short currentHash = HashString(s.c_str());
if (storedHashes.find(currentHash) != storedHashes.end()) {
macMatches++;
}
}
if (macMatches > 0) {
matchPoints += 1; // MAC match is worth 1 point
}
// Read HDD hashes
bits.ReadUInt16(&hash1);
bits.ReadUInt16(&hash2);
storedHashes.clear();
if (hash1 != h0) storedHashes.insert(hash1);
if (hash2 != h0) storedHashes.insert(hash2);
propList.clear();
#ifdef _WIN32
wmi.GetPropertyList("SELECT SerialNumber FROM Win32_PhysicalMedia WHERE SerialNumber IS NOT NULL", "SerialNumber", &propList, 10);
#else
GetHDDPropertyList(&propList, 10);
#endif
// Check if ANY current HDD serial matches stored hashes
int hddMatches = 0;
for (auto& serial : propList) {
string s = NormalizeHardwareString(serial);
unsigned short currentHash = HashString(s.c_str());
if (storedHashes.find(currentHash) != storedHashes.end()) {
hddMatches++;
}
}
if (hddMatches > 0) {
matchPoints += 1; // HDD match is worth 1 point
}
// Validation passes if we have enough matching points
// Typical valid scenarios:
// - UUID (2) + CPU (1) = 3 points ✓
// - UUID (2) + MAC (1) = 3 points ✓
// - UUID (2) + HDD (1) = 3 points ✓
// - CPU (1) + MAC (1) + HDD (1) = 3 points ✓ (if UUID changed but hardware same)
return matchPoints >= REQUIRED_POINTS;
}