Warum ist die Funktion gets so gefährlich, dass sie nicht benutzt werden sollte?

Warum ist gets() gefährlich

Der erste internet-Wurm (der Morris-Internet-Wurm) flüchtete vor 27 Jahren (1988-11-02), und es verwendet gets() - und einem Puffer-überlauf, der als eine seiner Methoden zur Vermehrung von system zu system. Das grundlegende problem ist, dass die Funktion nicht weiß, wie groß der Puffer ist, so dass es weiterhin Lesen, bis es findet ein Zeilenumbruch oder trifft auf EOF, und kann überlauf der Grenzen des Puffers gegeben wurde.

Sollten Sie vergessen, Sie jemals gehört, dass gets() existierte.

Den C11-standard ISO/IEC 9899:2011 beseitigt gets() als eine standard-Funktion, das ist Eine Gute Sache™. Leider bleibt es in Bibliotheken seit vielen Jahren (was bedeutet, 'Jahrzehnten') aus Gründen der rückwärts-Kompatibilität. Wenn es nach mir geht, die Umsetzung der gets() werden würde:

char *gets(char *buffer)
{
    assert(buffer != 0);
    abort();
    return 0;
}

Gegeben, dass Ihr code wird crash sowieso, früher oder später ist es besser, den Kopf der ärger aus, eher früher als später. Ich würde bereit sein, um hinzuzufügen eine Fehlermeldung:

fputs("obsolete and dangerous function gets() called\n", stderr);

Moderne Versionen des Linux-Kompilierung system generiert Warnungen wenn Sie einen link gets() — und auch einige andere Funktionen, die auch die security-Probleme (mktemp()...).

Alternativen zu gets()

fgets()

Als alle anderen sagte, ist die kanonische alternative zu gets() ist fgets() Angabe stdin wie die Datei-stream.

char buffer[BUFSIZ];

while (fgets(buffer, sizeof(buffer), stdin) != 0)
{
    ...process line of data...
}

Was niemand sonst noch erwähnt wird, dass gets() beinhaltet nicht das newline aber fgets() tut. Also, müssen Sie möglicherweise verwenden Sie einen wrapper um fgets() löscht die newline:

char *fgets_wrapper(char *buffer, size_t buflen, FILE *fp)
{
    if (fgets(buffer, buflen, fp) != 0)
    {
        size_t len = strlen(buffer);
        if (len > 0 && buffer[len-1] == '\n')
            buffer[len-1] = '\0';
        return buffer;
    }
    return 0;
}

Auch, wie caf Punkte in einen Kommentar und paxdiablo zeigt in seiner Antwort, mit fgets() müssen Sie möglicherweise Daten über Links auf einer Linie. Meine wrapper-code Blättern, die Daten zu Lesen, die nächste Zeit; Sie können leicht ändern Sie es zu fressen, der rest der Zeile der Daten, wenn Sie bevorzugen:

        if (len > 0 && buffer[len-1] == '\n')
            buffer[len-1] = '\0';
        else
        {
             int ch;
             while ((ch = getc(fp)) != EOF && ch != '\n')
                 ;
        }

Das Verbleibende problem ist, wie die Berichterstattung der drei verschiedenen Ergebnis-Staaten — EOF oder Fehler, Zeile Lesen und nicht abgeschnitten, und teilweise Zeile Lesen, aber die Daten abgeschnitten wurde.

Dieses problem entsteht nicht mit gets() weil Sie nicht wissen, wo Sie den Puffer beendet und fröhlich tramples über das Ende, wütet auf Ihrem wunderschön gepflegten memory layout, oft Unordnung auf dem return-stack (eine - Stack Overflow), wenn der Puffer auf dem Stapel reserviert, oder trampeln über die Kontrolle der Informationen, wenn der Puffer wird dynamisch zugewiesen, oder kopieren von Daten über andere wertvolle Globale (oder-Modul) - Variablen, wenn der Puffer statisch zugewiesen. Keines von diesen ist eine gute Idee — Sie verkörpern die phrase 'undefined behaviour`.

Gibt es auch die TR 24731-1 (Technischer Bericht vom C Standard Committee), die sicherere alternativen zu einer Vielzahl von Funktionen, einschließlich gets():

§6.5.4.1 Die gets_s Funktion

Synopsis

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
char *gets_s(char *s, rsize_t n);

Runtime-Einschränkungen

s ist nicht ein null-Zeiger. n weder gleich null, noch größer als
RSIZE_MAX ist. Ein neue-Zeile-Zeichen, Ende-der-Datei, oder lese-Fehler tritt innerhalb Lesen
n-1 Zeichen von stdin.²⁵⁾

3, Wenn es eine Laufzeit-constraint-Verletzung, s[0] eingestellt ist, um das null-Zeichen, und-Zeichen
gelesen und verworfen stdin bis ein neue-Zeile-Zeichen gelesen wird, oder das Ende der Datei oder
ein Lesefehler tritt auf.

Beschreibung

4 Die gets_s Funktion liest höchstens um eins kleiner als die Anzahl der Zeichen angegeben n
aus dem stream gezeigt, durch stdin, in das array verweist s. Keine zusätzliche
Zeichen gelesen werden, nachdem ein neue-Zeile-Zeichen (wird verworfen) oder nach dem Ende-der-Datei.
Das verworfen, neue-Zeile-Zeichen zählen nicht gegen die Anzahl von Zeichen Lesen. Ein
null-Zeichen geschrieben wird, sofort nachdem der Letzte gelesene Zeichen in das array.

5 Wenn das Ende der Datei angetroffen wird, und Sie keine Zeichen, die gelesen wurden in die Reihe, oder, wenn ein Lesen
Fehler tritt während dem Betrieb, dann s[0] eingestellt ist, um das null-Zeichen, und die anderen
Elemente der s nehmen Sie unbestimmte Werte.

Empfohlen

6 Die fgets Funktion ermöglicht das richtig geschriebene Programme, um sicher zu Prozess-input-Zeilen zu
lange zu speichern in das Ergebnis-array. Im Allgemeinen erfordert dies, dass der Anrufer fgets bezahlen
die Aufmerksamkeit auf die Anwesenheit oder Abwesenheit von einem neue-Zeile-Zeichen in das Ergebnis-array. Betrachten
mit fgets (zusammen mit gegebenenfalls erforderliche Verarbeitung basierend auf neue-Zeile-Zeichen) anstelle von
gets_s.

²⁵⁾ Die gets_s Funktion, im Gegensatz zu gets macht es zu einem Laufzeit-constraint-Verletzung für eine Zeile der Eingabe
überlauf der Puffer zu speichern. Im Gegensatz zu fgets, gets_s unterhält eine eins-zu-eins-Beziehung zwischen
Eingabe-Linien und erfolgreiche Gespräche zu gets_s. Programme, die mit gets erwarten, dass eine solche Beziehung.

Microsoft Visual Studio-Compiler implementieren, die eine Annäherung an die TR 24731-1 standard, aber es gibt Unterschiede zwischen den Signaturen, die von Microsoft implementiert und die in der TR.

Dem C11 standard, ISO/IEC 9899-2011, umfasst TR24731 in Anhang K als optionaler Teil der Bibliothek. Leider ist es selten umgesetzt, auf Unix-ähnlichen Systemen.

getline() — POSIX -

POSIX 2008 bietet auch eine sichere alternative zu gets() genannt getline(). Es reserviert Speicherplatz für dynamisch, so dass Sie am Ende brauchen, um zu befreien. Es beseitigt die Beschränkung der Länge der Linie, daher. Es auch gibt die Länge der Daten, die gelesen wurde, oder -1 (und nicht EOF!), was bedeutet, dass null-bytes in der Eingabe behandelt werden können, zuverlässig. Es gibt auch eine "wählen Sie Ihr eigenes single-character delimiter' Variante namens getdelim(); dies kann nützlich sein, wenn Sie sich mit der Ausgabe von find -print0 wo die enden der Dateinamen, die markiert sind mit einem ASCII-NUL '\0' Charakter, zum Beispiel.

InformationsquelleAutor der Antwort Jonathan Leffler

Sollten Sie nicht verwenden gets da hat es keine Möglichkeit zu stoppen Sie einen Pufferüberlauf. Wenn der Benutzer mehr Daten als fit in den Puffer, werden Sie wahrscheinlich am Ende mit Korruption oder schlechter.

In der Tat, ISO tatsächlich den Schritt von entfernen gets aus dem C-standard (C11, obwohl es veraltet in C99), was angesichts der Tatsache, wie hoch diese rate Abwärtskompatibilität, sollte ein Indiz dafür, wie schlecht diese Funktion war.

Das richtige zu tun, ist die Verwendung der fgets Funktion mit der stdin Datei-handle, seit Sie beschränken können, die Zeichen Lesen des Benutzers aus.

Aber dies hat auch seine Probleme, wie:

• zusätzliche Zeichen durch den Benutzer eingegeben wird, abgeholt werden das nächste mal um.
• es gibt keine schnelle Benachrichtigung, dass die vom Benutzer eingegebenen Daten zu lang.

Zu diesem Zweck werden in fast jeder C Programmierer an einem gewissen Punkt in Ihrer Karriere schreiben ein nützlicher wrapper fgets als gut. Hier ist meins:

#include <stdio.h>
#include <string.h>

#define OK       0
#define NO_INPUT 1
#define TOO_LONG 2
static int getLine (char *prmpt, char *buff, size_t sz) {
    int ch, extra;

    //Get line with buffer overrun protection.
    if (prmpt != NULL) {
        printf ("%s", prmpt);
        fflush (stdout);
    }
    if (fgets (buff, sz, stdin) == NULL)
        return NO_INPUT;

    //If it was too long, there'll be no newline. In that case, we flush
    //to end of line so that excess doesn't affect the next call.
    if (buff[strlen(buff)-1] != '\n') {
        extra = 0;
        while (((ch = getchar()) != '\n') && (ch != EOF))
            extra = 1;
        return (extra == 1) ? TOO_LONG : OK;
    }

    //Otherwise remove newline and give string back to caller.
    buff[strlen(buff)-1] = '\0';
    return OK;
}

mit einigen test-code:

//Test program for getLine().

int main (void) {
    int rc;
    char buff[10];

    rc = getLine ("Enter string> ", buff, sizeof(buff));
    if (rc == NO_INPUT) {
        printf ("No input\n");
        return 1;
    }

    if (rc == TOO_LONG) {
        printf ("Input too long\n");
        return 1;
    }

    printf ("OK [%s]\n", buff);

    return 0;
}

Es bietet den gleichen Schutz wie fgets in, dass es verhindert Pufferüberläufe aber auch, informiert den Anrufer, was passiert ist, und löscht die überschüssigen Zeichen, so dass Sie nicht auf Ihre nächste Eingabe.

Fühlen Sie sich frei, es zu benutzen, wie du willst, befreie ich Sie unter dem "tun, was Sie verdammt nochmal wollen" - Lizenz 🙂

InformationsquelleAutor der Antwort paxdiablo

Können Sie nicht entfernen Sie API-Funktionen, ohne die API. Wenn Sie viele Anwendungen nicht mehr kompilieren oder ausführen überhaupt.

Dies ist der Grund dafür, dass eine Referenz gibt:

Eine Zeile zu Lesen, die über das
array Spitzen, von s ergibt sich
Undefiniertes Verhalten. Die Verwendung von fgets()
empfohlen.

InformationsquelleAutor der Antwort Gerd Klima

In C11(ISO/IEC 9899:201x), gets() entfernt wurde. (Es ist veraltet, die in ISO/IEC 9899:1999/Cor.3:2007(E))

Neben fgets() C11 stellt eine neue sichere alternative gets_s():

C11 K. 3.5.4.1 Die gets_s - Funktion

#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
char *gets_s(char *s, rsize_t n);

Jedoch in der Empfohlen Abschnitt fgets() noch immer bevorzugt.

Den fgets Funktion ermöglicht das richtig geschriebene Programme, um sicher zu Prozess-input-Zeilen zu
lange zu speichern in das Ergebnis-array. Im Allgemeinen erfordert dies, dass der Anrufer fgets bezahlen
die Aufmerksamkeit auf die Anwesenheit oder Abwesenheit von einem neue-Zeile-Zeichen in das Ergebnis-array. Betrachten
mit fgets (zusammen mit gegebenenfalls erforderliche Verarbeitung basierend auf neue-Zeile-Zeichen) anstelle von
gets_s.

InformationsquelleAutor der Antwort Yu Hao

Ich würde gerne verlängern, eine ernsthafte Einladung an alle C-Bibliothek Betreuer da draußen, die noch darunter gets in Ihren Bibliotheken "nur falls jemand immer noch davon abhängig zu sein": Bitte ersetzen Sie Ihre Implementierung mit dem äquivalent von

char *gets(char *str)
{
    strcpy(str, "Never use gets!");
    return str;
}

Dies wird helfen, sicherzustellen, dass niemand ist noch davon abhängig zu sein. Danke.

InformationsquelleAutor der Antwort Steve Summit