Heap Overflow - Versionsgeschichte

Boris23: redirect (Information momentan komplett doppelt, siehe Diskussion:Pufferüberlauf#Heap_Overflow)

2005-12-20T17:48:54Z

redirect (Information momentan komplett doppelt, siehe Diskussion:Pufferüberlauf#Heap_Overflow)

← Nächstältere Version		Version vom 20. Dezember 2005, 19:48 Uhr
Zeile 1:		Zeile 1:
			#redirect [[Pufferüberlauf]]
	Ein '''Heap-Überlauf''' (''heap overflow'') ist ein [[Pufferüberlauf]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].

	Durch ''Heap-Überläufe'' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.

	''siehe auch'': [[Shellcode]], [[Exploit]]

	== Beispiel ==

	<code>
	#define BUFSIZE 128

	char * copy_string(const char *s)
	{
	char * buf = malloc(BUFSIZE); /* Annahme: Längere Strings kommen niemals vor */

	strcpy(buf, s); /* Heap-Überlauf, falls strlen(s) > 127 */

	return buf;
	}
	</code>

	Man sollte lieber folgendes verwenden:

	<code>
	char * buf;

	buf = malloc(1 + strlen(s)); /* Plus 1 wegen des terminierenden NUL-Zeichens */
	strcpy(buf, s);
	</code>

	Einige Betriebssysteme, z. B. [[OpenBSD]], bieten die Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.

	== Weblinks ==
	* http://www.w00w00.org/files/articles/heaptut.txt

	[[en:Heap overflow]]
	[[Kategorie:Sicherheitslücken]]
	[[Kategorie:Programmierung]]

Stern: warum sollte das umleiten?

2005-12-02T09:44:53Z

warum sollte das umleiten?

← Nächstältere Version		Version vom 2. Dezember 2005, 11:44 Uhr
Zeile 1:		Zeile 1:
			Ein '''Heap-Überlauf''' (''heap overflow'') ist ein [[Pufferüberlauf]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].
	#REDIRECT [[Pufferüberlauf]]

			Durch ''Heap-Überläufe'' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.

			''siehe auch'': [[Shellcode]], [[Exploit]]

			== Beispiel ==

			<code>
			#define BUFSIZE 128

			char * copy_string(const char *s)
			{
			char * buf = malloc(BUFSIZE); /* Annahme: Längere Strings kommen niemals vor */

			strcpy(buf, s); /* Heap-Überlauf, falls strlen(s) > 127 */

			return buf;
			}
			</code>

			Man sollte lieber folgendes verwenden:

			<code>
			char * buf;

			buf = malloc(1 + strlen(s)); /* Plus 1 wegen des terminierenden NUL-Zeichens */
			strcpy(buf, s);
			</code>

			Einige Betriebssysteme, z. B. [[OpenBSD]], bieten die Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.

			== Weblinks ==
			* http://www.w00w00.org/files/articles/heaptut.txt

			[[en:Heap overflow]]
			[[Kategorie:Sicherheitslücken]]
			[[Kategorie:Programmierung]]

Dammbruch: Einarbeitung in Pufferüberlauf

2005-07-20T17:55:49Z

Einarbeitung in Pufferüberlauf

← Nächstältere Version		Version vom 20. Juli 2005, 19:55 Uhr
Zeile 1:		Zeile 1:
			#REDIRECT [[Pufferüberlauf]]
	Ein '''Heap-Überlauf''' (''heap overflow'') ist ein [[Pufferüberlauf]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].

	Durch ''Heap-Überläufe'' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.

	''siehe auch'': [[Shellcode]], [[Exploit]]

	== Beispiel ==

	<code>
	#define BUFSIZE 128

	char * copy_string(const char *s)
	{
	char * buf = malloc(BUFSIZE); /* Annahme: Längere Strings kommen niemals vor */

	strcpy(buf, s); /* Heap-Überlauf, falls strlen(s) > 127 */

	return buf;
	}
	</code>

	Man sollte lieber folgendes verwenden:

	<code>
	char * buf;

	buf = malloc(1 + strlen(s)); /* Plus 1 wegen des terminierenden NUL-Zeichens */
	strcpy(buf, s);
	</code>

	Einige Betriebssysteme, z. B. [[OpenBSD]], bieten die Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.

	== Weblinks ==
	* http://www.w00w00.org/files/articles/heaptut.txt

	[[en:Heap overflow]]
	[[Kategorie:Sicherheitslücken]]
	[[Kategorie:Programmierung]]

80.136.212.63 am 19. Juli 2005 um 17:12 Uhr

2005-07-19T17:12:34Z

← Nächstältere Version		Version vom 19. Juli 2005, 19:12 Uhr
Zeile 1:		Zeile 1:
	Ein '''Heap ~~Overflow~~''' ist ein [[~~Buffer Overflow~~]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].		Ein '''Heap-Überlauf''' (''heap overflow'') ist ein [[Pufferüberlauf]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].

	Durch '''Heap ~~Overflows'~~'' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.		Durch ''Heap-Überläufe'' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.

	''siehe auch'': [[Shellcode]], [[Exploit]]		''siehe auch'': [[Shellcode]], [[Exploit]]
Zeile 10:		Zeile 10:
	#define BUFSIZE 128		#define BUFSIZE 128

	char *		char * copy_string(const char *s)
	copy_string(const char *s)
	{		{
	char buf = malloc(BUFSIZE); / Annahme: Längere Strings kommen niemals vor */		char * buf = malloc(BUFSIZE); /* Annahme: Längere Strings kommen niemals vor */

	strcpy(buf, s); /* Heap ~~Overflow~~, falls strlen(s) > 127 */		strcpy(buf, s); /* Heap-Überlauf, falls strlen(s) > 127 */

	return buf;		return buf;
Zeile 24:		Zeile 23:

	<code>		<code>
	char *buf;		char * buf;

	buf = malloc(1 + strlen(s)); /* Plus 1 wegen des terminierenden NUL-Zeichens */		buf = malloc(1 + strlen(s)); /* Plus 1 wegen des terminierenden NUL-Zeichens */

Fabian6129: kat

2005-07-17T13:06:09Z

kat

← Nächstältere Version		Version vom 17. Juli 2005, 15:06 Uhr
Zeile 36:		Zeile 36:

	[[en:Heap overflow]]		[[en:Heap overflow]]
			[[Kategorie:Sicherheitslücken]]
			[[Kategorie:Programmierung]]

80.146.29.90: "allokiert" ist definitiv kein deutsches Wort ;-)

2005-07-10T15:22:58Z

"allokiert" ist definitiv kein deutsches Wort ;-)

← Nächstältere Version		Version vom 10. Juli 2005, 17:22 Uhr
Zeile 1:		Zeile 1:
	Ein '''Heap Overflow''' ist ein [[Buffer Overflow]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird ~~allokiert~~, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].		Ein '''Heap Overflow''' ist ein [[Buffer Overflow]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird zugewiesen, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].

	Durch '''Heap Overflows''' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.		Durch '''Heap Overflows''' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.

84.150.94.247 am 3. Juli 2005 um 13:09 Uhr

2005-07-03T13:09:53Z

← Nächstältere Version		Version vom 3. Juli 2005, 15:09 Uhr
Zeile 1:		Zeile 1:
	Ein '''Heap Overflow''' ist ein [[Buffer Overflow]], der auf dem [[Heap]] stattfindet. Speicher auf dem Heap wird allokiert, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].		Ein '''Heap Overflow''' ist ein [[Buffer Overflow]], der auf dem [[Dynamischer Speicher\|Heap]] stattfindet. Speicher auf dem Heap wird allokiert, wenn Programme dynamischen Speicher anfordern, etwa über malloc() oder den ''new''-Operator in [[C-Plusplus\|C++]]. Werden in einen Puffer auf dem Heap Daten ohne Überprüfung der Länge geschrieben und ist die Datenmenge größer als die Größe des Puffers, so wird über das Ende des Puffers hinausgeschrieben und es kommt zu einem [[Speicherüberlauf]].

	Durch '''Heap Overflows''' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.		Durch '''Heap Overflows''' kann meist beliebiger Code auf dem Rechner ausgeführt werden, insbesondere wenn der Heap ausführbar ist. [[FreeBSD]] hat z.B. einen Heap-Schutz, hier ist dies nicht möglich. Sie können nur in [[Programmiersprachen]] auftreten, in denen bei Pufferzugriffen keine Längenüberprüfung stattfindet. [[C (Programmiersprache)\|C]], [[C-Plusplus\|C++]] oder [[Assemblersprache\|Assembler]] sind anfällig, [[Java (Programmiersprache)\|Java]] oder [[Perl (Programmiersprache)\|Perl]] sind es nicht.

80.144.188.220: /* Beispiel */

2005-06-06T13:27:20Z

Beispiel

← Nächstältere Version		Version vom 6. Juni 2005, 15:27 Uhr
Zeile 30:		Zeile 30:
	</code>		</code>

	Einige Betriebssysteme, z. B. [[OpenBSD]], bieten ~~eine~~ Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.		Einige Betriebssysteme, z. B. [[OpenBSD]], bieten die Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.

	== Weblinks ==		== Weblinks ==

195.62.99.203: /* Beispiel */ Vereinfacht; Kommentar korrigiert (off-by-one); strncpy nicht als "gutes" Beispiel anführen

2005-06-02T18:00:34Z

Beispiel: Vereinfacht; Kommentar korrigiert (off-by-one); strncpy nicht als "gutes" Beispiel anführen

← Nächstältere Version		Version vom 2. Juni 2005, 20:00 Uhr
Zeile 10:		Zeile 10:
	#define BUFSIZE 128		#define BUFSIZE 128

			char *
	int main(int argc, char** argv) {
			copy_string(const char *s)
		⚫	{
			char buf = malloc(BUFSIZE); / Annahme: Längere Strings kommen niemals vor */

		⚫	strcpy(buf, s); /* Heap Overflow, falls strlen(s) > 127 */
	char* buf=malloc(BUFSIZE);

	/* ~~... */~~		return buf;
⚫
⚫	strcpy(buf, ~~argv[1]~~); /* Heap Overflow, falls strlen(~~argv[1]~~) > ~~BUFSIZE~~ */
⚫
	return 0;
	}		}
	</code>		</code>

	Man sollte lieber folgendes verwenden:		Man sollte lieber folgendes verwenden:

	<code>		<code>
			char *buf;
	strncpy(buf, argv[1], BUFSIZE);
		⚫
	buf[BUFSIZE-1] = '\0'; /* Falls strlen(argv[1]) >= BUFSIZE war, fügt strncpy kein terminiertendes Nullbyte an. */
			buf = malloc(1 + strlen(s)); /* Plus 1 wegen des terminierenden NUL-Zeichens */
			strcpy(buf, s);
	</code>		</code>

	Einige Betriebssysteme, z. B. [[OpenBSD]], bieten eine Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.		Einige Betriebssysteme, z. B. [[OpenBSD]], bieten eine Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.

	== Weblinks ==		== Weblinks ==

82.82.233.60 am 16. Mai 2005 um 02:02 Uhr

2005-05-16T02:02:18Z

← Nächstältere Version		Version vom 16. Mai 2005, 04:02 Uhr
Zeile 28:		Zeile 28:
	</code>		</code>

	Einige Betriebssysteme, z. B. [[OpenBSD]], bieten eine Funktion ''strlcpy'' an, die sicherstellt, dass der ~~Zielstrink~~ nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.		Einige Betriebssysteme, z. B. [[OpenBSD]], bieten eine Funktion ''strlcpy'' an, die sicherstellt, dass der Zielstring nullterminiert wird und das Erkennen eines abgeschnittenen Zielstrings vereinfacht.

	== Weblinks ==		== Weblinks ==