Ich habe versehentlich meine Festplatte getrennt, während sie noch lief, und meine Windows 7-Installation beschädigt. Ich kann jetzt Windows nicht mehr vollständig starten. Ich habe alles versucht, um die Installation zu reparieren: Windows Startup Repair, chkdsk / r, SFC / scannow, bootrec / rebuildbcd usw. und kein Glück. Ich möchte nur eine Neuinstallation durchführen, aber mein Problem ist, dass ich meinen Windows-Produktschlüssel nirgendwo notiert habe und keine Skripte oder Dienstprogramme verwenden kann, um ihn aus der Registrierung abzurufen, da ich nicht in Windows booten kann.

Windows 7-Produktschlüssel werden verschlüsselt im Wert "DigitalProductId" des Registrierungsschlüssels HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ Windows NT \ CurrentVersion gespeichert. Ich konnte die beschädigte Windows-Partition schreibgeschützt von einer Ubuntu-Live-CD bereitstellen und die Registrierungsstruktur Windows \ System32 \ config \ SOFTWARE, die den betreffenden Schlüssel und Wert enthält, auf ein Flash-Laufwerk kopieren, diese Struktur jedoch in regedit laden Bei einer funktionierenden Windows-Installation und dem Versuch, den geladenen Wert "DigitalProductId" mithilfe von Skripten oder Dienstprogrammen zu entschlüsseln, wird nur der Produktschlüssel der Windows-Hostinstallation zurückgegeben, unabhängig davon, wie viel Fummelei ich versuche. Ich habe versucht, den Microsoft-Support zu kontaktieren, und sie waren nicht hilfreich. Würde mich jemand weiter führen können? Vielleicht, wenn es eine andere Möglichkeit gibt, den Produktschlüssel von Linux abzurufen?

Wenn jemand, der mit Skripten / Kryptografie besser vertraut ist, bereit wäre, das Entschlüsselungsskript zu befolgen, um den Produktschlüssel von Hand zu entschlüsseln, könnte ich Ihnen den exportierten Wert "DigitalProductId", die SOFTWARE-Registrierungsstruktur und das Entschlüsselungsskript per E-Mail senden.

Für Linux gibt es ein großartiges Tool namens chntpw. Sie können es einfach auf Debian / Ubuntu bekommen über:

sudo apt install chntpw

Um in die entsprechende Registrierungsdatei zu schauen, hängen Sie die Windows-Festplatte ein und öffnen Sie sie wie folgt:

chntpw -e /path/to/windisk/Windows/System32/config/software

Geben Sie nun den folgenden DigitalProductIdBefehl ein , um die Entschlüsselung zu erhalten :

dpi \Microsoft\Windows NT\CurrentVersion\DigitalProductId

Für diejenigen, die nicht schüchtern sind, ein bisschen zu programmieren.

Ich habe vor ungefähr 10 Jahren einen Algorithmus gefunden und ihn in C # implementiert (siehe unten).

Wenn Sie es nur unter Windows ausführen möchten

Ich habe mir erlaubt, es in ein Powershell-Skript umzuwandeln:

$dpid = Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name "DigitalProductId"

# Get the range we are interested in
$id = $dpid.DigitalProductId[52..(52+14)]

# Character table
$chars = "BCDFGHJKMPQRTVWXY2346789"

# Variable for the final product key
$pkey = ""

# Calculate the product key
for ($i=0; $i -le 24; $i++) {
    $c = 0

    for($j=14; $j -ge 0; $j--) {
        $c = ($c -shl 8) -bxor $id[$j]

        $id[$j] = [Math]::Floor($c / 24) -band 255

        $c = $c % 24
    }
    $pkey = $chars[$c] + $pkey
}
# Insert some dashes
for($i = 4; $i -gt 0; $i--) {
    $pkey = $pkey.Insert($i * 5, "-")
}
$pkey

Führen Sie dies aus und Sie erhalten Ihren Produktschlüssel. (Also doch keine Codierung für dich)

Ursprünglicher Beitrag

Das ist also der eigentliche C # -Code, den ich ausgegraben und kommentiert habe.

public static string ConvertDigitalProductID(string regPath, string searchKey = "DigitalProductID") {
    // Open the sub key i.E.: "Software\Microsoft\Windows NT\CurrentVersion"
    var regkey = Registry.LocalMachine.OpenSubKey(regPath, false);
    // Retreive the value of "DigitalProductId"
    var dpid = (byte[])regkey.GetValue(searchKey);
    // Prepare an array for the relevant parts
    var idpart = new byte[15];

    // Copy the relevant parts of the array
    Array.Copy(dpid, 52, idpart, 0, 15);

    // Prepare the chars that will make up the key
    var charStore = "BCDFGHJKMPQRTVWXY2346789";

    // Prepare a string for the result
    string productkey = "";

    // We need 24 iterations (one for each character)
    for(int i = 0; i < 25; i++) {

        int c = 0;
        // Go through each of the 15 bytes of our dpid
        for(int j = 14; j >= 0; j--) {
            // Shift the current byte to the left and xor in the next byte
            c = (c << 8) ^ idpart[j];

            // Leave the result of the division in the current position
            idpart[j] = (byte)(c / 24);

            // Take the rest of the division forward to the next round
            c %= 24;
        }
        // After each round, add a character from the charStore to our key
        productkey = charStore[c] + productkey;
    }

    // Insert the dashes
    for(int i = 4; i > 0; i--) {
        productkey = productkey.Insert(i * 5, "-");
    }

    return productkey;
}

Sie müssen es Software\Microsoft\Windows NT\CurrentVersionals Schlüssel übergeben, wo es den findetDigitalProductId

Zu diesem Zeitpunkt verwendete MS Office Products denselben Algorithmus, sodass durch die Bereitstellung des entsprechenden Registrierungsschlüssels für die Funktion auch diese Produktschlüssel berechnet werden konnten.

Sie können die Funktion natürlich so umgestalten, dass ein Byte-Array als Eingabe verwendet wird.

Wie für heute. Ich habe es gerade auf meinem Windows 10-Computer getestet und es funktioniert immer noch.

Hier ist ein Python-Port der anderen Antwort (angepasst für Windows 8.1). Dies hat den Vorteil, chntpwdass es auch mit schreibgeschützten Laufwerken funktioniert.

Bedarf:

pip install python-registry

Code:

#!/usr/bin/env python
import sys
from Registry import Registry
reg = Registry.Registry("/path/to/drive/Windows/System32/config/RegBack/SOFTWARE")
# Uncomment for registry location for Windows 7 and below:
#reg = Registry.Registry("/path/to/drive/Windows/system32/config/software")
key = reg.open("Microsoft\Windows NT\CurrentVersion")
did = bytearray([v.value() for v in key.values() if v.name() == "DigitalProductId"][0])
idpart = did[52:52+15]
charStore = "BCDFGHJKMPQRTVWXY2346789";
productkey = "";
for i in range(25):
  c = 0
  for j in range(14, -1, -1):
    c = (c << 8) ^ idpart[j]
    idpart[j] = c // 24
    c %= 24
  productkey = charStore[c] + productkey
print('-'.join([productkey[i * 5:i * 5 + 5] for i in range(5)]))

Hier ist meine Bash-Implementierung. Ich nenne es get_windows_key.sh funktioniert gut von Clonezilla. Ich habe es ursprünglich hier gepostet: https://sourceforge.net/p/clonezilla/discussion/Open_discussion/thread/979f335385/

#!/bin/bash
# written by Jeff Sadowski
# credit
###################################################
# Pavel Hruška, Scott Skahht, and Philip M for writting
# https://github.com/mrpeardotnet/WinProdKeyFinder/blob/master/WinProdKeyFind/KeyDecoder.cs
# that I got my conversion code from
#
# I used the comments on the sudo code from
# /ubuntu/953126/can-i-recover-my-windows-product-key- from-ubuntu
# by MrPaulch
#
# and the creator of chntpw
#
# Petter Nordahl-Hagen
# without which I would not be able to get the key in linux
#
# also the creators of ntfs-3g, linux and bash

parted -l 2>/dev/null |grep -e ntfs -e fat -e Disk|grep -v Flags
#get the first mac address that isn't a loopback address
# loopback will have all zeros
MAC=$(cat /sys/class/net/*/address|grep -v 00:00:00:00:00:00|head -n 1|sed "s/:/-/g")
if [ "$1" = "" ];then
 echo "mount the Windows share then give this script the path where you mounted it"
 exit
fi
cd $1
#
# This way will work no matter what the capitalization is
next=$(find ./ -maxdepth 1 -iname windows);cd ${next}
next=$(find ./ -maxdepth 1 -iname system32);cd ${next}
next=$(find ./ -maxdepth 1 -iname config);cd ${next}
file=$(find ./ -maxdepth 1 -iname software)
#echo $(pwd)${file:1}
#Get the necissary keys
#get the version key
VERSION=$((16#$(echo -e "cat \\Microsoft\\Windows NT\\CurrentVersion\\CurrentMajorVersionNumber\nq\n" | chntpw -e ${file}|grep "^0x"|cut -dx -f2)))
hexPid_csv_full=$(echo $(echo -e "hex \\Microsoft\\Windows NT\\CurrentVersion\\DigitalProductId\nq\n" | chntpw -e ${file}|grep "^:"|cut -b 9-55)|sed 's/ /,/g' | tr '[:u>
# get the subset 53 to 68 of the registry entry
hexPid_csv=$(echo $(echo -e "hex \\Microsoft\\Windows NT\\CurrentVersion\\DigitalProductId\nq\n" | chntpw -e ${file}|grep "^:"|cut -b 9-55)|sed 's/ /,/g' | tr '[:upper:>
echo "${hexPid_csv_full}" > /custom/DigitalProductId_${MAC}.txt
#formatted output
spread()
{
 key=$1
 echo ${key:0:5}-${key:5:5}-${key:10:5}-${key:15:5}-${key:20:5}
}
# almost a direct conversion of c# code from
# https://github.com/mrpeardotnet/WinProdKeyFinder/blob/master/WinProdKeyFind/KeyDecoder.cs
# however most of this looks similar to sudo code I found
# /ubuntu/953126/can-i-recover-my-windows-product-key-from-ubuntu
DecodeProductKey()
{
digits=(B C D F G H J K M P Q R T V W X Y 2 3 4 6 7 8 9)
for j in {0..15};do
#Populate the Pid array from the values found in the registry
 Pid[$j]=$((16#$(echo ${hexPid_csv}|cut -d, -f $(($j+1)))))
done
if [ "$1" = "8+" ];then
# modifications needed for getting the windows 8+ key
 isWin8=$(($((${Pid[14]}/6))&1))
 Pid[14]=$(( $(( ${Pid[14]}&247 )) | $(( $(( ${isWin8} & 2 )) * 4 )) ))
fi
key=""
last=0
for i in {24..0};do
 current=0
 for j in {14..0};do
  # Shift the current contents of c to the left by 1 byte 
  # and add it with the next byte of our id
  current=$((${current}*256))
  current=$((${Pid[$j]} + current))
  # Put the result of the divison back into the array
  Pid[$j]=$((${current}/24))
  # Calculate remainder of c
  current=$((${current}%24))
  last=${current}
 done
 # Take character at position c and prepend it to the ProductKey
 key="${digits[${current}]}${key}"
done
if [ "$1" = "8+" ];then
# another modification needed for a windows 8+ key
 key="${key:1:${last}}N${key:$((${last}+1)):24}"
 echo -n "Windows 8+ key: "
else
 echo -n "Windows 7- key: "
fi
spread "${key}"
}
if [ "$VERSION" -gt "7" ];then
 DecodeProductKey 8+
else
 DecodeProductKey
fi