Wird der Nullterminator am ende von 0x90 auch mit gezählt ?

char s[] = "\x41\x41\x00\x90";
cout<<sizeof(s);

Hallo wieso wird hier eine 5 anstatt eine 4 ausgeben ?

Wird der Nullterminator am ende von 0x90 auch mit gezählt ?

char s[] = "\x41\x41\x00\x90";
cout<<sizeof(s);

Ja natürlich, dafür brauchst du ja auch Platz. Wenn du die Länge des Strings wissen willst, benötigst du strlen.

Besser wäre in einem C++-Programm aber die Verwendung von std::string.

std::string wird auch durch \x00 Terminiert :>

Deswegen verwende ich für mein Shellcode char []

char s[]= "\xeb\x50\x5b\x53\xb8\x7b\x1d\x80\x7c\xff\xd0\xe8\x35\x00\x00\x00\x5b\x53\x50\xba\x40\xae\x80\x7c\xff\xd2\xe8\x18\x00\x00\x00\x5b\x68\x00\x00\x00\x00\x53\xff\xd0\xe8\x00\x00\x00\x00\x31\xc0\x50\xb8\x12\xcb\x81\x7c\xff\xd0\xe8\xe3\xff\xff\xff\x63\x61\x6c\x63\x2e\x65\x78\x65\x00\xe8\xc6\xff\xff\xff\x57\x69\x6e\x45\x78\x65\x63\x00\xe8\xab\xff\xff\xff\x6b\x65\x72\x6e\x65\x6c\x33\x32\x2e\x64\x6c\x6c\x00";

[Section .text]
BITS 32
global _start

_start:

jmp short GetDLLname 

LoadLib: 
				pop  ebx  ; ebx = kernel32.dll
				push ebx 
				mov  eax , 0x7c801d7b ; LoadLibrary Addr    
				call eax  ; call LoadLibrary  return wert in eax

				call GetFuncName

GetDllAddr:
				pop ebx   ; ebx = WinExec
				push ebx        ; WinExec 				
				push eax        ; handle von LoadLibrary

				mov edx,0x7c80ae40  ; GetProcAddress addr 
				call edx 	        ; call GetProcAdress  return addr in eax			
				call ExecName

ExecProg:
				pop ebx

				push 0
				push ebx	
				call eax  ; addr von WinExec 

				call ExitProg

ExitProg:
				xor eax,eax
				push eax
				mov eax,0x7c81cb12
			    call eax

ExecName:
				call ExecProg
				db "calc.exe"
				db 00

GetFuncName:
				call GetDllAddr
				db "WinExec"
				db 00

GetDLLname:

				call LoadLib 
				db "kernel32.dll" 
				db 0x00

std::string wird auch durch \x00 Terminiert :>

Nein, ein std::string kann \0 im Text enthalten und ist am Ende nicht notwendigerweise mit einem \0 abgeschlossen.

Aber für Shellcode würde ich ihn auch nicht verwenden, denn da willst du ja etwas kaputt machen

std::string var[] = {"\x41\x41\x00\x41\x41"};

        for (int i=0;i<=sizeof(var);i++)
        {
             std::cout<<var[i];
        }

Gibt beides bei mir aus: AA

Auch std::string wird durch \x00 Terminiert.

std::string var= "\x41\x41\x00\x41\x41";

Auch std::string wird durch \x00 Terminiert.

Nein, bei der Initialisierung über einen const char* wird nur bis zum \0 kopiert (woher soll der Konstruktor auch wissen, dass das String-Literal noch länger ist?). Du kannst aber z.B.

std::string var("\x41\x41\x00\x41\x41", 5);
assert(var.length() == 5);

sagen.

std::string var= "\x41\x41\x00\x41\x41";

std::cout << var;

std::string var[] = {"\x41\x41\x00\x41\x41"};

        for (int i=0;i<=sizeof(var);i++)
        {
             std::cout<<var[i];
        }

Gibt beides bei mir aus: AA

Auch std::string wird durch \x00 Terminiert.

Oho, Beweis durch Beispiel. Auch bekannt als "Das beweist überhaupt nichts". std::string braucht keine Nullterminierung zu haben und man darf sich darauf nicht verlassen, auch wenn bei deiner speziellen Implementierung vielleicht manchmal ein Nullzeichen folgt.

std::string braucht keine Nullterminierung zu haben und man darf sich darauf nicht verlassen, auch wenn bei deiner speziellen Implementierung vielleicht manchmal ein Nullzeichen folgt.

Doch, man kann sich drauf verlassen, dass std::string nicht nullterminiert ist. Die Annahme, es sei doch so, beruht hier auf einer Fehlinterpretation, siehe die zwei Postings vor dir.

SeppJ schrieb:

std::string braucht keine Nullterminierung zu haben und man darf sich darauf nicht verlassen, auch wenn bei deiner speziellen Implementierung vielleicht manchmal ein Nullzeichen folgt.

Doch, man kann sich drauf verlassen, dass std::string nicht nullterminiert ist. Die Annahme, es sei doch so, beruht hier auf einer Fehlinterpretation, siehe die zwei Postings vor dir.

Sicher? Ich bin mir ziemlich sicher, dass std::string auch eine Nullterminierung am Ende haben darf. Wäre zwar dumm das so zu implementieren, aber laut Standard dürfte nichts dagegen sprechen.

Wenn du recht hättest, dürfte bei dem Code:

std::string var("\x41\x41\x00\x41\x41", 5);
assert(var.length() == 5);

je nach Lust und Laune des Compilerherstellers die Assertion fehlschlagen.

Der Konstruktor von std::string hat aber als Nachbedingung, dass size() bzw. length() gleich der übergebenen Länge ist.

Ja, sicher. Lies es nach, 21.3§1:
"the template class basic_string describes objects that can store a sequence consisting of a varying number of arbitrary char-like objects"

Wenn du recht hättest, dürfte bei dem Code:

std::string var("\x41\x41\x00\x41\x41", 5);
assert(var.length() == 5);

je nach Lust und Laune des Compilerherstellers die Assertion fehlschlagen.

Der Konstruktor von std::string hat aber als Nachbedingung, dass size() bzw. length() gleich der übergebenen Länge ist.

Ich glaube, du verstehst das mit dem Nullterminiert falsch. Das soll nicht bedeuten, dass bei einem \0 der String zu ende ist, sondern nur, dass hinter dem letzen gültigen Zeichen eine \0 stehen kann, aber nicht muss. Im String selber können beliebig viele \0 stehen und die ändern auch nichts an der Länge.

Es soll ja auch nicht das Ende markieren.

Doch, sonst ist es was anderes. Null-terminiert bedeutet, dass das Ende durch Null angezeigt wird.
Was std::string außerhalb des zugreifbaren Bereichs anhängt, interessiert doch keinen. Da darf std::string es gerne eine Null anhängen, das ist auch gar nicht mal soo dumm, weil dann c_str() trivial (= performanter) implementiert werden kann.

SeppJ schrieb:

Es soll ja auch nicht das Ende markieren.

Doch, sonst ist es was anderes. Null-terminiert bedeutet, dass das Ende durch Null angezeigt wird.
Was std::string außerhalb des zugreifbaren Bereichs anhängt, interessiert doch keinen. Da darf std::string es gerne eine Null anhängen, das ist auch gar nicht mal soo dumm, weil dann c_str() trivial (= performanter) implementiert werden kann.

Die Komplexitätsanforderungen an c_str() bzw. data() erfordern das sogar.