La licenza è già nel firmware
Un sacco di gente possiede una licenza del Fisher-Price OS (Windows) senza averne mai visto il product key. È arrivata con la macchina, e la chiave vive nel firmware di quella macchina, in una piccola tabella ACPI chiamata MSDM.
Poi la macchina smette di essere il posto dove si lavora. O il proprietario vuole quella licenza in una VM che ora affitta da te, oppure la macchina stessa viene cancellata, trasformata in un host Proxmox, e la copia del sistema operativo con cui è stata venduta la si vuole di nuovo come VM sopra di essa.
Dal punto di vista meccanico, è un’opzione di QEMU. Ed è proprio questo il problema. QEMU passa qualsiasi tabella a un guest senza controllarla, il guest si attiva con qualunque chiave trovi, e niente in tutto lo stack si chiede se la licenza consenta qualcosa di tutto ciò. Questo post spiega cos’è la tabella, come metterla in una VM senza passarne una corrotta, cosa dicono i termini di Microsoft sullo spostarla, e perché una licenza volume non le si avvicina mai.
Cos’è la tabella
Da OEM Activation 3.0 in poi, chi produce un PC non stampa più la chiave su un’etichetta sotto il case, dove chiunque abbia la fotocamera del telefono la può copiare, e la chiave va invece nel firmware della macchina. Gli strumenti di fabbrica di Microsoft «injects the product keys into the firmware», e il passo di validazione verifica «that the MSDM table exists» e che header e voci «comply with the correct formats»1. Una macchina preparata così «activated by using the OA3 DPK in the firmware»2. MSDM è una normale tabella ACPI, e su Linux si legge direttamente dal firmware:
sudo cat /sys/firmware/acpi/tables/MSDM > msdm.bin
Il portatile su cui è stato scritto questo post ne ha una. 85 byte.
La specifica pubblicata da Microsoft definisce l’header ACPI standard di 36 byte con la firma MSDM, e poi si ferma.
Tutto ciò che viene dopo l’header è una «Proprietary data structure that contains all the licensing data necessary to enable Windows activation»3.
| Byte | Contengono | Si sa da |
|---|---|---|
| da 0 a 35 | l’header ACPI standard: firma MSDM, lunghezza, checksum, OEM ID | la specifica di Microsoft |
| da 36 a 55 | 20 byte di campi: versione, tipo di dato, lunghezza del dato | tabelle reali, non una specifica pubblicata |
| da 56 a 84 | il product key di 29 caratteri, cinque gruppi da cinque | tabelle reali, non una specifica pubblicata |
QEMU passa qualsiasi cosa gli dai
L’opzione -acpitable file= di QEMU prende la «whole ACPI table from the specified files, including all ACPI headers (possible overridden by other options)»4, e il guest vede poi una tabella MSDM esattamente come la presenterebbe il firmware di un portatile.
L’ho verificato con una chiave volutamente falsa.
I byte sono usciti dall’altra parte identici, dalla firma all’ultimo carattere.
QEMU non rifiuta niente.
Ecco cosa fa hw/acpi/core.c con un file rotto5:
| Cosa c’è di sbagliato nel file | Cosa fa QEMU | Cosa vede il guest |
|---|---|---|
| La lunghezza nell’header non corrisponde al file | avvisa, poi sovrascrive la lunghezza con la dimensione reale | un header valido |
| Il checksum non somma a zero | lo ricalcola, su ogni tabella, ogni volta | un checksum valido |
| Chiave troncata o storpiata | niente, i dati dopo l’header non sono affar suo | una tabella dall’aria valida attorno a una chiave rotta |
Il guest non ha modo di accorgersi della differenza, e nemmeno tu finché qualcuno non apre un ticket di supporto. Il primo a saperlo è un cliente la cui attivazione è fallita.
Quindi, se sono i clienti a caricarle, controllale prima che QEMU le veda:
#!/usr/bin/env python3
"""Refuse anything that is not a well-formed MSDM table before QEMU sees it."""
import re, struct, sys
t = open(sys.argv[1], 'rb').read()
fail = lambda why: sys.exit(f"{sys.argv[1]}: {why}")
if len(t) < 56: fail(f"{len(t)} bytes, too short for an MSDM table")
sig, length = t[:4], struct.unpack_from('<I', t, 4)[0]
if sig != b'MSDM': fail(f"signature is {sig!r}, not MSDM")
if length != len(t): fail(f"header says {length} bytes, file is {len(t)}")
if sum(t) & 0xff: fail("checksum does not sum to zero")
ver, _, dtype, _, dlen = struct.unpack_from('<5I', t, 36)
if (ver, dtype) != (1, 1): fail(f"version {ver}, data type {dtype}: expected 1 and 1")
if dlen != 29 or 56 + dlen != length: fail(f"data length {dlen}: expected 29")
key = t[56:].decode('ascii', 'replace')
if not re.fullmatch(r'([0-9A-Z]{5}-){4}[0-9A-Z]{5}', key): fail("data is not a 5x5 product key")
print(f"OK OEM {t[10:16].decode(errors='replace').strip()!r} key *****-*****-*****-*****-{key[-5:]}")
| Controlli | Confronta il file con | Un fallimento significa |
|---|---|---|
| Firma, lunghezza, checksum | l’header documentato da Microsoft | il file è rotto |
| Versione, tipo di dato, lunghezza del dato, forma della chiave | la forma che hanno le tabelle reali | guardalo a mano, non «è contraffatto» |
Non stampa mai la chiave, solo l’ultimo gruppo. Un product key in un file di log è un product key che può usare qualcun altro.
Lanciato su una tabella buona e su tre sue copie rotte:
OK OEM 'EXMPLE' key *****-*****-*****-*****-EEEEE
bad-sum.bin: checksum does not sum to zero
bad-trunc.bin: header says 85 bytes, file is 70
bad-sig.bin: signature is b'SLIC', not MSDM
Dove va, e chi ce la può mettere
Un product key è un segreto.
Non va messo da nessuna parte dove www-data possa leggerlo, e pmxcfs ti dà esattamente un posto in /etc/pve dove non può6:
| Dove potrebbe stare la tabella | Chi può leggerla | Su ogni nodo dove la VM può migrare |
|---|---|---|
/etc/pve/priv | solo root | sì |
in qualsiasi altro punto di /etc/pve | leggibile dal gruppo, compreso il www-data dell’interfaccia web | sì |
| una directory su un solo nodo | quello che imposti tu | no |
Con 85 byte è lontanissima dal limite di 1 MiB per file di pmxcfs7:
mkdir -p /etc/pve/priv/msdm
check-msdm.py upload.bin && cp upload.bin /etc/pve/priv/msdm/9000.bin
qm set 9000 --args "-acpitable file=/etc/pve/priv/msdm/9000.bin"
qm set --args sostituisce l’intera riga.
Se la VM ha già opzioni SMBIOS o firmware in args, scrivile tutte insieme.
E siccome args è riservato a root, questo è un lavoro per il tuo provisioning, non qualcosa che un cliente può fare dall’interfaccia web.
Ed è giusto che sia così.
Il cliente fornisce il file, i tuoi strumenti lo controllano e lo collegano.
La tabella sposta una chiave, non un diritto
Qui la funzionalità richiede la testa sulle spalle. Spostare la tabella MSDM in una VM sposta la chiave. Non la licenza.
Lo dicono i termini stessi di Microsoft, e le righe che contano stanno in una tabella:
| Caso | Cosa dice Microsoft | Fonte |
|---|---|---|
| Licenza OEM, spostarla | trasferibile a un altro utente «only with the licensed device» | termini della licenza OEM8 |
| Licenza OEM, quante installazioni | «only one instance of the software for use on one device, whether that device is physical or virtual» | termini della licenza OEM8 |
| Licenza OEM, in parole povere | «locked» al PC originale «and cannot be transferred to any other PC» | blog Microsoft per le piccole imprese9 |
| L’eccezione | le norme sul trasferimento «do not apply» quando il software è stato acquistato in Germania o in un elenco di altri paesi | termini della licenza OEM8 |
| Ospitarla per i clienti | il Services Provider License Agreement è per «hosted applications to end customers» | SPLA10 |
| Edizioni desktop come VM ospitate | «VMs must be hosted by a Qualified Multitenant Hoster (QMTH)» | Microsoft Learn11 |
La tabella viene sempre dalla macchina licenziata del cliente, mai dai tuoi host. Il caso che sta pienamente dentro il testo è il più semplice: la macchina con cui è stata venduta la licenza, che ora fa girare Proxmox, con quella stessa copia del Fisher-Price OS (Windows) spostata in una sola VM sopra di essa. È ancora un’istanza su un dispositivo, e i termini OEM lo consentono «whether that device is physical or virtual»8. Una seconda VM, o un’altra macchina, e non lo è più.
In quel caso la macchina del cliente e l’hypervisor sono la stessa scatola, quindi non c’è niente da caricare e niente da copiare.
Il kernel di Proxmox espone già la tabella MSDM del firmware sotto /sys/firmware/acpi/tables/, leggibile solo da root, e QEMU su Proxmox gira come root, quindi può prendere la tabella direttamente da lì:
qm set 100 --args "-acpitable file=/sys/firmware/acpi/tables/MSDM"
Puntare alla tabella viva invece che a una copia ha due conseguenze.
Il percorso viene letto su qualunque nodo la VM si avvii, quindi questa soluzione va su un host standalone e non in un cluster: migra la VM e o prende la tabella di quel nodo, una licenza diversa su una macchina diversa, o non parte affatto, perché QEMU rifiuta un file mancante con can't open file … No such file or directory.
Ed è una riga sola, il che la rende una riga sola da incollare su una seconda VM.
Quella seconda VM è il caso che i termini non coprono, quindi una VM la riceve e nessun’altra.
Quindi costruisci la funzionalità. Il meccanismo è solido, e ci sono clienti che hanno diritto a usarlo; uno che ha comprato la licenza in Germania potrebbe benissimo essere tra questi. Ma metti il diritto dove deve stare: nei tuoi termini di servizio, il cliente garantisce di avere una licenza che copre l’uso nella tua VM, e lo fa prima che il pulsante di caricamento faccia qualsiasi cosa. Il validatore dimostra che la tabella è ben formata. Niente dimostra che sia sua da usare.
Le licenze volume non si avvicinano mai alla tabella
Un cliente con una licenza volume può usare la stessa strada? No. Non c’è niente che la tabella debba portare.
MSDM appartiene al canale OEM e a nient’altro. La guida di pianificazione di Microsoft dice che l’attivazione OEM «is available only for computers that are purchased through OEM channels and have the Windows operating system preinstalled»12. Le licenze volume si attivano con uno di altri tre modelli, «Multiple Activation Keys (MAK)», «KMS» e «Active Directory-based activation»12, e in ognuno di essi la chiave è installata nel sistema operativo. Niente la legge dal firmware.
| Metodo | Dove vive la chiave | Con cosa parla il guest | In una VM Proxmox |
|---|---|---|---|
| OEM, OA 3.0 | la tabella MSDM nel firmware | i server di attivazione di Microsoft | la strada -acpitable vista sopra |
| MAK | installata nel guest | Microsoft, una volta, scalata dalle attivazioni della chiave | funziona con accesso a internet o per telefono |
| KMS | una chiave generica (GVLK) nel guest | l’host KMS del cliente su TCP 1688 | serve una rotta fino a lì, e 25 client o 5 server prima che attivi qualcosa |
| Active Directory | una GVLK nel guest | i domain controller del cliente, almeno ogni 180 giorni | serve la VM unita al loro dominio |
| AVMA | una chiave generica nel guest | la licenza Datacenter dell’host Hyper-V | non disponibile affatto |
Quindi per un cliente volume non c’è niente da costruire sull’hypervisor. La sua chiave va nella sua immagine, e la tua parte è il percorso di rete: la porta 1688 verso il suo host KMS, o una VPN verso i suoi domain controller. Lo slot MSDM resta vuoto, ed è giusto così.
Due cose fregano la gente. La chiave generica sui supporti volume da sola non attiva niente, perché «the GVLK doesn’t work unless a valid KMS host key can be found»12, quindi una VM costruita dalla ISO Enterprise del cliente senza una rotta verso casa resta non attivata. E una licenza volume desktop non è una licenza a sé. I programmi volume «cover upgrades to Windows client operating systems only», e «an existing retail or OEM operating system license is needed for each computer»12. La licenza volume si appoggia su una licenza base, molto spesso proprio la stessa OEM di cui parlava la sezione precedente, e se possa girare nella tua VM resta la questione di hosting in quella tabella, non una questione di attivazione.
AVMA si merita una riga tutta sua, perché è quella che sembra la risposta. È il modo di Microsoft perché un host attivi i propri guest server, legando «the VM activation to the licensed virtualization host», e richiede «a Windows Server Datacenter edition with the Hyper-V server host role installed»13. Sul resto Microsoft è chiara: «AVMA doesn’t work with other server virtualization technologies»13. Su Proxmox i guest server si attivano con le tue chiavi SPLA o con il KMS del cliente.
Niente nello stack controlla le carte
Ogni strato qui fa il suo lavoro e niente di più. Il firmware conserva una chiave. QEMU copia i byte e sistema l’header. Il guest legge la chiave e si attiva con quella. Nessuno di loro può dire se la macchina sottostante sia quella con cui è stata venduta la licenza, e nessuno di loro è mai stato pensato per farlo.
Quindi il controllo ricade su chi gestisce l’hypervisor. Una licenza è un accordo tra chi l’ha comprata e Microsoft, e la tua piattaforma non ne è parte, ma è la cosa che sposta la chiave, e questo rende la domanda tua che tu l’abbia chiesta o no.
Scrivi la risposta prima che il pulsante di caricamento faccia qualsiasi cosa. Una macchina, una VM, la licenza del cliente e la sua parola che copre questo uso. Non costa niente, e protegge te quanto lui. Il software sposterà qualunque chiave gli venga data. Se avrebbe dovuto farlo è una domanda a cui solo una persona può rispondere, quindi assicurati che una persona ci sia.
Microsoft Learn, OA 3.0 on the factory floor — «injects the product keys into the firmware»;
/Validateverifica «that the MSDM table exists». ↩︎Microsoft Learn, Validate an OEM Activation key — «is activated by using the OA3 DPK in the firmware». ↩︎
Microsoft, Microsoft Software Licensing Tables (SLIC and MSDM) — tabella 2, offset 36: «Proprietary data structure that contains all the licensing data necessary to enable Windows activation.» ↩︎
QEMU, System Emulation, Invocation — campi di
-smbiosper tipo;-acpitable«For file=, take whole ACPI table from the specified files, including all ACPI headers»;-boot«Currently Seabios for X86 system support it.» ↩︎QEMU v11.0.3,
hw/acpi/core.c— «ACPI table has wrong length» è unwarn_report, poi la lunghezza viene sovrascritta e il checksum ricalcolato. ↩︎pve-cluster,
src/pmxcfs/pmxcfs.c— i percorsi sottoprivsono mascherati a0777700, tutto il resto a0777750. ↩︎pve-cluster,
src/pmxcfs/memdb.h—#define MEMDB_MAX_FILE_SIZE (1024 * 1024) // 1 MiB. ↩︎Microsoft, Windows 11 OEM licence terms — «you may transfer the license to use the software directly to another user, only with the licensed device»; le norme sul trasferimento «do not apply if you acquired the software in Germany» o nei paesi elencati. Copia d’archivio; la pagina viva rifiuta le richieste automatiche. ↩︎ ↩︎ ↩︎ ↩︎
Microsoft, small business blog archive — «the OEM Windows license is ’locked’ to the original PC it comes with and cannot be transferred to any other PC.» ↩︎
Microsoft, Services Provider License Agreement — «for service providers and software development companies licensing eligible Microsoft products to provide software services and hosted applications to end customers.» ↩︎
Microsoft Learn, Windows subscription activation for VDA — «VMs must be hosted by a Qualified Multitenant Hoster (QMTH).» ↩︎
Microsoft Learn, Plan for volume activation — i tre modelli di attivazione volume; le soglie KMS di «at least five computers» per i server e «at least 25 computers» per i client, sulla porta TCP 1688; l’attivazione basata su Active Directory che richiede il dominio «at least once every 180 days»; «the GVLK doesn’t work unless a valid KMS host key can be found»; le licenze volume «cover upgrades to Windows client operating systems only». ↩︎ ↩︎ ↩︎ ↩︎
Microsoft Learn, Automatic Virtual Machine Activation in Windows Server — «AVMA requires a Windows Server Datacenter edition with the Hyper-V server host role installed»; «AVMA doesn’t work with other server virtualization technologies.» ↩︎ ↩︎