DEV9: allow a configurable / generated MAC address

The PS2 SMAP MAC lives in the first four words of the DEV9 EEPROM. The
built-in default image hardcodes 76:6D:61:63:30:31 ("vmac01"), and it is
only replaced when the user happens to have an eeprom.dat next to the
binary. Every install without one therefore presents an identical MAC.

Two instances bridged onto the same LAN are an address collision: switch
MAC tables flap and DHCP hands out a single lease. Nothing on the network
can tell two emulated consoles apart.

Add DEV9Options::Mac and DEV9Options::AutoMac. On init, and only when the
built-in image is in use, write the configured MAC into the EEPROM and fix
the checksum. A user supplied eeprom.dat is never touched.

When no MAC is configured and AutoMac is set, generate one, persist it via
the host settings and reuse it from then on. Generated once rather than per
boot: re-rolling on every launch would break DHCP leases and switch MAC
tables, which are the problems this is meant to fix. Generated addresses
clear the multicast bit and set the locally administered bit so they cannot
be mistaken for a vendor assigned address.

EEPROM words 0-2 hold the MAC and word 3 holds their 16-bit sum:
0x6D76 + 0x6361 + 0x3130 = 0x10207, truncated to 0x0207, which is exactly
the checksum stored in the existing default.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: taserz

pcsx2/Config.h

@@ -1066,6 +1066,14 @@ struct Pcsx2Config
 
 		std::vector<HostEntry> EthHosts;
 
+		// PS2 SMAP MAC. All-zero means "not set yet"; with AutoMac a unique
+		// address is generated once and persisted, so each install is
+		// distinguishable on the network instead of sharing the built-in
+		// default. Generated once rather than per boot: a MAC that changes
+		// every launch breaks DHCP leases and switch MAC tables.
+		u8 Mac[6]{};
+		bool AutoMac{true};
+
 		bool HddEnable{false};
 		std::string HddFile;
 
@@ -1079,6 +1087,8 @@ struct Pcsx2Config
 	protected:
 		static void LoadIPHelper(u8* field, const std::string& setting);
 		static std::string SaveIPHelper(u8* field);
+		static void LoadMacHelper(u8* field, const std::string& setting);
+		static std::string SaveMacHelper(u8* field);
 	};
 
 	// ------------------------------------------------------------------------

pcsx2/DEV9/DEV9.cpp

@@ -5,6 +5,10 @@
 #include "common/Path.h"
 #include "common/StringUtil.h"
 
+#include <cstring>
+#include <random>
+
+#include "Host.h"
 #include "IopDma.h"
 
 #ifdef _WIN32
@@ -70,6 +74,36 @@ u8 eeprom[] = {
 };
 // clang-format on
 
+// The MAC occupies EEPROM words 0-2, with word 3 holding their 16-bit sum.
+// Verified against the default above: 0x6D76 + 0x6361 + 0x3130 == 0x10207,
+// truncated to 0x0207, which is exactly the 0x07,0x02 stored there.
+static u16 DEV9MacChecksum(const u8* mac)
+{
+	const u16 w0 = static_cast<u16>(mac[0] | (mac[1] << 8));
+	const u16 w1 = static_cast<u16>(mac[2] | (mac[3] << 8));
+	const u16 w2 = static_cast<u16>(mac[4] | (mac[5] << 8));
+	return static_cast<u16>(w0 + w1 + w2);
+}
+
+static void DEV9SetEepromMac(u8* ee, const u8* mac)
+{
+	std::memcpy(ee, mac, 6);
+	const u16 sum = DEV9MacChecksum(ee);
+	ee[6] = static_cast<u8>(sum & 0xFF);
+	ee[7] = static_cast<u8>(sum >> 8);
+}
+
+// A generated address must never be mistakable for a vendor-assigned one:
+// clear the multicast bit and set the locally-administered bit.
+static void DEV9GenerateMac(u8* mac)
+{
+	std::random_device rd;
+	for (int i = 0; i < 6; i++)
+		mac[i] = static_cast<u8>(rd() & 0xFF);
+
+	mac[0] = static_cast<u8>((mac[0] & 0xFC) | 0x02);
+}
+
 #ifdef _WIN32
 HANDLE hEeprom;
 HANDLE mapping;
@@ -159,6 +193,36 @@ s32 DEV9init()
 	}
 #endif
 
+	// Only ever touch the built-in image. If the user supplied an eeprom.dat
+	// it is theirs, MAC included, and must be left exactly as found.
+	if (dev9.eeprom == reinterpret_cast<u16*>(eeprom))
+	{
+		u8 mac[6];
+		std::memcpy(mac, EmuConfig.DEV9.Mac, 6);
+
+		const bool unset = (mac[0] | mac[1] | mac[2] | mac[3] | mac[4] | mac[5]) == 0;
+		if (unset && EmuConfig.DEV9.AutoMac)
+		{
+			DEV9GenerateMac(mac);
+			std::memcpy(EmuConfig.DEV9.Mac, mac, 6);
+
+			// EmuConfig is a runtime copy populated FROM the settings store, so
+			// writing it alone is discarded on exit and a fresh MAC would be
+			// generated every boot. Persist through the host settings instead,
+			// which is what makes this stable across restarts.
+			const std::string macStr = StringUtil::StdStringFromFormat(
+				"%02X:%02X:%02X:%02X:%02X:%02X",
+				mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+			Host::SetBaseStringSettingValue("DEV9/Eth", "Mac", macStr.c_str());
+			Host::CommitBaseSettingChanges();
+
+			Console.WriteLn("DEV9: generated MAC %s", macStr.c_str());
+		}
+
+		if (!unset || EmuConfig.DEV9.AutoMac)
+			DEV9SetEepromMac(eeprom, mac);
+	}
+
 	for (int rxbi = 0; rxbi < (SMAP_BD_SIZE / 8); rxbi++)
 	{
 		smap_bd_t* pbd = (smap_bd_t*)&dev9.dev9R[SMAP_BD_RX_BASE & 0xffff];

pcsx2/Pcsx2Config.cpp

@@ -1323,6 +1323,14 @@ void Pcsx2Config::DEV9Options::LoadSave(SettingsWrapper& wrap)
 		SettingsWrapEntry(EthLogDHCP);
 		SettingsWrapEntry(EthLogDNS);
 
+		// Persisted so a generated MAC is stable across restarts. Rotating it
+		// every boot would break DHCP leases and switch MAC tables.
+		SettingsWrapEntry(AutoMac);
+		std::string macStr = SaveMacHelper(Mac);
+		SettingsWrapEntryEx(macStr, "Mac");
+		if (wrap.IsLoading())
+			LoadMacHelper(Mac, macStr);
+
 		SettingsWrapEntry(InterceptDHCP);
 
 		std::string ps2IPStr = "0.0.0.0";
@@ -1446,6 +1454,31 @@ std::string Pcsx2Config::DEV9Options::SaveIPHelper(u8* field)
 	return StringUtil::StdStringFromFormat("%u.%u.%u.%u", field[0], field[1], field[2], field[3]);
 }
 
+void Pcsx2Config::DEV9Options::LoadMacHelper(u8* field, const std::string& setting)
+{
+	if (setting.empty())
+	{
+		std::fill(field, field + 6, 0);		// unset; DEV9 will generate one
+		return;
+	}
+
+	if (6 == sscanf(setting.c_str(), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+			&field[0], &field[1], &field[2], &field[3], &field[4], &field[5]))
+		return;
+
+	Console.Error("Invalid MAC address in settings file");
+	std::fill(field, field + 6, 0);
+}
+
+std::string Pcsx2Config::DEV9Options::SaveMacHelper(u8* field)
+{
+	if ((field[0] | field[1] | field[2] | field[3] | field[4] | field[5]) == 0)
+		return std::string();				// keep "unset" out of the ini
+
+	return StringUtil::StdStringFromFormat("%02X:%02X:%02X:%02X:%02X:%02X",
+		field[0], field[1], field[2], field[3], field[4], field[5]);
+}
+
 bool Pcsx2Config::DEV9Options::HostEntry::operator==(const HostEntry& right) const
 {
 	return OpEqu(Url) &&