Top-Themen

AppleEntwicklungHardwareInternetLinuxMicrosoftMultimediaNetzwerkeOff TopicSicherheitSonstige SystemeVirtualisierungWeiterbildungZusammenarbeit

Aktuelle Themen

Administrator.de FeedbackApache ServerAppleAssemblerAudioAusbildungAuslandBackupBasicBatch & ShellBenchmarksBibliotheken & ToolkitsBlogsCloud-DiensteClusterCMSCPU, RAM, MainboardsCSSC und C++DatenbankenDatenschutzDebianDigitiales FernsehenDNSDrucker und ScannerDSL, VDSLE-BooksE-BusinessE-MailEntwicklungErkennung und -AbwehrExchange ServerFestplatten, SSD, RaidFirewallFlatratesGoogle AndroidGrafikGrafikkarten & MonitoreGroupwareHardwareHosting & HousingHTMLHumor (lol)Hyper-VIconsIDE & EditorenInformationsdiensteInstallationInstant MessagingInternetInternet DomäneniOSISDN & AnaloganschlüsseiTunesJavaJavaScriptKiXtartKVMLAN, WAN, WirelessLinuxLinux DesktopLinux NetzwerkLinux ToolsLinux UserverwaltungLizenzierungMac OS XMicrosoftMicrosoft OfficeMikroTik RouterOSMonitoringMultimediaMultimedia & ZubehörNetzwerkeNetzwerkgrundlagenNetzwerkmanagementNetzwerkprotokolleNotebook & ZubehörNovell NetwareOff TopicOpenOffice, LibreOfficeOutlook & MailPapierkorbPascal und DelphiPeripheriegerätePerlPHPPythonRechtliche FragenRedHat, CentOS, FedoraRouter & RoutingSambaSAN, NAS, DASSchriftartenSchulung & TrainingSEOServerServer-HardwareSicherheitSicherheits-ToolsSicherheitsgrundlagenSolarisSonstige SystemeSoziale NetzwerkeSpeicherkartenStudentenjobs & PraktikumSuche ProjektpartnerSuseSwitche und HubsTipps & TricksTK-Netze & GeräteUbuntuUMTS, EDGE & GPRSUtilitiesVB for ApplicationsVerschlüsselung & ZertifikateVideo & StreamingViren und TrojanerVirtualisierungVisual StudioVmwareVoice over IPWebbrowserWebentwicklungWeiterbildungWindows 7Windows 8Windows 10Windows InstallationWindows MobileWindows NetzwerkWindows ServerWindows SystemdateienWindows ToolsWindows UpdateWindows UserverwaltungWindows VistaWindows XPXenserverXMLZusammenarbeit
GELÖST

Base24 Algorithmus decodieren mit Batch?

Frage Entwicklung Batch & Shell

Mitglied: sinsizer

sinsizer (Level 1) - Jetzt verbinden

05.01.2012, aktualisiert 10:05 Uhr, 4896 Aufrufe, 15 Kommentare

Hallo,

wie der Titel schon sagt habe ich ein Verständnissproblem mit dem Base24 Algorithmus.
Ziel ist es, mit reinem Batch, den Microsoft Product Key zu decodieren.

Es gibt schon genügend Programme die das machen und auch Codes in Powershell und VBScript.

Hier mal ein Beispiel in VBScript:

01.
  
02.
Set WshShell = CreateObject("WScript.Shell") 
03.
msgbox ConvertToKey(WshShell.RegRead("HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DigitalProductId")), 64, "Windows Product Key" 
04.
  
05.
Function ConvertToKey(Key) 
06.
    Const KeyOffset = 52 
07.
    i = 28 
08.
    Chars = "BCDFGHJKMPQRTVWXY2346789" 
09.
    Do 
10.
        Cur = 0 
11.
        x = 14 
12.
        Do 
13.
            Cur = Cur * 256 
14.
            Cur = Key(x + KeyOffset) + Cur 
15.
            Key(x + KeyOffset) = (Cur \ 24) And 255 
16.
            Cur = Cur Mod 24 
17.
            x = x -1 
18.
        Loop While x >= 0 
19.
        i = i -1 
20.
        KeyOutput = Mid(Chars, Cur + 1, 1) & KeyOutput 
21.
        If (((29 - i) Mod 6) = 0) And (i <> -1) Then 
22.
            i = i -1 
23.
            KeyOutput = "-" & KeyOutput 
24.
        End If 
25.
    Loop While i >= 0 
26.
    ConvertToKey = KeyOutput 
27.
End Function
Leider verstehe ich die Funktion nicht und würde mich freuen wenn mir die jemand etwas genauer erklären könnte.
Kenne mich mit VBScript noch nicht aus. (Kämpfe noch mit Batch )

Auf Wunsch kann ich noch ein alternatives VBScript und ein Powershell Script posten wenn das weiter hilft.

So siehts in Batch bis jetzt aus um den Key aus der Registry zu lesen :

01.
for /f "tokens=3 delims= " %%a in ('reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v DigitalProductId') do set keyhex=%%a 
02.
set keyhex=%keyhex:~104,30%
Danke
Mitglied: pieh-ejdsch
05.01.2012 um 10:44 Uhr
moin sinsizer,

meiner Ansicht nach hat es gar keinen Sinn den Algorithmus aus einer VBS 1:1 in eine Batch zu übertragen.

Das auslesen des Keys erfolgt ja auf eine Art wie es in "Base24" (wobei die 24 nur die Anzahl der zu verwendeten Zeichen beschreibt) gemacht wird. In den Dokumentationen über "Base16"; "Base 32"; "Base 32hex" oder "Base 64" etc. wird die genaue Vorgehensweise beschrieben.
Rechnen in Batch ist auch schon etwas anders als in VBS.
Auf jeden Fall musst Du erst den Base... Algorithmus kennen um den Batch entwerfen zu können.

Gruß Phil
Bitte warten ..
Mitglied: sinsizer
05.01.2012 um 11:52 Uhr
Also kann ich, nach verstandenem Base16 oder/und Base32, das Wissen auf Base 24 übertragen? Oder findet dort noch irgendetwas anderes statt?
Aufgrund meiner fehlenden VBS Kenntnisse hab ich Probleme die Funktion zu verstehen.
Die Rechnung wird in Batch bestimmt etwas anders aussehen. Dort stehen aber auch Bitweise Operatoren und Modulo zur Verfügung.

Es ist wohl Sinnvoll wenn ich mich nach Batch mal mit VBS beschäftige.
Bitte warten ..
Mitglied: rubberman
05.01.2012 um 23:14 Uhr
Hallo zusammen.

Ich habe mich zwar nie mit einem Base24 Algorithmus oder Ähnlichem beschäftig, die "Übersetzung" nach Batch ist aber relativ simpel. Vielleicht hilft es beim Verständnis.

01.
@echo off &setlocal 
02.
if "%~1"==":doWhile" call :doWhile 
03.
 
04.
setlocal EnableDelayedExpansion 
05.
:: HEX String lesen 
06.
for /f "tokens=3" %%i in ('reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v "DigitalProductId"') do set "hex=%%i" 
07.
 
08.
:: Länge des HEX Strings 
09.
set "str=A%hex%" 
10.
set "len=0" 
11.
for /l %%i in (12,-1,0) do ( 
12.
    set /a "len |= 1 << %%i" 
13.
    for %%j in (!len!) do if "!str:~%%j,1!"=="" set /a "len &= ~1 << %%i" 
14.
15.
 
16.
:: Pseudo-Array anlegen 
17.
set /a "len -= 2" 
18.
for /l %%i in (0,2,%len%) do ( 
19.
  set /a "n = %%i / 2" 
20.
  set /a "Key_!n! = 0x!hex:~%%i,2!" 
21.
22.
 
23.
:: Do While simulieren 
24.
for /f %%K in ('cmd /c "%~f0" :doWhile') do (endlocal &set "WinProdKey=%%K") 
25.
 
26.
echo Windows Product Key: %WinProdKey% 
27.
echo( 
28.
pause 
29.
goto :eof 
30.
 
31.
:doWhile 
32.
setlocal EnableDelayedExpansion 
33.
set "KeyOffset=52" 
34.
set "Chars=BCDFGHJKMPQRTVWXY2346789" 
35.
set "i=28" 
36.
for /l %%# in (0) do ( 
37.
  set "Cur=0" 
38.
  for /l %%x in (14,-1,0) do ( 
39.
    set /a "Cur *= 256 , el = KeyOffset + %%x" 
40.
    for %%j in (!el!) do ( 
41.
      set /a "Cur = !Key_%%j! + Cur , Key_%%j = (Cur / 24) & 255 , Cur %%= 24" 
42.
43.
44.
  set /a "i -= 1 , z = (29 - i) %% 6" 
45.
  for %%j in (!Cur!) do set "KeyOutput=!Chars:~%%j,1!!KeyOutput!" 
46.
  if !z!==0 if !i! neq -1 ( 
47.
    set /a "i -= 1" 
48.
    set "KeyOutput=-!KeyOutput!" 
49.
50.
  if !i! lss 0 (echo !KeyOutput!&exit) 
51.
)
Grüße
rubberman
Bitte warten ..
Mitglied: sinsizer
06.01.2012 um 10:45 Uhr
Super! Vielen Dank für die Übersetztung.

Auf dem Papier teile ich den Wert durch die gewünschte Basis, also 24, und erhalte einen Rest. Der Rest gibt den Wert im neuen Zahlensystem an.
Das Ergebniss teile ich solang bis der Rest 0 ist. So erhält man zum Schluss das Ergebniss mit neuer Basis.
(Wenn ich das richtig verstanden hab )

Leider blick ich bei der Schleife trotzdem noch nicht ganz durch.

for /l %%# in (0) do (
unendliche Schleife bis exit ausgelöst wird
set "Cur=0"
aktuelle Position vielleicht ????
for /l %%x in (14,-1,0) do (
Schleife um die 15 Byte einzeln zu durchlaufen
set /a "Cur *= 256 , el = KeyOffset + %%x"
?????? 0*256 ??????, el = Position des entsprechenden Byte
for %%j in (!el!) do (
Schleife für einzel Byte umrechnung
set /a "Cur = !Key_%%j! + Cur , Key_%%j = (Cur / 24) & 255 , Cur %%= 24"
???????? "Key_%%j" ist 1 Byte in hex an Pos. %el% aber warum + Cur
cur ist doch 0 und 0*256 ist immer noch 0? Wozu das Bitweise und?

Hier steig ich aus, und versteh den Rest leider nicht mehr.

Wäre nett wenn mir den restlichen Code noch jemand erklären könnte.

Mit freundlichen Grüßen sinsizer
Bitte warten ..
Mitglied: 76109
06.01.2012 um 16:57 Uhr
Hallo @All!

Der Vollständigkeit halber noch eine etwas vereinfachte VBS-Version:
01.
Const sKeyChar = "BCDFGHJKMPQRTVWXY2346789" 
02.
Const sRegKey = "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\DigitalProductId" 
03.
 
04.
MsgBox GetProductKey(CreateObject("WScript.Shell").RegRead(sRegKey)), 64, "Windows Product Key" 
05.
 
06.
Function GetProductKey(ByRef aRegValue) 
07.
    Dim sProductKey, b, c, i 
08.
     
09.
    For b = 24 To 0 Step -1 
10.
        c = 0 
11.
        For i = 66 To 52 Step -1 
12.
            c = c * 256 + aRegValue(i) 
13.
            aRegValue(i) = CByte(c \ 24) 
14.
            c = c Mod 24 
15.
        Next 
16.
         
17.
        sProductKey = Mid(sKeyChar, c + 1, 1) & sProductKey 
18.
         
19.
        If b And b Mod 5 = 0 Then sProductKey = "-" & sProductKey 
20.
    Next 
21.
     
22.
    GetProductKey = sProductKey 
23.
End Function
Gruß Dieter

[edit] Codezeile 12 geändert (XOR durch + ersetzt) [/edit]
Bitte warten ..
Mitglied: rubberman
06.01.2012 um 20:48 Uhr
Hallo Zusammen.

@Dieter,
nachdem ich vorher nur stupide VBS zu Batch konvertiert habe, ist mir die Funktionsweise dank deines Scripts nun auch klar.

@sinsizer,
Cur (bzw. c) bezeichnet die Position des Zeichens im String BCDFGHJKMPQRTVWXY2346789. Der Wert der Variablen startet zwar mit 0, wird aber sofort in der inneren Schleife neu berechnet.

Dieters VBS 2 Batch:
01.
@echo off &setlocal 
02.
call :GetProductKey sWinProdKey 
03.
echo Windows Product Key: %sWinProdKey% 
04.
echo( 
05.
pause 
06.
goto :eof 
07.
 
08.
:GetProductKey outVarName 
09.
setlocal EnableDelayedExpansion 
10.
set "sKeyChar=BCDFGHJKMPQRTVWXY2346789" 
11.
set "sRegKey=HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" 
12.
set "sRegVal=DigitalProductId" 
13.
 
14.
for /f "tokens=3" %%i in ('reg query "%sRegKey%" /v "%sRegVal%"') do set "sHex=%%i" 
15.
 
16.
set /a "n = 52" 
17.
for /l %%i in (104,2,132) do set /a "aRegValue_!n! = 0x!sHex:~%%i,2! , n += 1" 
18.
 
19.
for /l %%b in (24,-1,0) do ( 
20.
  set /a "c = 0 , n = %%b %% 5" 
21.
  for /l %%i in (66,-1,52) do set /a "c = c * 256 ^^ !aRegValue_%%i! , aRegValue_%%i = c / 24 , c %%= 24" 
22.
  for %%j in (!c!) do set "sProductKey=!sKeyChar:~%%j,1!!sProductKey!" 
23.
  if %%b neq 0 if !n!==0 set "sProductKey=-!sProductKey!" 
24.
25.
endlocal &set "%~1=%sProductKey%" &goto :eof
Grüße
rubberman
Bitte warten ..
Mitglied: sinsizer
07.01.2012 um 08:49 Uhr
Hallo,

tut mir wirklich leid das ich so schwer von Begriff bin, aber könnte mir jemand erklären was hier mathematisch passiert?

for /l %%i in (66,-1,52) do set /a "c = c * 256 ^^ !aRegValue_%%i! , aRegValue_%%i = c / 24 , c %%= 24"

Werde es mal als gelöst markieren. Sind ja nun schon mehrere Übersetzungen vorhanden.

Vielen Dank an alle.

Mit freundlichen Grüßen sinsizer
Bitte warten ..
Mitglied: 76109
07.01.2012 um 12:04 Uhr
Hallo sinsizer!

Na dann, versuche ich es mal zu erklären
For b = 24 To 0 Step -1
Schleife entsprechend der Anzahl Charakter im Produkt-Key (25-Zeichen)

c = 0
Position im String "BCDFGHJKMPQRTVWXY2346789" pro Produkt-Key-Zeichen auf 0 setzen

For i = 66 To 52 Step -1
Schleife entsprechend der Positonen von den auszulesenden 15 Byte-Werten aus dem Reg-Byte-Array (164 Byte)

c = c * 256 + aRegValue(i)
aRegValue(i) = CByte(c \ 24)
c = c Mod 24
for /l %%i in (66,-1,52) do set /a "c = c * 256 ^^ !aRegValue_%%i! , aRegValue_%%i = c / 24 , c %%= 24"
Den aktuellen Wert in c (c * 256) auf ein WORD (16-Bit) erweitern sprich in's High-Byte (Bit 8-15) schieben + Low-Byte (Bit 0-7) aus dem Reg-Byte-Array

Beispiel:
Position (i) = 66 und c enthält den Startwert 0:
c = 0 und Wert im Reg-Byte-Array an Position 66 = 5:
c = 0 * 256 (0000 hex) + 5 ergibt 5 (0005 hex)
aRegValue(66) = Ganzahl 5 / 24 (aRegValue(i) = CByte(c \ 24)) ergibt 0 (00 hex)

Position (i) = 65 und c enthält aktuell von Position 66 den Restwert aus 5 / 24 (c = c Mod 24):
c = 5 und Wert im Reg-Byte-Array an Position 65 = 60:
c = 5 * 256 (0500hex) + 60 (003C hex) ergibt 1340 (053C hex)
aRegValue(65) = Ganzahl 1340 / 24 (aRegValue(i) = CByte(c \ 24)) ergibt 55 (37 hex)

Position (i) = 64 und c enthält aktuell von Position 65 den Restwert aus 20 / 24 (c = c Mod 24):
c = 20 und Wert im Reg-Byte-Array an Position 64 = 147:
c = 20 * 256 (1400hex) + 147 (0093 hex) ergibt 5267 (1493 hex)
aRegValue(64) = Ganzahl 5267 / 24 (aRegValue(i) = CByte(c \ 24)) ergibt 219 (DB hex)
...........

Hoffe, ich hab's einigermaßen verständlich erklärt?

@rubberman
@Dieter,
nachdem ich vorher nur stupide VBS zu Batch konvertiert habe, ist mir die Funktionsweise dank deines Scripts nun auch klar.
Freut mich zu hören und der Erfolg läßt sich nun ja auch an der Kürze des neuen Batch-Scripts erkennen

Gruß Dieter

PS. Codezeile 12 geändert:
c = c * 256 + aRegValue(i)
XOR durch (+) ersetzt
Bitte warten ..
Mitglied: sinsizer
07.01.2012 um 21:41 Uhr
Danke für die ausführliche Erklärung. Jetzt hat es "KLICK!" gemacht.

Muss mich nur noch mit der High-Byte, Low-Byte Sache, dem Erweitern von BYTE auf WORD mit *256(evtl. auch DWORD *4096? usw.) und dem Unterschied von XOR und + in der Funktion auseinandersetzten.
Als nächstes bastel ich dann eine eigene kleine Ver- und Entschlüsselungs-Batch mit individueller Basis und Zeichensatz.

Mit freundlichen Grüßen sinsizer
Bitte warten ..
Mitglied: rubberman
07.01.2012 um 23:53 Uhr
Hallo sinsizer.

Vielleicht wird es einfacher, wenn du dir die binären Entsprechungen ansiehst.
Ein Byte hat eine Breite von 8 Bit. Das WORD hat eine Breite von 2 Byte = 16 Bit. Das linke Byte wird High-Byte genannt, das rechte Low-Byte.

Nehmen wir noch einmal das Beispiel von Dieter:
c = 5 * 256 (0500hex) + 60 (003C hex) ergibt 1340 (053C hex)
          High-Byte Low-Byte 
5         00000000  00000101 
* 256     00000101  00000000 
+ 60      00000101  00111100
Statt der Multiplikation mit 256 könntest du auch ein Left-Shift um 8 Bit anwenden:
5         00000000  00000101 
<< 8      00000101  00000000
Was nun den Unterschied zwischen Addition und XOR ausmacht ist einfach erklärt: Es sind 2 völlig unterschiedliche Operationen, die allerdings in diesem Fall exakt das gleiche Ergebnis liefern.
Die Addition muss ich sicher nicht erklären. Zum XOR:
0 XOR 0 = 0 
1 XOR 0 = 1 
0 XOR 1 = 1 
1 XOR 1 = 0
Da alle Bits des Low-Bytes nach der Multiplikation mit 256 den Wert 0 haben, ist klar dass die Bits nach der XOR Operation nur dann den Wert 1 haben, wenn der 2. Operand an dieser Stelle 1 ist.

Grüße
rubberman
Bitte warten ..
Mitglied: sinsizer
08.01.2012 um 00:22 Uhr
Hier kann man ja noch richtig was lernen.

Soweit hab ich glaub ich alles verstanden. Ohne die Verschiebung ins High-Byte wäre die Rechnung nicht möglich, da der Wert für eine Breite von 1 Byte zu groß wird.
Da 255 (dec) der größte wert für 1 Byte also 1111 1111 ist wird bei 256 auf WORD verschoben 0000 0001 0000 0000.
Das heißt um so größer der umzurechnende Wert, um so weiter bzw. öfter muss man verschieben?

Edit: Muss man Byteweise umrechnen, oder ginge das auch in einem "Rutsch"?

An dieser Stelle nochmal ein herzliches Dankeschön, an rubberman und Dieter, für die tollen Ausführungen und Erklärungen.
Bitte warten ..
Mitglied: 76109
08.01.2012 um 00:26 Uhr
Hallo rubberman!

Das hast Du sehr schön erklärt


Gruß Dieter
Bitte warten ..
Mitglied: rubberman
08.01.2012 um 00:35 Uhr
Hallo sinsizer,

kommt darauf an was du damit vorhast. Die Breite von 16 Bit wird zur Dekodierung gebraucht. Das heist, dieser Algorithmus verlangt es so. Wenn du ein Array Byte für Byte abarbeitest, reicht die Breite von 2 Byte in diesem Fall. Kreierst du deinen eigenen Kodierungs-/Dekodierungsalgorithmus, kann das anders sein.
Deine Frage lässt sich also nicht so einfach mit Ja oder Nein beantworten.

Grüße
rubberman

<EDIT: @Dieter - Danke für die Blumen />
Bitte warten ..
Mitglied: rubberman
08.01.2012 um 01:02 Uhr
Was dein Edit anbetrifft:
Dieser Algorithmus verlangt eine byteweise Abarbeitung. Davon abgesehen ist sie sinnvoll. Mit einer Breite von 4 Byte wärst du bereits an der Grenze angelangt, die die Kommandozeile noch als Zahl interpretieren kann.

Grüße
rubberman
Bitte warten ..
Mitglied: 76109
08.01.2012 um 11:30 Uhr
Hallo sinsizer!

Dieser Algorithmus verlangt eine byteweise Abarbeitung. Davon abgesehen ist sie sinnvoll. Mit einer Breite von 4 Byte
wärst du bereits an der Grenze angelangt, die die Kommandozeile noch als Zahl interpretieren kann.
Mal davon abgesehen, werden die Bytes im RegValue-Array für jeden Buchstaben neu geschrieben, also 25 mal alle 15 Bytes verändert

Ergänzend noch die Grenzwerte der Bases für die Byte-Decodierung:
Base Formel Binär Dez Hex Anzahl Bits
16 15 * 256 + 255 0000 1111 1111 1111 4095 0FFF 12
24 23 * 256 + 255 0001 0111 1111 1111 6143 17FF 13
32 31 * 256 + 255 0001 1111 1111 1111 8191 1FFF 13
64 63 * 256 + 255 0011 1111 1111 1111 16383 3FFF 14
128 127 * 256 + 255 0111 1111 1111 1111 32767 7FFF 15


Gruß Dieter
Bitte warten ..
Neuester Wissensbeitrag
Humor (lol)

Linkliste für Adventskalender

(3)

Information von nikoatit zum Thema Humor (lol) ...

Ähnliche Inhalte
Batch & Shell
gelöst Wlan-adapter such algorithmus in batch (7)

Frage von TicoWrite zum Thema Batch & Shell ...

Batch & Shell
Dateinamen nach Zeichnen abschneiden - Batch-Shell (9)

Frage von cberndt zum Thema Batch & Shell ...

Batch & Shell
CMD Verschlüsslung ( Batch ) (9)

Frage von clragon zum Thema Batch & Shell ...

Batch & Shell
gelöst älteste dateien via batch löschen (6)

Frage von cali169 zum Thema Batch & Shell ...

Heiß diskutierte Inhalte
Router & Routing
gelöst Ipv4 mieten (22)

Frage von homermg zum Thema Router & Routing ...

Windows Server
DHCP Server switchen (20)

Frage von M.Marz zum Thema Windows Server ...

Exchange Server
gelöst Exchange 2010 Berechtigungen wiederherstellen (20)

Frage von semperf1delis zum Thema Exchange Server ...

Hardware
gelöst Negative Erfahrungen LAN-Karten (19)

Frage von MegaGiga zum Thema Hardware ...