"\x56\x8B\xF1\x8B\x06\xFF\x90\xB8\x04\x00\x00\x8B\x86\xE8\x0D\x00\x00\x85\xC0\x74\x0E\x8B\x50\x18\x85\xD2\x74\x07\x8B\x48\x1C\x03\xCE\xFF\xD2"

Problem ist: Ich brauch den Kram als unsigned char*. Ein einfaches casten geht nicht, da der Compiler die einzelnen Bytes nicht als char ansieht.
Es muss also so aussehen (später):

unsigned char *pszSignatureFixed = {\x56, \x8B, \xF1, \x8B, \x06, ...};

Wie kriege ich das hin?
Das funktioniert leider auch nicht:

for (unsigned int i = 0; i < strlen(pszSignature); i += 4)
				{
					pszSignatureFixed[i] = 0x0 + pszSignature[i + 2] + pszSignature[i + 3];
				}

Gruß und Danke!

Ein einfaches casten geht nicht, da der Compiler die einzelnen Bytes nicht als char ansieht.

Doch, einfaches (reinterpret-)casten "geht"...

char *pszSignature = m_pSettings->getString(pszBaseName, "signature");
unsigned char *pszSignatureFixed = new unsigned char[strlen(pszSignature) + 1];
pszSignatureFixed = reinterpret_cast<unsigned char*>(pszSignature);

Msg("Manuell eingegeben: %s\nUngecastet: %s\nGecastet: %s\n", (unsigned char*)"\x56\x8B\xF1\x8B\x06\xFF\x90\xB8\x04\x00\x00\x8B\x86\xE8\x0D\x00\x00\x85\xC0\x74\x0E\x8B\x50\x18\x85\xD2\x74\x07\x8B\x48\x1C\x03\xCE\xFF\xD2", pszSignature, pszSignatureFixed);

Maneull eingegeben: <kryptische Zeichen, so wie ich es brauche>
Ungecastet: \x56\x8B\xF1\x8B\x06\xFF\x90\xB8\x04\x00\x00\x8B\x86\xE8\x0D\x00\x00\x85\xC0\x74\x0E\x8B\x50\x18\x85\xD2\x74\x07\x8B\x48\x1C\x03\xCE\xFF\xD2
Gecastet: \x56\x8B\xF1\x8B\x06\xFF\x90\xB8\x04\x00\x00\x8B\x86\xE8\x0D\x00\x00\x85\xC0\x74\x0E\x8B\x50\x18\x85\xD2\x74\x07\x8B\x48\x1C\x03\xCE\xFF\xD2

~ Chris

Gruß und Danke.

Hi.
Das geht schlecht da ich noch ein paar mehr char's habe und diese nicht als unsigned möchte.
Die Datei die ich parse wird mittels Funktionen von VALVe ausgelesen (Spielehersteller) und dieser Parser liefert nur const char's zurück.

Gruß und Danke.

du kannst signed davor schreiben.

~ Chris

char *pszSignature = m_pSettings->getString(pszBaseName, "signature");
unsigned char *pszSignatureFixed = reinterpret_cast<unsigned char*>(pszSignature);

Das liegt wohl daran, dass die Signatur in etwa so vorliegt:

pszSignature[0] = '\\';
pszSignature[1] = 'x';
pszSignature[2] = '5';
pszSignature[3] = '6';
// ...

Und nicht so:

pszSignature[0] = '\x56';

Gruß

...
unsigned char *pszSignatureFixed = new unsigned char[strlen(pszSignature) + 1];
pszSignatureFixed = reinterpret_cast<unsigned char*>(pszSignature);
...

...

char* pszSignature = {"\x56\x8B\xF1\x8B\x06"};
  unsigned char* pszSignatureFixed = new unsigned char[strlen(pszSignature) + 1];
  // pszSignatureFixed = reinterpret_cast<unsigned char*>(pszSignature);//  Fehler! 
  // Es ist Quatsch den Zeiger den new geliefert hat zu überschreiben.
  memcpy(pszSignatureFixed, pszSignature, strlen(pszSignature)+1); // ist nach new folgerichtig 
                                                                   // und beinhaltet nebenbei den Cast.

Siehe meinen letzten Post.

Gruß und Danke

Danke für den Code, aber dennoch funktioniert das nicht, da die Bytes nicht mehr als Bytes vorliegen

Dann solltest Du ermitteln, warum die Bytes nicht mehr als Bytes vorliegen. Am Cast kann es nicht liegen, insofern ist die Frage beantwortet.

Und um die Folgefrage zu beantworten, hast Du bislang nicht genug Infos geliefert.

EDIT: Oder suchst Du jetzt eine Möglichkeit, den als '\', 'x', '5', '4' vorliegenden String in ein (unsigned) char mit dem Wert '\x45' umzuwandeln?

EDIT: Oder suchst Du jetzt eine Möglichkeit, den als '\', 'x', '5', '4' vorliegenden String in ein (unsigned) char mit dem Wert '\x45' umzuwandeln?

Ist das ein Byte=

Gruß und Danke

und wo ist das problem?

char *pszSignatureFixed = new char[strlen(pszSignature) + 1];
				unsigned short iLengthxx = strlen(pszSignature);

				for (unsigned short i = 0; i < iLengthxx; i += 4)
				{
					if (i + 4 < iLengthxx)
					{
						char *pszTemp = new char[4];
						sprintf(pszTemp, "\\x%i%i", pszSignature[i + 2], pszSignature[i + 3]);
						sprintf(pszSignatureFixed, "%x%x", pszSignatureFixed, pszTemp);

						delete[] pszTemp;
					}
				}

Gruß und Danke

Hi.
Hab mal das hier gebastelt, das liefert aber komplett falsche Ergebnisse

char *pszSignatureFixed = new char[strlen(pszSignature) + 1];
				unsigned short iLengthxx = strlen(pszSignature);

				for (unsigned short i = 0; i < iLengthxx; i += 4)
				{
					if (i + 4 < iLengthxx)
					{
						char *pszTemp = new char[4];
						sprintf(pszTemp, "\\x%i%i", pszSignature[i + 2], pszSignature[i + 3]);
						sprintf(pszSignatureFixed, "%x%x", pszSignatureFixed, pszTemp);

						delete[] pszTemp;
					}
				}

Gruß und Danke

Beschreib mal in Worten, was der Code machen soll. So ist es ein wenig äh ... undurchsichtig, um es mal vorsichtig zu formulieren.

char *pszTemp = new char[4];

no comment. epic fail!

char pszTemp[4];

// Speicher freimachen
char *pszSignatureFixed = new char[strlen(pszSignature) + 1];
// Länge der Signatur (vom String her)
unsigned short iLengthxx = strlen(pszSignature);

// Durchlaufen von jedem Abschnitt ab \, also i von 0-3 wäre \x56, 4-7 wäre \x8B usw
for (unsigned short i = 0; i < iLengthxx; i += 4)
{
    // Nur wenn i + 4 < als Länge ist (sonst Crash)
    if (i + 4 < iLengthxx)
    {
        // Speicher freimachen
        char *pszTemp = new char[4];
        // Abschnitt zu einem \x<i + 2><i + 3> zusammenfügen, wenn i = 0 wäre es \x56
        sprintf(pszTemp, "\\x%i%i", pszSignature[i + 2], pszSignature[i + 3]);
        // Nun zu pszSignatureFixed den String als Byte hinzufügen durch %x in sprintf
        sprintf(pszSignatureFixed, "%x%x", pszSignatureFixed, pszTemp);

        // Speicher freigeben
        delete[] pszTemp;
    }
}

EDIT: Wieso sollte das ein fail sein?!
EDIT2: Oh man ^^ In Python wäre das mit einem binascii.unhexlify einfach getan

Gruß

theliquidwave schrieb:

Hi.
Hab mal das hier gebastelt, das liefert aber komplett falsche Ergebnisse

char *pszSignatureFixed = new char[strlen(pszSignature) + 1];
				unsigned short iLengthxx = strlen(pszSignature);

				for (unsigned short i = 0; i < iLengthxx; i += 4)
				{
					if (i + 4 < iLengthxx)
					{
						char *pszTemp = new char[4];
						sprintf(pszTemp, "\\x%i%i", pszSignature[i + 2], pszSignature[i + 3]);
						sprintf(pszSignatureFixed, "%x%x", pszSignatureFixed, pszTemp);

						delete[] pszTemp;
					}
				}

Gruß und Danke

Beschreib mal in Worten, was der Code machen soll. So ist es ein wenig äh ... undurchsichtig, um es mal vorsichtig zu formulieren.

Duju wanna want sowas hier? Guggsu brazza:

string str;
	char* s = "\x41\x42\x43\x2D\x4B\x6F\x6D\x70\x6C\x69\x63\x61\x74\x30\x72";
	while(*s)
		str += *s++;
	cout << str << endl;

Hab mir halt folgendes gedacht:

// Speicher freimachen
char *pszSignatureFixed = new char[strlen(pszSignature) + 1];
// Länge der Signatur (vom String her)
unsigned short iLengthxx = strlen(pszSignature);

// Durchlaufen von jedem Abschnitt ab \, also i von 0-3 wäre \x56, 4-7 wäre \x8B usw
for (unsigned short i = 0; i < iLengthxx; i += 4)
{
    // Nur wenn i + 4 < als Länge ist (sonst Crash)
    if (i + 4 < iLengthxx)
    {
        // Speicher freimachen
        char *pszTemp = new char[4];
        // Abschnitt zu einem \x<i + 2><i + 3> zusammenfügen, wenn i = 0 wäre es \x56
        sprintf(pszTemp, "\\x%i%i", pszSignature[i + 2], pszSignature[i + 3]);
        // Nun zu pszSignatureFixed den String als Byte hinzufügen durch %x in sprintf
        sprintf(pszSignatureFixed, "%x%x", pszSignatureFixed, pszTemp);

        // Speicher freigeben
        delete[] pszTemp;
    }
}

Duju wanna want sowas hier? Guggsu brazza:

string str;
	char* s = "\x41\x42\x43\x2D\x4B\x6F\x6D\x70\x6C\x69\x63\x61\x74\x30\x72";
	while(*s)
		str += *s++;
	cout << str << endl;

Sowie ich das verstanden habe, hat er diesen Fall:

char* s = "\\x41\\x42\\x43\\x2D\\x4B\\x6F\\x6D\\x70\\x6C\\x69\\x63\\x61\\x74\\x30\\x72";

Also in dem char[] steht wirklich "\x41" statt "A".

EDIT2: Oh man ^^ In Python wäre das mit einem binascii.unhexlify einfach getan

char* s = "\x41\x42\x43\x2D\x4B\x6F\x6D\x70\x6C\x69\x63\x61\x74\x30\x72";
	string unhexlificat0r(s);
	cout << unhexlificat0r << endl;

du willst aus nem '\0xAB' ein 'A' 'B' machen, wobei A und B beliebige Zeichen sind!?

also z.bsp.
\0xAB\0xCD\0xEF
-> ABCDEF

richtig?

falls ja z.bsp. mittels std::string und std::find + std::string::erase
bzw std::string und std::string::substring