Byte* zu Hexstring

seb5594

Leider hat es nicht das gewünschten ergebnis gebracht.
Der byte array ist folgender:
0E DA AE D9 F4 80 EA 0C BF 80 D2 C7 EB 2D 88 69

Als ausgabe hab ich dies erhalten: � >X
Das gewünschte ergebnis ist aber
"0EDAAED9F480EA0CBF80D2C7EB2D8869" als char*.

Das script sieht aktuell so aus

const char* hexString(unsigned char *bytes, int bytesLength)
{
	char lookup[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
	char s[33]; //length 16 * 2 + 1 = 33. fixed size da es eine konstante benötigt hat.
	for (int i = 0; i < bytesLength; i++) 
	{
		s[i * 2] = lookup[bytes[i] >> 4];
		s[i * 2 + 1] = lookup[bytes[i] & 0xF];
	}
	return s;
}

Achtung, du gibst da einen Zeiger auf ein lokales Array zurück. Nimm entweder malloc oder überlass die Bufferverwaltung dem Aufrufer.

void hexString(unsigned char *bytes, int bytesLength, char *dest)
{
    char lookup[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    for (int i = 0; i < bytesLength; i++) {
        dest[2*i  ] = lookup[(bytes[i]>>4)&0xF];
        dest[2*i+1] = lookup[bytes[i] & 0xF];
    }
    dest[2*bytesLength] = 0;
}

SeppJ

seb5594 schrieb:

Das problem an der sache ist, das die Konsole sehr eingeschränkt ist was Libs angeht, ich kann natürlich standardfunctions with strlen, printf, va usw benutzen aber leider keine std libs (std::string/sstream usw).

Das ist eine SEHR ungewöhnliche Einschränkung. Bist du sicher, dass du kein C machst? Kennt die Umgebung keine dynamische Speicherverwaltung?

seb5594

selbercoden? schrieb:

Achtung, du gibst da einen Zeiger auf ein lokales Array zurück. Nimm entweder malloc oder überlass die Bufferverwaltung dem Aufrufer.

void hexString(unsigned char *bytes, int bytesLength, char *dest)
{
    char lookup[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    for (int i = 0; i < bytesLength; i++) {
        dest[2*i  ] = lookup[(bytes[i]>>4)&0xF];
        dest[2*i+1] = lookup[bytes[i] & 0xF];
    }
    dest[2*bytesLength] = 0;
}

Vielen dank dir!
Habe fast das erwartete ergebnis

Hash: 0EDAAED9F480EA0CBF80D2C7EB2D8869� >X

Eigentlich sollte es nur bis zur 69 am ende gehen.
Rufe die funktion so auf. Malloc funkioniert nicht auf meiner Konsole.

char temp[33];
hexString(buffer, 0x10, temp);

Columbo

Besser:

void hexString(unsigned char const* bytes, std::size_t bytesLength, char* dest)
{
	static char const lookup[] = "0123456789ABCDEF";

	for (std::size_t i = 0; i != bytesLength; ++i)
	{
		dest[2*i  ] = lookup[ bytes[i] >> 4  ];
		dest[2*i+1] = lookup[ bytes[i] & 0xF ];
	}
}

Testprogramm:

int main()
{
	unsigned char const arr[] = {1, 2, 3, 4, 5};
	char dest[2*sizeof arr + 1];

	hexString(arr, sizeof arr, dest);
	dest[2*sizeof arr] = 0;

	std::cout << dest;
}

Mit erwarteter Ausgabe. Die Nullterminierung sollte dem Aufrufer überlassen werden.

seb5594

SeppJ schrieb:

seb5594 schrieb:

Das problem an der sache ist, das die Konsole sehr eingeschränkt ist was Libs angeht, ich kann natürlich standardfunctions with strlen, printf, va usw benutzen aber leider keine std libs (std::string/sstream usw).

Das ist eine SEHR ungewöhnliche Einschränkung. Bist du sicher, dass du kein C machst? Kennt die Umgebung keine dynamische Speicherverwaltung?

Und ja, sehr sicher. Das Sony SDK hat sehr schlecht detailierte Dokumentationen (teilweise japanisch) und bietet sehr viele Funktionen was die konsole direkt angeht, alles andere ist irgendwie auf der Strecke geblieben, was ich persöhnlich auch sehr merkwürdig finde. Die Konkurrenz (Microsoft) hat dagegen die nase vorne deutlich.
Für die zwecke für die ich es benötige, reicht's eigentlich ausser die kleinen einschränkungen bei einigen dingen.

Lg

seb5594

Arcoth schrieb:

Besser:

void hexString(unsigned char const* bytes, std::size_t bytesLength, char* dest)
{
	static char const lookup[] = "0123456789ABCDEF";

	for (std::size_t i = 0; i != bytesLength; ++i)
	{
		dest[2*i  ] = lookup[ bytes[i] >> 4  ];
		dest[2*i+1] = lookup[ bytes[i] & 0xF ];
	}
}

Testprogramm:

int main()
{
	unsigned char const arr[] = {1, 2, 3, 4, 5};
	char dest[2*sizeof arr + 1];

	hexString(arr, sizeof arr, dest);
	dest[2*sizeof arr] = 0;

	std::cout << dest;
}

Mit erwarteter Ausgabe. Die Nullterminierung sollte dem Aufrufer überlassen werden.

Leider bekomme ich immer als ergebnis diesen char
"0EDAAED9F480EA0CBF80D2C7EB2D8869� >X"

Columbo

Du setzt den Nullterminator zu spät.

Schreib mal

temp[32] = 0;

hinter den Aufruf.

Arcoth schrieb:

Die Nullterminierung sollte dem Aufrufer überlassen werden.

Was für einen Zweck hat das? Premature optimization zu Lasten von Fehleranfälligkeit!?

seb5594

Arcoth schrieb:

Du setzt den Nullterminator zu spät.

Schreib mal
temp[32] = 0;
hinter den Aufruf.

Leider nein, so ist mein Funktionsaufruf

char dest[0x21];
	hexString(buffer, 0x10, dest);
	dest[0x20] = 0;
	return dest;

Swordfish

Arcoth schrieb:

Die Nullterminierung sollte dem Aufrufer überlassen werden.

Weil? Ohne Nullterminierung sollte deine Funktion nicht String im Namen haben ...

seb5594

Swordfish schrieb:

Arcoth schrieb:

Die Nullterminierung sollte dem Aufrufer überlassen werden.

Weil? Ohne Nullterminierung sollte deine Funktion nicht String im Namen haben ...

Hab jetzt mal den char array von 0x21 auf 0x20 gemacht und das ist dann das resultut

"0EDAAED9F480EA0C� >XD2C7EB2D8869"

selbercoden? schrieb:

Achtung, du gibst da einen Zeiger auf ein lokales Array zurück. Nimm entweder malloc oder überlass die Bufferverwaltung dem Aufrufer.

seb5594

selbercoden? schrieb:

selbercoden? schrieb:

Achtung, du gibst da einen Zeiger auf ein lokales Array zurück. Nimm entweder malloc oder überlass die Bufferverwaltung dem Aufrufer.

Malloc fällt schonmal aus der auswahl durch, wie meinst mit überlassen der bufferverwaltung?

Lg

Swordfish

Arcoth hat dir die Lösung doch eh schon gegeben ...

#include <cstddef>
#include <iostream>

void bytes2hexstring( char * dst, char unsigned const * bytes, std::size_t num_bytes )
{
	char const * lookup{ "0123456789ABCDEF" };

	for( std::size_t i{}; i < num_bytes; ++i ) {

		dst[ 2 * i     ] = lookup[ bytes[ i ] >> 4   ];
		dst[ 2 * i + 1 ] = lookup[ bytes[ i ] & 0x0f ];
	}

	dst[ 2 * num_bytes ] = '\0';
}

int main()
{
	char unsigned hash[] =
		{ 0x0E, 0xDA, 0xAE, 0xD9, 0xF4, 0x80, 0xEA, 0x0C,
		  0xBF, 0x80, 0xD2, 0xC7, 0xEB, 0x2D, 0x88, 0x69 };

	char buffer[ sizeof hash * 2 + 1 ];  // Puffer wird vom Aufrufer zur Verfuegung gestellt.

	bytes2hexstring( buffer, hash, sizeof hash );

	std::cout << buffer << '\n';
}

seb5594

Swordfish schrieb:

Arcoth hat dir die Lösung doch eh schon gegeben ...

#include <cstddef>
#include <iostream>

void bytes2hexstring( char * dst, char unsigned const * bytes, std::size_t num_bytes )
{
	char const * lookup{ "0123456789ABCDEF" };
 
	for( std::size_t i{}; i < num_bytes; ++i ) {

		dst[ 2 * i     ] = lookup[ bytes[ i ] >> 4   ];
		dst[ 2 * i + 1 ] = lookup[ bytes[ i ] & 0x0f ];
	}

	dst[ 2 * num_bytes ] = '\0';
}

int main()
{
	char unsigned hash[] =
		{ 0x0E, 0xDA, 0xAE, 0xD9, 0xF4, 0x80, 0xEA, 0x0C,
		  0xBF, 0x80, 0xD2, 0xC7, 0xEB, 0x2D, 0x88, 0x69 };

	char buffer[ sizeof hash * 2 + 1 ];  // Puffer wird vom Aufrufer zur Verfuegung gestellt.

	bytes2hexstring( buffer, hash, sizeof hash );

	std::cout << buffer << '\n';
}

Dennoch stimmt das endergebnis nicht wirklich

void hexString(unsigned char *bytes, size_t bytesLength, char *dest)
{
	char const lookup[] = "0123456789ABCDEF";
	for (std::size_t i = 0; i != bytesLength; ++i)
	{
		dest[2 * i] = lookup[bytes[i] >> 4];
		dest[2 * i + 1] = lookup[bytes[i] & 0xF];
	}
	dest[2 * bytesLength] = '\0';
}

So rufe ich die Funktion

char dest[sizeof buffer * 2 + 1];
	hexString(buffer, sizeof buffer, dest);
	return dest;

Mein Buffer ist 16 bytes groß (0x10)

Ergebnis:
"0EDAAED9F480EA0CBF80D2C7EB2D8869� >X"
Richtig wäre
"0EDAAED9F480EA0CBF80D2C7EB2D8869"

Lg

tkausl

char dest[sizeof buffer * 2 + 1]; 
    hexString(buffer, sizeof buffer, dest); 
    return dest;

Du returnst schon wieder etwas aus dem lokalen Namensraum...

Swordfish

seb5594 schrieb:

So rufe ich die Funktion

char dest[sizeof buffer * 2 + 1];
	hexString(buffer, sizeof buffer, dest);
	return dest;  // <<-- hier!!

In welcher Funktion steht denn das? Wo wird deren Ergebnis ausgegeben?
Ist dir klar, dass du schon wieder eine Funktionslokale Variable zurückgibst?

selbercoden? schrieb:

selbercoden? schrieb:

Achtung, du gibst da einen Zeiger auf ein lokales Array zurück. Nimm entweder malloc oder überlass die Bufferverwaltung dem Aufrufer.

seb5594

Swordfish schrieb:

seb5594 schrieb:
So rufe ich die Funktion
char dest[sizeof buffer * 2 + 1];
	hexString(buffer, sizeof buffer, dest);
	return dest;  // <<-- hier!!
In welcher Funktion steht denn das? Wo wird deren Ergebnis ausgegeben?
Ist dir klar, dass du schon wieder eine Funktionslokale Variable zurückgibst?

Ihr könntet mir auch sagen wie ich es sonst zurück geben sollte.
Das ist meine MD5Hash Funktion...

const char* HashMD5String(const char* String)
{
	uint8_t buffer[16];
	if (cellMd5Digest(String, strlen(String), buffer) == CELL_OK)
	{
		char dest[sizeof buffer * 2 + 1];
		hexString(buffer, sizeof buffer, dest);
		return dest;
	}
	return "INVALID";
}

Danke schonmal