4. Regsitry Binary Werte auslesen

Regsitry Binary Werte auslesen

  • L

    hy da dEUs Tutorial Regsitry nicht das auslesen und verändern und wieder schreiben der Binären Werte behandelt, möchte ich an dEUs tutorial anknüpfen und den beitrag bezüglich Binäre Werte setzen verfollständigen.

    Da dEUs die handhabung der Registry schon ausfürlich erklärt hat und die Regeln bezüglich Binärer Daten auslesen nicht viel anderst ist, erspare ich mir hinsichtlich dieser großartige erklärungen.

    der einfachste und eigendlich nicht erwähnenswerte weg Bytewerte auszulesen und wieder zu setzen, wäre eben sie auszulesen, unverändert als Bytewert zu lassen und diesen dann wieder zu schreiben.

    Aber wer will das schon. dieses tutorial ist dazu da, zu zeigen wie man werte aus der registry holt, verändert, und veränderte werte wieder speichert.
    Somit gebrauche ich auch 4 Funktionen die NICHT die registry betreffen aber darauf eingehn den Bytewert aus der registry anzuzeigen zu verändern und wieder als Bytewert zu speichern

    Binäre Werte auslesen:

    HKEY 	m_hMasterKey 	= HKEY_LOCAL_MACHINE;//Hauptschlüssel
LPCTSTR m_lpSubKey 	= "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion";//Schlüssel Pfad
LPCTSTR m_lpValueName	= "DigitalProductId";//Schlüsselname der ausgelesen wird

HKEY hKey;
BYTE byData[1024]="";//Wichtig genügend platz schaffen
DWORD dwDataSize=sizeof(Data);
DWORD dwType=REG_BINARY;

RegOpenKey(m_hMasterKey, m_lpSubKey, &hKey);

RegQueryValueEx(hKey, m_lpValueName, 0, &dwType, byData, &dwDataSize);

    byData enthält nun die Daten aus dem Schlüßel DigitalProductId und dwDataSize beinhaltet die exackte größe von byData

    Nun machen wir das ganze sichtbar als Hex & Ascii String wie es auch in der Regsity zu sehen ist wenn wir den Schlüssel öffnen würden.
    der Hex String kann dann in einem Editfeld Angezeigt und bearbeitet werden.

    LPTSTR lpszHex;
LPTSTR lpszAscii;

ByteToHex(byData, dwDataSize, lpszHex);

ByteToAscii(byData, dwDataSize,lpszAscii);

    der inhalt von lpszHex sieht nun in etwa wie folgt aus

    a4 00 00 00 03 00 00 00 37 36 34 39 37 2d 4f 45 4d 2d 30 30 36 33 30 36 36 2d 30 36 33 38 33 00 2d 00 00 00 41 32 32 2d 30 30 30 30 31 00 00 00 00 00 00 00 5e 94 2c 4b dc a8 28 6e 94 ef 87 09 51 a3 03 00 00 00 00 00 66 c5 68 44 b0 1f 06 00 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 38 31 37 32 38 00 00 00 00 00 00 00 de 17 00 00 77 90 bc cc 00 04 00 00 26 57 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 7b cb 2a 93

    und der inhalt von lpszAscii gestalltet sich in etwa so

    ¤.......76497-OEM-0063066-06383.-...A22-00001.......^”,Kܨ(n”ï‡.Q£......fÅhD°...........................81728.......Þ...w.¼Ì....&W..............................{Ë*“

    nun da wir den Bytewert als Hex String vor uns haben, können wir ihn verändern, wie und wo muss jeder benutzer für sich selber wissen, ich zeige jetzt nur noch wie man den Hex String nach bearbeitung wieder zurück in einen Bytewert bekommt und dieser korreckt in der Regsitry abgespeichert wird

    BYTE *pBuffer;	//Byte Wert der in die Regsitry geschrieben wird
DWORD dwSize;	//größe des zu schreibenden Bytewertes

HexToByte(lpszHex,pBuffer, dwSize);

    wichtig zum schreiben des Bytewertes ist das der Schlüssel genauso geöffnet wird wie beim lesen, lediglich der Typ REG_BINARY und die größe des Bytewertes in DWORD werden hier nicht als long Pointer übergeben.

    RegSetValueEx(hKey, m_lpValueName, 0, dwType, pBuffer, dwSize);

    int HexToInt(char*I)
{
	for(int l=0;*I;l*=16,l+=(!!('@'&*I))*9+*I++&'\17');return l;
} 

void HexToByte(LPTSTR pszIn,BYTE *&pData, DWORD &dwSize)
{
	dwSize = (DWORD)strlen(pszIn) / 3;//Merke wir haben aus einem Byte 3 Stellen gemacht

	pData = new BYTE[dwSize];

	char szHex[3];

	unsigned int j	= 0;//Position
	unsigned int j1 = 0;//Erstes Zeichen
	unsigned int j2 = 0;//Zweites Zeichen

	for (DWORD i = 0; i < dwSize; i++)
	{
		j1 = j++;
		j2 = j++;

		sprintf(szHex,"%c%c",pszIn[j1],pszIn[j2]);

		BYTE b = (BYTE) HexToInt(szHex);//Wandel Hexwert in Byte

		pData[i] = b;
		j++;//Überspringe Leerstelle
	}

}

void ByteToHex(const BYTE* pData, DWORD dwSize, LPTSTR &pszOut) 
{
	pszOut = new TCHAR[(dwSize * 3) + 1];//Merke wir machen aus einem Byte 3 Stellen

	for(DWORD n = 0; n < dwSize; ++n)
		wsprintf(&pszOut[n * 3], TEXT("%.02x "), pData[n]); 
}

void ByteToAscii(const BYTE* pData, DWORD dwSize, LPTSTR &pszOut)
{
	pszOut = new char[(dwSize*3) + 1];
	sprintf(pszOut,"");

	char szDezString[4];
	char szAsciiString[4];
	for (DWORD i = 0; i < dwSize; i++)
	{
		sprintf(szDezString,"%u",pData[i]);//Dezimaler Byte Wert

		if(atoi(szDezString)<=31 || atoi(szDezString) == 144)//Filter nichtdarstellbare zeichen
				sprintf(szAsciiString,"%c",'.');
		else
				sprintf(szAsciiString,"%c",atoi(szDezString));//Dezimaler Wert in Ascii

		strcat(pszOut,szAsciiString);
	}

}
    0
  • N

    LowFly schrieb:

    int HexToInt(char*I)
{
	for(int l=0;*I;l*=16,l+=(!!('@'&*I))*9+*I++&'\17');return l;
}

    und dafür schreibste aber auch ein tutorial, oder? 😉

    0
  • ?

    Hallo, sieht cool aus, aber ich versteh auch nur Bahnhof, wenn ich mir das ansehe. Die for-Schleife im hex to int. Machst du darüber auch ein tutorial, wie man das als neuling begreift bzw. angehen muss? Danke

    0
Anmelden zum Antworten