ein Kapitel zurück                                           ein Kapitel weiter

1.Die meisten Buffer Overflows werden mit den Funktionen, der Standard Library, gets(), sprintf(), vsprintf(), strcpy(), strcat() und stpcpy() gemacht. Ebenso scanf() ist für Buffer Overflow verletztlich, da bei dieser wie auch den anderen genannten Funktionen keine "Begrenzungen" der Zeichenketten vorhanden ist. Also sollte man, sofern sie auf dementsprechende OS vorhanden sind, alternative Funktionen verwenden die diese Längenüberprüfung durchführen. Hierzu nun ein Liste der verletztlichen Funktionen und deren Alternative.....

  • gets() -> fgets()
  • sprintf() -> snprintf() (leider nicht auf jedem System vorhanden)
  • vsprintf()-> vsnprintf() (leider nicht auf jedem System vorhanden)
  • strcpy() -> strncpy() (lässt den Endestring '\0' aus falls ein Überlauf stattfindet)
  • strcat() -> strncat() (wie strncpy)
  • stpcpy() -> stpncpy() (Kopiert exakt die Anzahl der Angegeben Zeichen in das Ziel)

Falls es in Ihrem Programm auf Perfomance ankommt muss noch erwähnt werden das die Funktionen mit der n-Alternative langsamer sind als die ohne.

2. Sollten das Programm schon geschrieben sein, und jemand meldet einen Buffer Overflow bei Ihrem Programm, was ist dann zu tun? Man fixt das Programm. Vorraussetzung man hat den Source-Code zu diesem Programm bzw. kennt den Programmierer der diesen Besitzt und weist diesen auf diesen Bug hin. Das Programm zu fixen ist übrigens die häufigste Fehlerbehebung. Gebt mal in der Suchmaschine die Worte "Buffer Overflow Bugfix" ein und Ihr werdet merken das der Buffer Overflow einer der meist gemachten Fehler eines Programmierers ist. Man Programmiert ein Wrapper-Funktion. Eine Wrapper-Funktion kann man sich als Strumpf vorstellen den man über eine anfällige Funktion darüberstülpt. Beispielsweise... 

/*Download:strcpy.c*/

#include <stdio.h>
#define MAX  10
 /*Damit keine Kollision mit strcpy in string.h*/
#define strcpy Strcpy

char puffer[MAX];

void Strcpy(char *ziel, char *quelle)
{
  int counter;
  for(counter=0; quelle[counter] != '\0' && counter < 10; counter++)
    ziel[counter]=quelle[counter];
  ziel[MAX] = '\0';     /*Zur Sicherheit am Ende Terminieren*/
}

int main(int argc, char **argv)
{
  strcpy(puffer, "123456789012345678");
  printf("puffer = %s\n",puffer);
  return 0;
}

Zuerst müssen wir vor dem Compilerlauf die Funktion strcpy mittels...... 

#define strcpy Strcpy

...ausschalten. Jetzt kann anstatt der echten strcpy-Version die Wrapper-Funktion Strcpy() verwenden. Genauso kann dies bei den anderen gefährlichen Funktionen gemacht werden. Beispielsweise gets()....

/*Download:getss.c*/

#include <stdio.h>
#define MAX  10
/*Damit keine Kollision mit gets*/
#define gets(c) Gets(c)

char puffer[MAX];

void Gets(char *z)
{
  int c;
  int counter=0;
  while((c=getchar()) != '\n')
       z[counter++]=c;
  z[MAX] = '\0';     /*Zur Sicherheit am Ende Terminieren*/
}

int main(int argc, char **argv)
{
  printf("Eingabe : ");
  gets(puffer);
  printf("puffer = %s\n",puffer);
  return 0;
}

Natürlich läßt sich so auch die Funktion strncpy() nachbilden, die nicht auf jedem System vorhanden ist.......

/*Download:strncpy.c*/

#include <stdio.h>
#define MAX  10
/*Damit keine Kollision mit strncpy */
#define strncpy Strncpy

char puffer[MAX];

void Strncpy(char *ziel, char *quelle, int n)
{
  int counter;
  for(counter=0; counter < n && quelle[counter] != '\0'; counter++)
    ziel[counter]=quelle[counter];
  ziel[++counter] = '\0';     /*Zur Sicherheit am Ende Terminieren*/
}

int main(int argc, char **argv)
{
  strncpy(puffer, "12345678901234567", 8);   /*8 Zeichen in puffer*/
  printf("puffer = %s\n",puffer);
  return 0;
}

Das mit den Wrapper-Funktionen hört sich jetzt ziemlich toll an. Man muss aber erwähnen das eine Wrapper-Funktion die Perfomance erheblich einbremst. Das daher weil Funktionen wie z.B. strcpy der Standard-Library für dem Compiler optimiert sind, und wir mit unserer Wrapper-Funktion jedesmal einen neuen Funktionsaufruf durchführen. Dies sollte überdacht werden, sollte es auf Geschwindigkeit ankommen.

3.Es gibt auch Software um Buffer Overflows aufzudecken. Ein Software wäre z.B. Insure++ von Parasoft, was sich aber für Hobbyprogrammierer wegen des hohen Preises nicht rechnet. Das Programm meldet zwar den Buffer Overflow nicht zu Compilierzeit, aber es registriert während der Laufzeit einen Pufferüberlauf und meldet diesen an Insra. Dies Programm kann natürlich weit aus mehr um den Preis von 5000 Euro zu Gerechtferigen. Beispielsweise auch das Auffinden von Speicherlecks. Für Firmen kann sich dieser hohe Preis aber rechnen. Was diese Software sonst noch alles kann, können sie unter http://www.parasoft.com/products/insure/index.htm nachlesen.

ein Kapitel zurück          nach oben           ein Kapitel weiter


© 2001,2002 Jürgen Wolf