Wie Sie verhindern, dass memcpy-Puffer-überlauf?

Wie kann ich erkennen, ob es buffer overflow?

Ich glaube, Sie haben drei oder vier Möglichkeiten (geben oder nehmen).

Ist die erste Wahl, um eine "sichere" Funktion für memcpy. Dies ist, was ich verlange im code unter meiner Aufsicht, und ich regelmäßig eine Prüfung für Sie. Ich verlange auch, dass alle Parameter überprüft werden, und alle Parameter, die geltend gemacht werden.

Den Behauptungen erstellen selbst Debuggen von code. Ich möchten, dass Entwickler code schreiben; und ich will Sie nicht verschwenden Zeit mit Debuggen. So ich verlangen, daß Sie code schreiben, Debuggen selbst. Behauptet auch Dokumente, die die Dinge ziemlich gut, so dass Sie knausern auf die Dokumentation. In release-builds, die Behauptet werden entfernt, indem preporcessor Makros.

errno_t safe_memcpy(void* dest, size_t dsize, void* src, size_t ssize, size_t cnt)
{
    ASSERT(dest != NULL);
    ASSERT(src != NULL);
    ASSERT(dsize != 0);
    ASSERT(ssize != 0);
    ASSERT(cnt != 0);

    //What was the point of this call?
    if(cnt == 0)
        retrn 0;

    if(dest == NULL || src == NULL)
        return EINVALID;

    if(dsize == 0 || ssize == 0)
        return EINVALID;

    ASSERT(dsize <= RSIZE_MAX);
    ASSERT(ssize <= RSIZE_MAX);
    ASSERT(cnt <= RSIZE_MAX);

    if(dsize > RSIZE_MAX || ssize > RSIZE_MAX || cnt > RSIZE_MAX)
        return EINVALID;

    size_t cc = min(min(dsize, ssize), cnt);
    memmove(dest, src, cc);

    if(cc != cnt)
        return ETRUNCATE;

    return 0;
}

Wenn Ihr safe_memcpy gibt nicht 0, dann gab es einen Fehler, wie eine schlechte parameter oder potenziellen Pufferüberlauf.

Die zweite Möglichkeit ist die Verwendung "sicherer" Funktionen der C-Standard. C hat "sicherer" - Funktionen über ISO/IEC TR 24731-1 Bounds-Checking Interfaces. Auf konforme Plattformen, können Sie einfach anrufen gets_s und sprintf_s. Sie bieten ein konsistentes Verhalten (wie immer dafür ein string ist NULL beendet) und die konsequente Rückkehr-Werte (wie 0 bei Erfolg oder ein errno_t).

errno_t  err = memcpy_s(dest, dsize, src, cnt);
...

Leider, gcc und glibc nicht konform zum C-Standard. Ulrich Drepper (einer der glibc-maintainer) genannt bounds-checking interfaces "schrecklich ineffizient BSD Mist", und Sie wurden nie Hinzugefügt.

Die Dritte Wahl ist, um die Plattform "sicherer" - Schnittstellen, falls vorhanden. Auf Windows -,, die passiert werden die gleichen wie jene, die in ISO/IEC TR 24731-1 Bounds-Checking Interfaces. Sie haben auch die String-Bibliothek Sicher.

Auf Apple und BSD haben Sie nicht eine "sicherere" Funktion für memcpy. Aber Sie haben safer string-Funktionen wie strlcpy, strlcat und Freunde.

Unter Linux, die vierte Wahl ist, um FORTIFY_SOURCE. FORTIFY_SOURCE verwendet die "sicherere" Variante von high-risk-Funktionen wie memcpy, strcpy und gets. Der compiler verwendet die sicherere Variante, wenn es ableiten kann, die Ziel-Puffer-Größe. Wenn die Kopie überschreiten würde, die Ziel-Puffer-Größe), dann ruft das Programm abort(). Wenn der compiler nicht ableiten, das Ziel-Puffer-Größe, dann die "sicherere" Variante (N) werden nicht verwendet.

Deaktivieren FORTIFY_SOURCE für die Prüfung, sollten Sie das Programm kompilieren mit -U_FORTIFY_SOURCE oder -D_FORTIFY_SOURCE=0.

Wenn zum Beispiel Sie haben:

Ziel 4 bytes Größe

Quelle 5 bytes Größe

Können Sie stellen Sie sicher, dass Sie maximal 4 bytes zur Ziel-Puffer:

size_t getCopySize(size_t sourceSize, size_t destSize)
{
    return (destSize <= sourceSize ? destSize : sourceSize);
}
memcpy(destination, source, getCopySize(sizeof(source),sizeof(destination)));

Basierend auf Ihrer Anwendung könnten Sie auch sicherstellen, dass die restlichen Daten kopiert werden zu einem späteren Zeitpunkt, oder können Sie überspringen, wenn einige Daten können ignoriert werden.