Recupere la clave de producto de Windows 8 de la placa base

Mi nueva computadora portátil viene preinstalada con Windows 8. Ingenuamente, tal como estoy, acabo de formatear el disco duro e instalé Ubuntu antiguo. Ahora quiero instalar Windows 8 para el arranque dual nuevamente, pero no tengo DVD y descargo el ISO, necesito una clave de producto. Esa clave ya no está en la parte posterior de la computadora portátil, sino en algún lugar de la placa base.

¿Hay alguna forma de recuperar la clave de producto de la placa base usando Ubuntu?

Por lo general, los fabricantes OEM han precargado una clave electrónicamente en una ROM. Windows identificará esto y activará automáticamente su instalación. Entonces, por lo general, no necesita saber este código. Sin embargo, puede ver algún rastro de esto usando

sudo dmidecode

listado como OEM-specific Types, codificado / encriptado, que puede contenerlo. Los principales OEM como HP y Dell usan esto. Pregunte en los sitios web de Windows para más detalles; Este es el lugar equivocado. El único detalle que recuerdo es que uno necesita una versión OEM del disco de instalación de Windows (es decir, no minorista).

Otra forma que no requiere mirar a través de un montón de salida es:

sudo acpidump -b -t MSDM | dd bs=1 skip=56 2>/dev/null;echo

acpidump volca la tabla (por defecto en formato hexdump), pero las opciones -b le dice que muestre los datos sin procesar. Como solo necesitamos la última parte de la tabla, canalice la salida en dd, pero omita la basura innecesaria. Finalmente, agregue un eco al final para que sea compatible con terminales = D

acpidump -t MSDM funcionará también, pero la clave se rompe en varias líneas, lo que dificulta la copia.

Actualización gracias a Lekensteyn:

Las nuevas versiones acpidumpenviadas con Ubuntu funcionan de manera diferente a la descrita anteriormente. El indicador -b hace acpidumpque se escriba en un archivo en todas las circunstancias, por lo que un método alternativo es usar el comando

sudo tail -c+57 /sys/firmware/acpi/tables/MSDM

Un instalador legítimo de Windows 8 debería detectar automáticamente la clave en el ACPI y continuar la instalación con la clave incorporada.

Sin embargo, debe tenerse en cuenta que utilicé este método para intentar instalar Win8 en una máquina virtual utilizando mi propia clave de producto, pero se desactivó automáticamente diciendo que la clave de producto estaba en uso. Por lo tanto, es de poca utilidad en toda la realidad. Dado que las claves OEM de Win8 están diseñadas para vincularse a esa computadora específica, golpeará una pared de ladrillos si le pide a Microsoft que anule el registro de la clave para poder usarla en una VM, y mucho menos en otra computadora.

La única forma en que podría usar la clave es si nunca antes había arrancado en Win8 o no estaba conectado a una red cuando lo hizo. Aun así, si alguna vez se permite que su VM / computadora nueva se conecte a la red, registrará automáticamente la clave haciendo que su instalación real sea inutilizable.

 sudo tail -c+57 /sys/firmware/acpi/tables/MSDM

Esto me dio la clave de producto de mi OEM Windows 8 en la computadora portátil MSI.

Todos pueden usar este código que funciona tan bien si los anteriores no funcionan para usted o si solo desea ver la salida hexadecimal con su clave. Es similar a bendecir el editor binario hexadecimal. Windows tendrá su clave en el formato habitual HAN50-0L00M-4D31T-CR4ZY. 5 letras o números en 5 grupos.

$ ls /sys/firmware/acpi/tables
$ sudo hd /sys/firmware/acpi/tables/MSDM

00000000  ha ns oo lo oe at es ap  pl le sa uc ef or li fe  |Key in area|
00000010  cu si ca nb ro ha ms am  cu si ca nb ro ha ms am  |In key area|
00000020  it sj us ho wz ir ol lz  it sj us ho wz ir ol lz  |Area in key|
00000000  ha ns oo lo oe at es ap  pl le sa uc ef or li fe  |It is 5 x 5|
00000010  cu si ca nb ro ha ms am  cu si ca nb ro ha ms am  |Key in area|
00000020  it sj us ho wz ir ol lz  it sj us ho wz ir ol lz  |In key area|
00000050  ha ns oo lo ow az he re                           |Area in key|
00000055                                                    |It is 5 x 5|

Ejecutar el siguiente comando volcará la clave del producto en su formato estándar de Microsoft.

sudo hexdump -s 56 -e '"MSDM key: " /29 "%s\n"' /sys/firmware/acpi/tables/MSDM

así que vi las otras respuestas aquí y necesitaba intervenir. encontré

strings /sys/firmware/acpi/tables/MSDM

funciona muy bien si la clave original es la que todavía se está utilizando. Sin embargo, tengo algunos sistemas que vinieron con la adición de inicio y necesita obtener la clave actual del registro.

winmount=/mnt
echo "hex \\Microsoft\\Windows NT\\CurrentVersion\\DigitalProductId\nq\nq" | chntpw -e ${winmount}/Windows/System32/config/SOFTWARE

entonces necesitaremos ejecutarlo a través de un algoritmo para obtener la clave.

Encontré un código de https://github.com/mrpeardotnet/WinProdKeyFinder/blob/master/WinProdKeyFind/KeyDecoder.cs

    /// <summary>
    /// Decodes Windows Product Key from the DigitalProductId. 
    /// This method applies to DigitalProductId from Windows 7 or lower versions of Windows.
    /// </summary>
    /// <param name="digitalProductId">DigitalProductId to decode</param>
    /// <returns>Decoded Windows Product Key as a string</returns>
    private static string DecodeProductKey(byte[] digitalProductId)
    {
        const int keyStartIndex = 52;
        const int keyEndIndex = keyStartIndex + 15;
        var digits = new[]
        {
            'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'M', 'P', 'Q', 'R',
            'T', 'V', 'W', 'X', 'Y', '2', '3', '4', '6', '7', '8', '9',
        };
        const int decodeLength = 29;
        const int decodeStringLength = 15;
        var decodedChars = new char[decodeLength];
        var hexPid = new ArrayList();
        for (var i = keyStartIndex; i <= keyEndIndex; i++)
        {
            hexPid.Add(digitalProductId[i]);
        }
        for (var i = decodeLength - 1; i >= 0; i--)
        {
            // Every sixth char is a separator.
            if ((i + 1) % 6 == 0)
            {
                decodedChars[i] = '-';
            }
            else
            {
                // Do the actual decoding.
                var digitMapIndex = 0;
                for (var j = decodeStringLength - 1; j >= 0; j--)
                {
                    var byteValue = (digitMapIndex << 8) | (byte)hexPid[j];
                    hexPid[j] = (byte)(byteValue / 24);
                    digitMapIndex = byteValue % 24;
                    decodedChars[i] = digits[digitMapIndex];
                }
            }
        }
        return new string(decodedChars);
    }

    /// <summary>
    /// Decodes Windows Product Key from the DigitalProductId. 
    /// This method applies to DigitalProductId from Windows 8 or newer versions of Windows.
    /// </summary>
    /// <param name="digitalProductId">DigitalProductId to decode</param>
    /// <returns>Decoded Windows Product Key as a string</returns>
    public static string DecodeProductKeyWin8AndUp(byte[] digitalProductId)
    {
        var key = String.Empty;
        const int keyOffset = 52;
        var isWin8 = (byte)((digitalProductId[66] / 6) & 1);
        digitalProductId[66] = (byte)((digitalProductId[66] & 0xf7) | (isWin8 & 2) * 4);

        const string digits = "BCDFGHJKMPQRTVWXY2346789";
        var last = 0;
        for (var i = 24; i >= 0; i--)
        {
            var current = 0;
            for (var j = 14; j >= 0; j--)
            {
                current = current*256;
                current = digitalProductId[j + keyOffset] + current;
                digitalProductId[j + keyOffset] = (byte)(current/24);
                current = current%24;
                last = current;
            }
            key = digits[current] + key;
        }

        var keypart1 = key.Substring(1, last);
        var keypart2 = key.Substring(last + 1, key.Length - (last + 1));
        key = keypart1 + "N" + keypart2;

        for (var i = 5; i < key.Length; i += 6)
        {
            key = key.Insert(i, "-");
        }

        return key;
    }

Voy a intentar decodificar el algoritmo y escribirlo en bash. La salida dmi parece ser el algoritmo más antiguo (<win8) para decodificar la clave. No he encontrado una opción para usar el nuevo algoritmo (> win7).