17.11.2012, aktualisiert am 22.11.2012

14022

Hex in Dez umwandeln innerhalb einer Batchdatei, SAFER HASH-Regeln erstellen

Hallo,

kann mir einer sagen wie ich innerhalb einer Batchdatei ein in einer Variablen stehender Dezimal Wert von >DEZ in HEX< umwandeln kann?

Bitte markiere auch die Kommentare, die zur Lösung des Beitrags beigetragen haben

Content-ID: 194418

Url: https://administrator.de/forum/hex-in-dez-umwandeln-innerhalb-einer-batchdatei-safer-hash-regeln-erstellen-194418.html

Ausgedruckt am: 22.12.2024 um 13:12 Uhr

50 Kommentare

Neuester Kommentar

Hallo speedy26gonzales!

Damit Du nicht selbst (nach "dec to hex batch") suchen musst: http://www.dostips.com/DtTipsArithmetic.php

Grüße
bastla

Hallo speedy26gonzales und bastla.

Wie immer - viele Wege führen nach Rom.

@echo off &setlocal
set /a num = 123

cmd /c exit /b %num%
for /f "tokens=* delims=0" %%i in ("%=ExitCode%") do set "hex=%%i"  

echo %hex%
pause

Grüße
rubberman

Hallo rubberman!

Sehr hybsch ...

Wie bist Du auf

"%=ExitCode%"

gekommen?

Grüße
bastla

[OT]
Hallo bastla.

Hab ich gelegentlich gelesen (vieles von @jeb-the-batcher, auch in anderen Foren). Variablen beginnend mit = sind CMD-intern. Du hast keine Chance sie per SET Befehl zu ändern und im Normalfall siehst du sie auch nicht. Mittels SET; machst sie letztlich aber doch sichtbar.

@echo off &setlocal
cd /d C:\Windows
cd /d D:\
cmd /c exit /b 65
set; | findstr /b "="  

=::=::\
=C:=C:\Windows
=D:=D:\
=ExitCode=00000041
=ExitCodeAscii=A

Was in der ersten Zeile erscheint, habe ich noch nicht herausgefunden.
Auf LW C: war ich zuletzt auf C:\Windows, Auf LW D: zuletzt im Root.
Nun kommt der "Errorlevel" als HEX Wert, dann als ASCII Zeichen (sofern er sich als druckbares Standard-ASCII Zeichen darstellen lässt).

Grüße
rubberman
[/OT]

Hi,

ich wunderte mich dass ich keine Antwort bekam und hab jetzt bemerkt dass die Mails mal wieder im SPAM landeten

Ich hab jetzt durch die weitere Suche hier mal was zusammengebastelt:

REM DEZ in HEX Umrechnung
set "Z10=A" & set "Z11=B" & set "Z12=C" & set "Z13=D" & set "Z14=E" & set "Z15=F"  

set /a Dez = %FILESIZE%
set /a Rest=Dez
set "Hex="  

:LoopDezHex
if %Rest%==0 goto :MAKEREG
set /a Ziffer=Rest%%16
if %Ziffer% gtr 9 call set "Ziffer=%%Z%Ziffer%%%"  
set "Hex=%Ziffer%%Hex%"  
set /a Rest=Rest/16
goto :LoopDezHex

Funktioniert soweit auch, bin allerdings gleich auf das nächste Problem gestoßen. Ich brauche den Wert um einen Registrywert vom Typ: REG_QWORD zu schreiben. Jetzt frag ich mich, wie ich denn diese Formatierung hinbekomme. Mit "reg add" kann ich ja einen Schlüssel erstellen aber der schreibt ihn ja direkt in die Registry.

Als Hintergrund: Mein Script soll bestimmte Verzeichnisse (die später eingestellt werden sollen) nach bestimmten Dateiendungen (später auch einstellbar) suchen und daraus sogenannte "SAFER - REGELN" erstellen und dann in die Registry schreiben. So sieht mein Programm derzeit aus:

REM Programm durchsucht das komplette Laufwerk nach *.EXE Dateien
@ECHO OFF
REM Skript wird in UniCode geschrieben
ECHO Windows Registry Editor Version 5.00 > "safer.reg"  
ECHO. >> "safer.reg"  
REM Durchsucht das angegebene Laufwerk nach *.Exe Dateien und bei jeder gefundenen Datei ruft er das Unterprogramm auf
FOR /R "%SystemDrive%" %%I IN ("*.exe") DO CALL :MAKERULE "%%I"   
CALL :CLEAN
EXIT /B

:MAKERULE
REM Schreibe Pfadname
SET FILEPATH=%~1
SET FILESIZE=%~z1
SET FILENAME=%~n1
REM Erstelle eine GUID
cscript.exe //NoLogo uuid.vbs > "GUID.txt"  
SET /P GUID=<GUID.txt
REM Erstelle einen sha1 - HASH
fciv.exe -add "%~1" -sha1 > "HASH.txt"  
FOR /F "skip=3 eol=; tokens=1 usebackq delims= " %%a IN ("HASH.txt") DO (SET HASH=%%a)  

REM DEZ in HEX Umrechnung
set "Z10=A" & set "Z11=B" & set "Z12=C" & set "Z13=D" & set "Z14=E" & set "Z15=F"  

set /a Dez = %FILESIZE%
set /a Rest=Dez
set "Hex="  

:LoopDezHex
if %Rest%==0 goto :MAKEREG
set /a Ziffer=Rest%%16
if %Ziffer% gtr 9 call set "Ziffer=%%Z%Ziffer%%%"  
set "Hex=%Ziffer%%Hex%"  
set /a Rest=Rest/16
goto :LoopDezHex

REM echo Hexadezimal: %Hex%

REM CALL :MAKEREG
REM GOTO :EOF

:MAKEREG
ECHO. >> "safer.reg"  
ECHO [HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Safer\CodeIdentifiers\262144\Hashes\%GUID%] >> "safer.reg"  
REM TODO: Auslesen der letzten Dateiaenderung und anpassen des Formats (xx,xx,xx,xx...)
ECHO >> "safer.reg" "LastModified"=hex(b):   
REM TODO: Anpassung der Beschreibung
ECHO >> "safer.reg" "Description"="%FILEPATH%"   
REM TODO: Bessere Benennung des FriendlyName
ECHO >> "safer.reg" "FriendlyName"="%FILENAME%"   
REM Zu "SaferFlags" existiert keine Doku, Wert immer 0  
ECHO >> "safer.reg" "SaferFlags"=dword:00000000   
REM TODO: Umrechnung von dezimal in hex und konvertierung in REG_QWORD
ECHO >> "safer.reg" "ItemSize"=hex(b):%Hex%   
REM Aufsplitten des Hashs in Zweiergruppen
ECHO >> "sha1.txt" "ItemData"=hex:%HASH%   
ECHO >> "safer.reg" "ItemData"=hex:%HASH:~0,2%,%HASH:~2,2%,%HASH:~4,2%,%HASH:~6,2%,%HASH:~8,2%,%HASH:~10,2%,%HASH:~12,2%,%HASH:~14,2%,%HASH:~16,2%,%HASH:~18,2%,%HASH:~20,2%,%HASH:~22,2%,%HASH:~24,2%,%HASH:~26,2%,%HASH:~28,2%,%HASH:~30,2%,%HASH:~32,2%,%HASH:~34,2%,%HASH:~36,2%,%HASH:~38,2%  
REM Hash Algorithmus wird auf SHA1 gesetzt: 0x8003 (32771) = MD5, 0x8004 (32772) = SHA1
ECHO >> "safer.reg" "HashAlg"=dword:00008004   
ECHO. >> "safer.reg"  
GOTO :EOF

:CLEAN
del GUID.txt
del HASH.txt
GOTO :EOF

Vielleicht könnt Ihr mir hier auch etwas weiterhelfen bei meinen noch offenen Punkten?

Hallo speedy26gonzales.

Ein REG_QWORD ist letztlich ein 64 Bit breiter Ganzahlwert. Mit einem Hex-String kommst du für REG ADD und Batch schon mal um einiges weiter. Testen kannst du ja in einem dafür angelegten Key, den du anschließend wieder löscht.
Beispiel:

set "strHex=FFFFFFFFFFFFFFFF"  
reg add "HKCU\test" /v "test_value" /t REG_QWORD /d "0x%strHex%" /f  

In strHex findet sich dein Hex String (im Beispiel der für den größtmöglichen Wert). Für REG ADD musst du noch ein 0x davor setzen.

Grüße
rubberman

Ich hab das mit dem "reg add" heute schon mal angeschaut. Allerdings ist es doch so, dass dieser Befehl direkt in die Registry schreibt. Ich aber in meinem Skript erstmal alles in eine eigene *.reg Datei schreiben lasse und dann wenn alle Dateien gescannt wurden in die Registry übertrage.

Ander wie über "reg add" geht es nicht über ne Batch?
Und wie kann ich die Ausgabe in meine Datei umleiten?

Hallo speedy26gonzales.

Ein kurzer Test macht das klar.
Wenn du einen REG_QWORD Wert exportierst, siehst du wie es aussehen muss.

"test_value"=hex(b):ef,cd,ab,90,67,56,34,12

Hier wird der Wert 0x1234567890ABCDEF repräsentiert. Das niedrigste Byte steht also am Anfang. Es sind immer alle 8 Bytes anzugeben
Für deinen Batch bedeutet das, du musst den Hex String ggf. mit vorangestellten Nullen auf 16 Stellen erweitern und ihn dann in Zweiersteps von hinten nach vorn in der Ausgabe arrangieren.

Beispiel:

set "strHex=A1B2AF"  

set "strHex=0000000000000000%strHex%"  
set "strHex=%strHex:~-16%"  

>>"test.reg" echo "test_value"=hex(b):%strHex:~-2%,%strHex:~-4,2%,%strHex:~-6,2%,%strHex:~-8,2%,%strHex:~-10,2%,%strHex:~-12,2%,%strHex:~-14,2%,%strHex:~,2%  

Grüße
rubberman

Zitat von @rubberman:

> set "strHex=A1B2AF" -> Hier wird ein Hexwert gesetzt  
> 
> set "strHex=0000000000000000%strHex%" -> Hier wird mit 16 Nullen aufgefüllt und daran der Hexwert von oben gehängt.  
> set "strHex=%strHex:~-16%" -> Der Hexwert wird auf 16 Stellen begrenzt, somit werden überflüssige Nullen gestrichen. Wie genau funktioniert das hier? Eigentlich sollte dort doch im Moment drin stehen z.B.: 0000000000000000FFFFF, bedeutet er macht von hinten -16 Stellen und schneidet den Rest weg? Also: 00000000000FFFFF  
> 
> >>"test.reg" echo -> Erstellt die Datei "test.reg"  
> "test_value"=hex(b):%strHex:~-2%,%strHex:~-4,2%,%strHex:~-6,2%,%strHex:~-8,2%,%strHex:~-10,2%,%strHex:~-12,2%,%strHex:~-14,2%,%strHex:~,2%  -> Schreibt den umgewandelten Wert in die vorher erstellte Datei. Wie genau macht er das?  -> Das Minus bedeutet er fängt von hinten an?   

> 

Hi rubberman,

Danke erst mal. Ich habe deinen Code mal eingebaut und es scheint wirklich zu gehen

. Kannst Du mir den Code noch etwas genauer erklären? Wie das ganze denn funktioniert. Ich habe mal ein paar Kommentare geschrieben wie ich es soweit verstehe. Bitte mal ergänzen oder verbessern.

Meine jetzige Programmerweiterung:

REM DEZ in HEX Umrechnung
set "Z10=A" & set "Z11=B" & set "Z12=C" & set "Z13=D" & set "Z14=E" & set "Z15=F"  

set /a Dez = %FILESIZE%
set /a Rest=Dez
set "Hex="  

:WandlungDezHex
if %Rest%==0 goto :HEXCONVERT
set /a Ziffer=Rest%%16
if %Ziffer% gtr 9 call set "Ziffer=%%Z%Ziffer%%%"  
set "Hex=%Ziffer%%Hex%"  
set /a Rest=Rest/16
goto :WandlungDezHex

:HEXCONVERT
set "strHex=%Hex%"  

set "strHex=0000000000000000%strHex%"  
set "strHex=%strHex:~-16%"  

Ausgabe:

REM TODO: Umrechnung von dezimal in hex und konvertierung in REG_QWORD
ECHO >> "safer.reg" "ItemSize"=hex(b):%strHex:~-2%,%strHex:~-4,2%,%strHex:~-6,2%,%strHex:~-8,2%,%strHex:~-10,2%,%strHex:~-12,2%,%strHex:~-14,2%,%strHex:~,2%   

Hallo speedy26gonzales.

Wenn du dir die Hilfe zu SET ansiehst (SET /?), wirst du die passenden Erklärungen finden.
Zuerst werden 16 Nullen deinem Hex String vorangestellt. Um auf die exakte Länge von 16 Stellen insgesamt zu kommen, werden im Nachgang per %strHex:~-16% nur die letzten 16 Stellen des Variablenwertes wieder der Variablen zugewiesen. Der Rest funktioniert genauso.

%strHex:~-2% - die letzten beiden Zeichen
%strHex:~-4,2% - die ersten beiden Zeichen der letzten 4.
...
%strHex:~,2% - die ersten beiden Zeichen des Strings (auch als %strHex:~0,2% falls es so deutlicher wird)

BTW: Sowohl bastlas Link, als auch mein und dein Lösungsweg zur Erstellung des Hex Strings funktioniert nur mit Zahlen, die die CMD auch als Zahlenwert verarbeiten kann. Im Klartext bedeutet das, ein ganzzahliger vorzeichenbehafteter Wert mit max. 32 Bit Breite (-2147483648 bis 2147483647). Dateien können aber gerne mal größer sein und auch ein REG_QWORD ist dafür gemacht einen nicht-vorzeichenbehafteten ganzahligen Wert von 64 Bit Breite (bis 18446744073709551615) anzunehmen. Dafür brauchst du aber eine Sonderbehandlung. Batch kann damit nur schrittweise rechnen.

Dieser Algorithmus aus Stringmanipulation und bitweiser Arithmetik könnte das und gibt dir auch gleich einen 16-stelligen Hex String aus:

@echo off &setlocal

set "strBigint=18446744073709551615"  
:: set "strBigint=1311768467294899695" 
:: set "strBigint=15" 

setlocal EnableDelayedExpansion
set "strHex="  
set "strPool=0123456789ABCDEF"  
set "strBigint=00000000000000000000%strBigint%"  
for /f "tokens=* delims=0" %%i in ("%strBigint:~-20,5%") do set "int4=%%i" &if not defined int4 set "int4=0"  
for /f "tokens=* delims=0" %%i in ("%strBigint:~-15,5%") do set "int3=%%i" &if not defined int3 set "int3=0"  
for /f "tokens=* delims=0" %%i in ("%strBigint:~-10,5%") do set "int2=%%i" &if not defined int2 set "int2=0"  
for /f "tokens=* delims=0" %%i in ("%strBigint:~-5%")    do set "int1=%%i" &if not defined int1 set "int1=0"  
for /l %%i in (1,1,16) do (
    set /a "int3 += (int4 & 15) * 100000 , int4 >>= 4"  
    set /a "int2 += (int3 & 15) * 100000 , int3 >>= 4"  
    set /a "int1 += (int2 & 15) * 100000 , int2 >>= 4"  
    set /a "x = int1 & 15 , int1 >>= 4"  
    for %%j in (!x!) do set "strHex=!strPool:~%%j,1!!strHex!"  
)
endlocal &set "strHex=%strHex%"  

echo %strHex%

pause

Grüße
rubberman

Hi Rubber,

Danke für die Antwort.
Die Lösung wo ich im Moment eingebaut habe würde ja Dateien bis 256 MB verarbeiten können. Das Vorzeichen bringt mir ja rein gar nix weil der Speicher nicht negativ benutzt werden kann

Bedeutet dein letzter Post dass ich eher die Lösung als die vorher eingebaut nutzen soll?

Hallo speedy26gonzales.

Solange du von ein paar hundert MB redest, ist alles OK. Und dass du mit negativen Zahlenwerten nichts anfangen kannst, war mir klar. Darum auch mein Vorschlag, zugleich nur im positiven Bereich zu arbeiten, den Bereich auszuschöpfen den das REG_QWORD bietet und ohne Umschweife einen 16-stelligen Hex String zu bekommen.
Dass du dich damit bei den möglichen Dateigrößen im Exabyte Bereich bewegst und das sicher etwas overkill ist, ist mir bewusst. Andererseits bist du auf der sicheren Seite.

Grüße
rubberman

Ich werde morgen mal die "große" Variante einbauen.
Hab derzeit irgendwie noch ein anderes Problem:
Das Skript will auf meinem virtuellen Testsystem mit WindowsXP nicht laufen. Er durchsucht nur den Ordner aus dem ich es starte und findet dort nur die fciv.exe. Dann beendet er es? Ich hab keine Ahnung warum. Unter Windows7 läuft er zumindest die ganzen Ordner unter C:\ durch. Endsystem soll WindowsXP erst mal sein. Später evtl. dann Windows7.

So sieht derzeit das Skript aus:

REM Programm durchsucht das komplette Laufwerk nach *.EXE Dateien
@echo off & setlocal
REM Skript wird in ANSI geschrieben
ECHO Windows Registry Editor Version 5.00 > "safer.reg"  
ECHO. >> "safer.reg"  
REM Durchsucht das angegebene Laufwerk nach *.Exe Dateien und bei jeder gefundenen Datei ruft er das Unterprogramm auf
FOR /R "%SystemDrive%" %%I IN ("*.exe") DO CALL :MAKERULE "%%I"   
CALL :CLEAN
EXIT /B

:MAKERULE
REM Schreibe Pfadname
SET FILEPATH=%~1
SET FILESIZE=%~z1
SET FILENAME=%~n1
REM Erstelle eine GUID
cscript.exe //NoLogo uuid.vbs > "GUID.txt"  
SET /P GUID=<GUID.txt
REM Erstelle einen sha1 - HASH
fciv.exe -add "%~1" -sha1 > "HASH.txt"  
FOR /F "skip=3 eol=; tokens=1 usebackq delims= " %%a IN ("HASH.txt") DO (SET HASH=%%a)  

REM DEZ in HEX Umrechnung
set "Z10=A" & set "Z11=B" & set "Z12=C" & set "Z13=D" & set "Z14=E" & set "Z15=F"  

set /a Dez = %FILESIZE%
set /a Rest=Dez
set "Hex="  

:WandlungDezHex
if %Rest%==0 goto :HEXCONVERT
set /a Ziffer=Rest%%16
if %Ziffer% gtr 9 call set "Ziffer=%%Z%Ziffer%%%"  
set "Hex=%Ziffer%%Hex%"  
set /a Rest=Rest/16
goto :WandlungDezHex

:HEXCONVERT
set "strHex=%Hex%"  

set "strHex=0000000000000000%strHex%"  
set "strHex=%strHex:~-16%"  

REM >>"test.reg" echo "test_value"=hex(b):%strHex:~-2%,%strHex:~-4,2%,%strHex:~-6,2%,%strHex:~-8,2%,%strHex:~-10,2%,%strHex:~-12,2%,%strHex:~-14,2%,%strHex:~,2%  
REM echo Hexadezimal: %Hex%
REM CALL :MAKEREG
REM GOTO :EOF

:MAKEREG
ECHO. >> "safer.reg"  
ECHO [HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Safer\CodeIdentifiers\262144\Hashes\%GUID%] >> "safer.reg"  
REM TODO: Auslesen der letzten Dateiaenderung und anpassen des Formats (xx,xx,xx,xx...)
ECHO >> "safer.reg" "LastModified"=hex(b):   
REM TODO: Anpassung der Beschreibung
ECHO >> "safer.reg" "Description"="%FILEPATH%"   
REM TODO: Bessere Benennung des FriendlyName
ECHO >> "safer.reg" "FriendlyName"="%FILENAME%"   
REM Zu "SaferFlags" existiert keine Doku, Wert immer 0  
ECHO >> "safer.reg" "SaferFlags"=dword:00000000   
REM TODO: Umrechnung von dezimal in hex und konvertierung in REG_QWORD
ECHO >> "safer.reg" "ItemSize"=hex(b):%strHex:~-2%,%strHex:~-4,2%,%strHex:~-6,2%,%strHex:~-8,2%,%strHex:~-10,2%,%strHex:~-12,2%,%strHex:~-14,2%,%strHex:~,2%   
REM Aufsplitten des Hashs in Zweiergruppen
ECHO >> "sha1.txt" "ItemData"=hex:%HASH%   
ECHO >> "safer.reg" "ItemData"=hex:%HASH:~0,2%,%HASH:~2,2%,%HASH:~4,2%,%HASH:~6,2%,%HASH:~8,2%,%HASH:~10,2%,%HASH:~12,2%,%HASH:~14,2%,%HASH:~16,2%,%HASH:~18,2%,%HASH:~20,2%,%HASH:~22,2%,%HASH:~24,2%,%HASH:~26,2%,%HASH:~28,2%,%HASH:~30,2%,%HASH:~32,2%,%HASH:~34,2%,%HASH:~36,2%,%HASH:~38,2%  
REM Hash Algorithmus wird auf SHA1 gesetzt: 0x8003 (32771) = MD5, 0x8004 (32772) = SHA1
ECHO >> "safer.reg" "HashAlg"=dword:00008004   
ECHO. >> "safer.reg"  
GOTO :EOF

:CLEAN
del GUID.txt
del HASH.txt
GOTO :EOF

Hi.

Welchen Wert hat denn die Umgebungsvariable %SytemDrive% auf deinem virtuellen Testsystem?

Wenn ich ne Batch schreibe:

 ECHO %SystemDrive% >"C:\Test.txt"

schreibt er nur C: , kann es sein dass mir dort ein \ hinter dem %SystemDrive% fehlt?
Hhhm kann aber auch nicht sein. Laut dem Eintrag: http://de.wikipedia.org/wiki/Umgebungsvariable müsste es doch passen?

EDIT: Habe jetzt mal so erweitert:

FOR /R "%SystemDrive%"\ %%I IN ("*.exe") DO CALL :MAKERULE "%%I"    

Jetzt scheint es zu gehen. Verhält sich dann unter WindowsXP und Windows7 doch anderst ??

Habe das Skript jetzt mal so laufen lassen. Irgendwann bricht er mir ab mit dem Fehler "fehlender Operand" , was könnte das sein?

Hallo.