Datum: | Artikel 2014

Windows PowerShell Logo

Es gibt genügend Tools, die die Seriennummer von Windows auslesen können. Dabei hat Windows selbst ein mächtiges Tool im System, das den korrekten Produktkey auslesen kann – die Windows PowerShell – Bestandteil von Windows 7 und Windows 8/8.1.

Die PowerShell ähnelt der Eingabeaufforderung von Windows, basiert jedoch auf .NET Framework und ist in Windows 7 sowie Windows 8 standardmäßig im Betriebssystem integriert.

Anzeige

Die objektorientierte Shell „powershell.exe“, die im Verzeichnis system32\WindowsPowerShell\vX.x bzw. syswow64\Windowspowershell\vX.x liegt, ist viel umfangreicher als die textbasierte Eingabeaufforderung „cmd.exe“ aus dem system32- bzw. syswow64-Verzeichnis. Die Shell enthält unter anderem die grafische Entwicklungsumgebung „PowerShell ISE“ (Integrated Scripting Environment), die das Autovervollständigen von Befehlen mit der TAB-Taste unterstützt, sowie farbliche Syntaxkennzeichnungen, Mehrzeilenbearbeitungen, Sprachen mit Lese-Richtung von rechts nach links und einen Skript-Debugger. Eigentlich ist die PowerShell etwas für Entwickler, Script-Bastler oder Administratoren. Wir möchten aber mit PowerShell nur die Lizenznummer von Windows 7 und Windows 8 auslesen.

NEU: Nur ein Skript für Windows XP, Vista, Windows 7, Windows 8/8.1 und Windows 10 *GetWinKey.ps1 downloaden* (gepackt – Anleitung liegt bei).

Für Windows XP SP3, Vista SP2, Windows Server 2003 SP2 und Windows Server 2008 SP2 bietet Microsoft „Windows PowerShell 2.0“ als Download an.

Sie sollten zuerst die Dateinamenerweiterungen einblenden, damit Sie die Dateiendung sehen können. Unter Windows 7 deaktivieren Sie die Option „Erweiterungen bei bekannten Dateitypen ausblenden“ unter Ordneroptionen – Registerkarte „Ansicht“. Unter Windows 8 finden Sie im Menüband die Option, die Sie aktivieren müssen.

Skripte erlauben

Einfach loslegen geht nicht. Zuerst muss die Sicherheitsrichtlinie von PowerShell gelockert werden, damit die Shell auch Skripte ausführt. Starten Sie dazu Windows PowerShell als Administrator.

02.PowerShell

Windows 8

In der 64-Bit-Version müssen Sie die gefundene „Windows PowerShell“ – nicht die „Windows PowerShell (x86)“ – als Administrator ausführen.

03.PowerShell

Windows 7×64

04.PowerShell

Windows 7×64 – Als Administrator ausführen

Geben Sie nun folgenden Befehl ein:

set-executionpolicy remotesigned

Nach Klick auf die [Enter]-Taste wird gefragt, ob Sie die Ausführungsrichtlinie ändern möchten.

Tippen Sie j (für ja) ein und nach erneutem Klick auf die [Enter]-Taste führt die Shell nun Skripte aus.

05.PowerShell

Ausführungsrichtlinie ändern

Um später die alte Sicherheitsrichtlinie wieder zu setzen, geben Sie den folgenden Befehl ein:

set-executionpolicy restricted

Skript zum Auslesen des Produktkeys von Windows erstellen

Erstellen Sie einen Ordner unter C:\ (zum Beispiel „PowerShellKeySkript„) und öffnen Sie einen Texteditor (Notepad).

Da Windows 8.0/8.1 den Key anders wie seine Vorgänger abspeichert, gibt es zwei verschiedene Scripts:

Für Windows 7

Geben Sie im Notepad für Windows 7 Folgendes ein oder laden Sie sich das Script Win7Key.zip herunter:

function Get-WindowsKey {
    param ($targets = ".")
    $hklm = 2147483650
    $regPath = "Software\Microsoft\Windows NT\CurrentVersion"
    $regValue = "DigitalProductId"
    Foreach ($target in $targets) {
        $productKey = $null
        $win32os = $null
        $wmi = [WMIClass]"\\$target\root\default:stdRegProv"
        $data = $wmi.GetBinaryValue($hklm,$regPath,$regValue)
        $binArray = ($data.uValue)[52..66]
        $charsArray = "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 ($i = 24; $i -ge 0; $i--) {
            $k = 0
            For ($j = 14; $j -ge 0; $j--) {
                $k = $k * 256 -bxor $binArray[$j]
                $binArray[$j] = [math]::truncate($k / 24)
                $k = $k % 24
            }
            $productKey = $charsArray[$k] + $productKey
            If (($i % 5 -eq 0) -and ($i -ne 0)) {
                $productKey = "-" + $productKey
            }
        }
        $win32os = Get-WmiObject Win32_OperatingSystem -computer $target
        $obj = New-Object Object
        $obj | Add-Member Noteproperty Computer-Name -value $target
        $obj | Add-Member Noteproperty Windows-Edition -value $win32os.Caption
        $obj | Add-Member Noteproperty Windows-Version -value $win32os.CSDVersion
        $obj | Add-Member Noteproperty Bit-Version -value $win32os.OSArchitecture
        $obj | Add-Member Noteproperty Build-Nummer -value $win32os.BuildNumber
        $obj | Add-Member Noteproperty Lizenznehmer -value $win32os.RegisteredUser
        $obj | Add-Member Noteproperty Produkt-ID -value $win32os.SerialNumber
        $obj | Add-Member Noteproperty Produkt-Key -value $productkey
        $obj
    }
}

Speichern Sie im Notepad über „Datei – Speichern unter“ die Datei im Ordner „PowerShellKeySkript“ als Windows_Key.ps1 ab (NICHT als Windows_Key.ps1.txt). Wechseln Sie im Speichern-Dialog unter Dateityp von „Textdateien (*.txt)“ auf „Alle Dateien (*.*)“.

06.PowerShell

Im Notepad als Windows_Key.ps1 speichern

07.PowerShell

Speichern unter – Dateityp: Alle Dateien (*.*)

08.PowerShell

Verzeichnispfad

 

Für Windows 8/8.1

Hier weicht der Code von dem für Windows 7 ab, so dass sie für Windows 8.0/8.1 bitte diesen Code verwenden und unter dem Namen Win8Key.ps1 im Ordner „PowerShellKeySkript“ abspeichern oder Win8Key.zip herunterladen.

Hinweis: Wer für Windows 8.0 über den Windows Store oder über Windows Update ein Upgrade auf Windows 8.1 durchgeführt hat, findet seinen „Productkey“ im Klartext in der Registry unter
„HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Win8“
als REG_SZ Wert.

Windows8.1-Verzeichnispfad

Verzeichnispfad und Dateiname

 

Function GetWinKey
{
$Hklm = 2147483650
$Target = $env:COMPUTERNAME
$RegPath = "Software\Microsoft\Windows NT\CurrentVersion"
$DigitalID = "DigitalProductId"
$Wmi = [WMIClass]"\\$Target\root\default:stdRegProv"
$Object = $Wmi.GetBinaryValue($Hklm,$RegPath,$DigitalID)
[Array]$DigitalIDvalue = $Object.uValue
$ProductName = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "ProductName").ProductName
$CurrentBuild = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "CurrentBuild").CurrentBuild
$CurrentVersion = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "CurrentVersion").CurrentVersion
$PROCESSOR_ARCHITECTURE = (Get-itemproperty -Path "HKLM:SYSTEM\CurrentControlSet\Control\Session Manager\Environment" -Name "PROCESSOR_ARCHITECTURE").PROCESSOR_ARCHITECTURE
$RegisteredOwner = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "RegisteredOwner").RegisteredOwner
$USERDOMAIN = (Get-itemproperty -Path "HKCU:Volatile Environment" -Name "USERDOMAIN").USERDOMAIN
$ProductID = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "ProductId").ProductId
$DigiID = ConvertTokey $DigitalIDvalue
$OSInfo = (Get-WmiObject "Win32_OperatingSystem" | Select Caption).Caption
$CSDVersion = ""
If($PROCESSOR_ARCHITECTURE -eq "x86")
{
$OsType = "32 Bit"
}
Elseif($PROCESSOR_ARCHITECTURE -eq "AMD64")
{
$OsType = "64 Bit"
}
If($CurrentVersion -eq 6.1)
{
$CSDVersion = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "CSDVersion").CSDVersion
}
[string]$Value = "Infos zum Betriebssystem: `r`n" `
+ "Windows-Edition       : $ProductName $OsType $CSDVersion `r`n" `
+ "Windows-Build-ID      : $CurrentBuild `r`n" `
+ "Windows-Versions-ID   : $CurrentVersion `r`n" `
+ "Prozessor-Architektur : $PROCESSOR_ARCHITECTURE `r`n" `
+ "Produkt-ID            : $ProductID `r`n" `
+ "Windows-ProduktKey    : $DigiID `r`n`r`n" `
+ "Registrierter Benutzer: $RegisteredOwner `r`n" `
+ "Computername          : $USERDOMAIN `r`n"
$Value
$Txtpath = "."
If($CurrentVersion -ge 6.2)
{
New-Item -Path $Txtpath -Name "Windows8_Key.txt" -Value $Value -ItemType File -Force | Out-Null
}
}

Function ConvertToKey($Key)
{
$Keyoffset = 52
$IsWin8 = [int]($Key[66]/6) -band 1
$HF7 = 0xF7
$Key[66] = ($Key[66] -band $HF7) -bOr (($IsWin8 -band 2) * 4)
$i = 24
[String]$Chars = "BCDFGHJKMPQRTVWXY2346789"
Do
{
$Cur = 0
$X = 14
Do
{
$Cur = $Cur * 256
$Cur = $Key[$X + $Keyoffset] + $Cur
$Key[$X + $Keyoffset] = [math]::Floor([double]($Cur/24))
$Cur = $Cur % 24
$X = $X – 1
}While($X -ge 0)
$i = $i- 1
$KeyOutput = $Chars.SubString($Cur,1) + $KeyOutput
$Last = $Cur
}While($i -ge 0)
$Keypart1 = $KeyOutput.SubString(1,$Last)
$Keypart2 = $KeyOutput.Substring(1,$KeyOutput.length-1)

If($Last -eq 0 )
{
$KeyOutput = "N" + $Keypart2
}
Else
{
$KeyOutput = $Keypart2.Insert($Keypart2.IndexOf($Keypart1)+$Keypart1.length,"N")
}

$KeyProduct = ""
For ($i = 0; $i -le 24; $i++) 
{
  $KeyProduct = $KeyProduct + $KeyOutput[$i] 
  If ((($i+1) % 5 -eq 0) -and ($i -ne 0) -and ($i -le 20) ) 
    {
     $KeyProduct = $KeyProduct + "-"
    }
}
$KeyProduct
}

$CurrentVersion = (Get-itemproperty -Path "HKLM:Software\Microsoft\Windows NT\CurrentVersion" -Name "CurrentVersion").CurrentVersion

If($CurrentVersion -le 6.1)
{
"Script läuft nur unter Microsoft Windows 8/8.1"
}
else {
GetWinKey
Write-host "`r`nAlle Angaben sind in der Datei .\Windows8_key.txt im gleichen Verzeichnis enthalten. `r`n" 
Write-host "`Beenden mit Tastendruck ..." 
$voidinput = $host.UI.RawUI.ReadKey("NoEcho, IncludeKeyDown")
}

Skript zum Auslesen des Keys ausführen

Wenn die Windows_Key.ps1 (Win7) im Ordner „PowerShellKeySkript“ unter C:\ liegt, geben Sie nun folgenden Befehl ein, ggf. müssen Sie sonst den Pfad ändern:

Import-Module "C:\PowerShellKeySkript\Windows_Key.ps1"; Get-WindowsKey

Dann drücken Sie die [Enter]-Taste.

Für Windows 8 lautet der Befehl dann

Import-Module "C:\PowerShellKeySkript\Win8Key.ps1"

Sie erhalten Informationen über die Windows-Edition, Windows-Version (Service Pack), Bit-Version, Build-Nummer, Lizenznehmer, Produkt-ID und Produktkey.

Windows8.1-PowerShell

Windows 8.1 Produktkey

10.PowerShell

Windows 7 Produktkey

Hängen Sie bei Windows 7 nach Get-WindowsKey noch den Parameter

Out-File "C:\PowerShellKeySkript\sn.txt"

an, wird eine Textdatei im Ordner „PowerShellKeySkript“ abgelegt.

Beispiel:

Import-Module "C:\PowerShellKeySkript\Windows_Key.ps1"; Get-WindowsKey Out-File "C:\PowerShellKeySkript\sn.txt"

Wenn Sie das Skript auf einem USB-Stick speichern, können Sie von jedem beliebigen PC den Produktkey auslesen. Auf dem Ziel-Computer muss natürlich Windows PowerShell vorhanden sein und Sie müssen zuerst die Sicherheitsrichtlinie lockern.

Tipp: Auf dieser Seite liefern deutsche PowerShell-Nutzer zahlreiche Tipps und zeigen Beispiele zur Nutzung von PowerShell mit Windows auf.

Das Skript Windows_Key.ps1 funktioniert unter Windows XP, Vista, Windows 7, etc.
Das Skript Win8Key.ps1 funktioniert nur unter Windows 8.0 und Windows 8.1.

Fazit

Eine gute Idee, wenn man das komplizierte, lange Skript besitzt. Die Shell-Befehle selbst sind ja einfach und verständlich.

Das Win8-Skript kann leider nicht den Key von einem vorinstallierten Windows 8, welches im BIOS/EFI den Key hinterlegt hat, auslesen.

Zum Tipparchiv: Produktkey von Windows 8 auslesen

Bildquelle: Microsoft

25 Antworten auf “Mit PowerShell den Windows-Produktkey auslesen”

  1. Mein Name

    Der Artikel ist für Windows 8/8.1 unbrauchbar, da die Funktion zum Auslesen des Produktkeys URALT ist und unter Windows 8 und 8.1 fehlerhafte Ergebnisse liefert.

  2. Michael

    Der Code von der com! ist schrott.
    Ich habe ein PS-Skript, das den Key von 7, 8 und 8.1 ausliest.

  3. Michael

    P.S.
    Beim Kopieren des Codes für die .cmd ist was schiefgelaufen. Hier nochmal der vollständige Code:

    @echo off
    cd /d %~dp0
    PowerShell -NoProfile -ExecutionPolicy Bypass -Command „“

  4. Michael

    Oh Mann, das funktioniert anscheinend nicht. Noch ein Versuch:

    @echo off
    cd /d %~dp0
    PowerShell -NoProfile -ExecutionPolicy Bypass -Command „“

  5. PCDPan_Fee

    Danach eine neue Textdatei öffnen und folgenden Code dort einfügen ... Diese Datei dann als .ps1 über “Speichern unter….” z.B. “GetWindowsKeys.ps1″ abspeichern.
    Dieser Code kann dann auch mit PowerShell mit dem Befehl z.B.: Import-Module „C:\xxx\GetWindowsKeys.ps1“; Get-WindowsKey
    geöffnet werden?

  6. Michael

    Hallo.
    Unter Windows 8(.1) startet man den Prozess durch Klick mit rechter Maustaste auf die Datei „GetWindowsKeys.ps1“ und wählt dann „Mit Powershell ausführen“.
    Unter Windows 7 muss man die .ps1-Datei zwingend über die .cmd (Als Administrator) ausführen, ansonsten funktioniert die Sache nicht.
    Man kann den Befehl aus der .cmd aber natürlich auch in der Powershell-Konsole eingeben.
    Ob die Sache auch mit dem „Import-Module“-Befehl funktioniert, weiß ich nicht, da ich es nicht ausprobiert habe.

    Ich habe die beiden Skripte, wie schon erwähnt, per E-Mail an die oben eingestellte E-Mail-Adresse geschickt.

  7. PCDPan_Fee

    Der Artikel wurde wegen Windows 8.0/8.1 Skript überarbeitet und der Download vom COM-Magazin entfernt, da fehlerhaft. Wir bedanken uns an BigWoelfi, der den Fehler entdeckt hat, an User Michael, der den Ansatz für das neue Windows 8-Skript lieferte und an User Mein Name, der das Windows 8-Skript weiter modifizierte und das fertige Skript für uns zur Verfügung stellte.

    Gruß PCDpan_fee

  8. Mein Name

    Hallo, Michael,

    dein geposteter Code funktioniert leider unter Window 7 nicht korrekt, er liefert einen verwurschtelten Key zurück. Die Windows-8-Version stammt aus deinem Script und wurde von mir modifiziert.

    Die Variable IsWin8 wurde zwar definiert, aber im weiteren Verlauf leider nicht verwendet, um für Window 7 den korrekten Code zu erzeugen. 😉

    Gruß
    M.N.

  9. Michael

    Hallo „Mein Name“,

    doch, der Code funktioniert für 7, 8 und 8.1.
    Allerdings muss man unter Windows 7 zwingend die .cmd ausführen, deren Code ich hier in diesen Kommentarbereich nicht einfügen kann.

    Es ist überhaupt nicht erforderlich, zwei unterschiedliche Codes für die unterschiedlichen Windows-Versionen, wie oben in dem Tutorial beschrieben, zu verwenden.

    Ich schicke die beiden Dateien, wie angemerkt, heute abend noch einmal an Wintotal.

  10. Mein Name

    Lieber MichaelB,

    auch wenn du noch 20 mal postest und deine Scripts verteilst, ob mit oder ohne (völlig überflüssiges) .cmd-File: Es wird nicht besser. Unter Windows 7 liefert dein Script falsche Ergebnisse, nimm es einfach zur Kenntnis.

    Im ersten Quintett fehlt das erste Zeichen, dafür ist das letzte zum 2. Quintett gehörig, und im 2. Quintett ist das erste Zeichen immer „N“.
    Eigentlich wollte ich ja nichts mehr dazu kommentieren, aber sowas Uneinsichtiges geht mir einfach auf den Senkel.

    M.N.
    Vielleicht hilft allen ja ein simples VB-Scripts, das ohne Klimmzüge in allen Windows-OS korrekte Ergebnisse liefert:
    Schnipp —->

    Set WshShell = CreateObject("WScript.Shell")
    strTemp = WshShell.ExpandEnvironmentStrings("%temp%")
    fName = strTemp & "\Windows Key.txt"
      
    
    Key = "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\"
    DigitalID = WshShell.RegRead(key & "DigitalProductId")
    
    ProductName = "Product Name: " & WshShell.RegRead(Key & "ProductName") & vbNewLine
    ProductID = "Product ID: " & WshShell.RegRead(Key & "ProductID") & vbNewLine
    ProductKey = "Installed Key: " & ConvertToKey(DigitalID)
    ProductID = ProductName & ProductID & ProductKey & vbNewLine
    
       
    If vbYes = MsgBox(ProductId & vblf & vblf & "In Datei " &  fname & " speichern?", vbYesNo + vbQuestion, "Windows Key Information") then
    Save ProductID, fname
    End if
    
    Function ConvertToKey(Key)
    Const KeyOffset = 52
    isWin8 = (Key(66) \ 6) And 1
    Key(66) = (Key(66) And &HF7) Or ((isWin8 And 2) * 4)
    i = 24
    Chars = "BCDFGHJKMPQRTVWXY2346789"
    Do
    Cur = 0
    X = 14
    Do
    Cur = Cur * 256
    Cur = Key(X + KeyOffset) + Cur
    Key(X + KeyOffset) = (Cur \ 24)
    Cur = Cur Mod 24
    X = X -1
    Loop While X >= 0
    i = i -1
    KeyOutput = Mid(Chars, Cur + 1, 1) & KeyOutput
    Last = Cur
    Loop While i >= 0
    If (isWin8 = 1) Then
    keypart1 = Mid(KeyOutput, 2, Last)
    insert = "N"
    KeyOutput = Replace(KeyOutput, keypart1, keypart1 & insert, 2, 1, 0)
    If Last = 0 Then KeyOutput = insert & KeyOutput
    End If
    a = Mid(KeyOutput, 1, 5)
    b = Mid(KeyOutput, 6, 5)
    c = Mid(KeyOutput, 11, 5)
    d = Mid(KeyOutput, 16, 5)
    e = Mid(KeyOutput, 21, 5)
    ConvertToKey = a & "-" & b & "-" & c & "-" & d & "-" & e
    End Function
    
    
    Function Save(Data, Fname)
    
    Set fso = CreateObject("Scripting.FileSystemObject")
    Set oFile = fso.OpenTextFile(fname,8,true)
    oFile.WriteLine Data
    oFile.close
    
    End Function
    

    <— Schnapp

  11. Michael

    Immer locker bleiben, Sportsfreund!

    Bei mir funktioniert das PS-Skript ohne Probleme und es wird sowohl unter Windows 7, als auch unter Windows 8(.1) alles korrekt ausgelesen.

    Ich fühle mich nicht berufen, anderen irgendetwas aufzuzwingen. Ich wollte nur helfen und habe es nicht nötig, mich dumm von der Seite anmachen zu lassen.

  12. PCDMicha

    MichaelB, Dein Script zeigt im ersten Block die ersten beiden Stellen auf allen Win7-Systemem hier falsch an.

  13. Michael

    1. Ist das nicht MEIN Script, sondern eine angepasste Version aus dem Internet.

    2. Wie im Forum schon angemerkt, funktioniert das Auslesen hier ohne jegliche Fehler. Bei mittlerweile fünf Nutzern, auf deren Systemen getestet wurde.

    Ist mir alles ein Rätsel.

    Aber ihr hier seid doch die Experten.
    Wenn das Skript bei euch, wie behauptet, tatsächlich nicht fehlerfrei auslesen sollte, dann passt es doch einfach an und korriegiert den oder die angeblichen Fehler.

  14. Mein Name

    @MichaelB

    Weil hier die Experten sind, funktionieren die jetzt veröffentlichten Scripts ja auch. Wozu also für andere nach Fehlern suchen? Such doch bitte selbst.

  15. Michael

    Wieso sollte ich nach nicht vorhandenen Fehlern suchen?
    Komische Logik.

    Ich habe das Skript jetzt sogar daingehend erweitert, dass damit jetzt auch die im BIOS/UEFI integrierten Keys, wie es bei vorinstallierten Win8(.1)-Betriebssystemen der Fall ist, ausgelesen werden.

    Und jetzt kommt’s:
    Es funktioniert!! Die Keys werden sogar vollständig und korrekt ausgegeben!!

    Das kann doch eigentlich gar nicht sein, oder?
    Naja, ich bin ja auch kein Experte.

  16. ArnoNym

    Hallo zusammen,

    Ich hab einn Laptop mit vorinstalliertem Windows 8.1, und hab es tatsächlich geschafft, das Paßwort zum Superuser-Account zu „verbaseln“. Ehe ich das Windows nun wegblase, und eventuell später mal wieder installiere, wollte ich mir vorsichtshalber den product key sicherstellen. Dafür habe ich das von „Mein Name“ am 27.02.2014 um 17:50 hier gepostete Skript in meinem Verzeichnis als Datei „ProductKeyAuslesen.VBS“ gespeichert, und mit beherztem Doppelklick ausgeführt. Die ermittelten Daten (Product Name, Product ID und Installed Key) hab ich am Ende des SKRIPTS in eine Datei schreiben lassen. Wenn ich mir diese Datei irgend wo ganz ganz sicher aufhebe (oder besser: ausdrucke und extra noch die Datei aufhebe), dann hätte ich vorher gerne noch gewußt, wie ich die Korrektheit dieser 3 Informationen prüfen kann. Dannach würde ich erst mal das Windows von der Platte putzen, und ein anderes Betriebssystem installieren. Ist das ein guter Plan, oder aus irgend einem Grund ganz schlecht?

    Vielen Dank für hilfreiche Kommentare,
    Arno

  17. PCDPan_Fee

    hi Arno,
    den Text unter Fazit (am Ende des Textes) hast du gelesen?
    Das Win8-Skript kann leider nicht den Key von einem vorinstallierten Windows 8, welches im BIOS/EFI den Key hinterlegt hat, auslesen.

    Lies dir bitte den >>Tipp< < durch, da stehen auch Tools drin, die den BIO-Key auslesen können. Gruß pan_fee

    Ich hab einn Laptop mit vorinstalliertem Windows 8.1

  18. Fred

    Ich habe mir das Script: Win8Key.ps1 hier heruntergeladen und auf meinem PC unter Windows 8.1 Pro gestartet.
    Grundsätzlich funktioniert das Script aber im Artikel ist ein Fehler.
    Im Artikel steht, dass der Befehl unter Windows 8/8.1 wie folgt lauten muss:
    Import-Module „C:\PowerShellKeySkript\Win8Key.ps1“; Get-WindowsKey
    Das ist so nicht korrekt, da im Script die Function als GetWinKey und nicht als Get-WindowsKey festgelegt wurde.

    Ich habe das Script: Win8Key.ps1 bei mir in das Verzeichnis D:\ kopiert,
    dann die Windows PowerShell als Administrator ausgeführt
    und in PowerShell auf D:\ gewechselt.
    Dann habe ich das Script aufgerufen.
    Die Datei: Windows8_Key.txt befindet sich dann im Ordner: D:\

    #########################

    Windows PowerShell
    Copyright (C) 2013 Microsoft Corporation. Alle Rechte vorbehalten.

    PS C:\WINDOWS\system32> d:
    PS D:\>
    PS D:\> set-executionpolicy remotesigned

    Ausführungsrichtlinie ändern
    Die Ausführungsrichtlinie trägt zum Schutz vor nicht vertrauenswürdigen Skripts bei. Wenn Sie die Ausführungsrichtlinie
    ändern, sind Sie möglicherweise den im Hilfethema „about_Execution_Policies“ unter
    „http://go.microsoft.com/fwlink/?LinkID=135170“ beschriebenen Sicherheitsrisiken ausgesetzt. Möchten Sie die
    Ausführungsrichtlinie ändern?
    [J] Ja [N] Nein [H] Anhalten [?] Hilfe (Standard ist „J“):
    PS D:\>
    PS D:\> Import-Module D:\Win8Key.ps1
    Infos zum Betriebssystem:
    Windows-Edition : Windows 8.1 Pro with Media Center 64 Bit
    Windows-Build-ID : 9600
    Windows-Versions-ID : 6.3
    Prozessor-Architektur : AMD64
    Produkt-ID : XXXXX-XXXXX-XXXXX-XXXXX
    Windows-ProduktKey : XXXXX-XXXXX-XXXXX-XXXXX-XXXXX

    Registrierter Benutzer: User
    Computername : PC1

    Alle Angaben sind in der Datei .\Windows8_key.txt im gleichen Verzeichnis enthalten.

    Beenden mit Tastendruck …
    PS D:\>
    PS D:\> getwinkey
    Infos zum Betriebssystem:
    Windows-Edition : Windows 8.1 Pro with Media Center 64 Bit
    Windows-Build-ID : 9600
    Windows-Versions-ID : 6.3
    Prozessor-Architektur : AMD64
    Produkt-ID : XXXXX-XXXXX-XXXXX-XXXXX
    Windows-ProduktKey : XXXXX-XXXXX-XXXXX-XXXXX-XXXXX

    Registrierter Benutzer: User
    Computername : PC1

    PS D:\>
    PS D:\>
    PS D:\> set-executionpolicy restricted

    Ausführungsrichtlinie ändern
    Die Ausführungsrichtlinie trägt zum Schutz vor nicht vertrauenswürdigen Skripts bei. Wenn Sie die Ausführungsrichtlinie
    ändern, sind Sie möglicherweise den im Hilfethema „about_Execution_Policies“ unter
    „http://go.microsoft.com/fwlink/?LinkID=135170“ beschriebenen Sicherheitsrisiken ausgesetzt. Möchten Sie die
    Ausführungsrichtlinie ändern?
    [J] Ja [N] Nein [H] Anhalten [?] Hilfe (Standard ist „J“):
    PS D:\>
    PS D:\>
    PS D:\> exit

  19. PCDPan_Fee

    hi Fred, die Funktion Get-WindowsKey sollte nicht in der Eingabezeile für Windows 8/8.1 angegeben werden, sondern nur in der für das Windows 7 Script, somit hast du Recht. Ich habe es im Artikel geändert. Neu ist; Nur ein Skript für 6 Betriebssysteme (XP, Vista, Win7, Win8.0, Win8.1, Win10) – das Skript heißt GetWinKey.ps1 und ist im Artikel oben unter NEU vermerkt.

  20. Unwichtig

    Hey,

    als mittelmäßig erfahrener PC-User stand ich bis gerade vor dem Problem, dass die oben beschriebenen Lösungsansätze nicht funktioniert haben. Als Key wurde mir immer BBBB-BBB-BBBB-BBBB ausgegeben.

    Nach meiner Recherche liegt das daran, dass in meiner Registry noch ein Verzeichnis zwischengeschaltet ist.

    DIe meisten Skripte gehen davon aus, dass der Key unter „Current Version“ in der Registry liegt. Bei mir ist aber noch der Ordner „DefaultProductKey“ angehängt. Dementsprechend muss das Skript modifiziert werden.

    Folgendes hat bei mir in PowerShelIISE funktioniert:

    $map=“BCDFGHJKMPQRTVWXY2346789″
    $value = (get-itemproperty „HKLM:\\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DefaultProductKey“).digitalproductid[0x34..0x42]
    $ProductKey = „“
    for ($i = 24; $i -ge 0; $i–) {
    $r = 0
    for ($j = 14; $j -ge 0; $j–) {
    $r = ($r * 256) -bxor $value[$j]
    $value[$j] = [math]::Floor([double]($r/24))
    $r = $r % 24
    }
    $ProductKey = $map[$r] + $ProductKey
    if (($i % 5) -eq 0 -and $i -ne 0) {
    $ProductKey = „-“ + $ProductKey
    }
    }
    echo „Product Key:“ $ProductKey

  21. Peter

    Das Beispiel zum Ablegen der Textdatei mit den ausgelesenen Informationen ist offenbar falsch und führt ggf. zu Scriptfehlern.
    Import-Module „C:\PowerShellKeySkript\Windows_Key.ps1“; Get-WindowsKey Out-File „C:\PowerShellKeySkript\sn.txt“

    Das sollte wie auf einer CMD üblich mit einem > („Ausgabe umleiten auf…“) geschrieben werden, dann funzt es auch ordentlich.
    Import-Module „C:\PowerShellKeySkript\Windows_Key.ps1“; Get-WindowsKey > „C:\PowerShellKeySkript\sn.txt“

Hinterlasse eine Antwort

(wird nicht veröffentlicht)

Nutzungsrichtlinien beachten