Warum wird strncpy nicht mit null beendet?

strncpy() schützt angeblich vor Pufferüberläufen. Aber wenn es einen Überlauf ohne Nullterminierung verhindert, wird aller Wahrscheinlichkeit nach eine nachfolgende Zeichenfolgenoperation überlaufen. Um mich dagegen zu schützen, mache ich Folgendes:

strncpy( dest, src, LEN );
dest[LEN - 1] = '\0';

man strncpy gibt:

Das strncpy() Funktion ist ähnlich, außer dass nicht mehr als n Byte von src werden kopiert. Also, wenn unter den ersten kein Null-Byte ist n Byte von srcwird das Ergebnis nicht nullterminiert.

Ohne null etwas scheinbar Unschuldiges zu beenden wie:

   printf( "FOO: %s\n", dest );

…könnte abstürzen.

Gibt es bessere und sicherere Alternativen zu strncpy()?

strncpy() ist nicht als Safer gedacht strcpy()es soll verwendet werden, um eine Saite in die Mitte einer anderen einzufügen.

Alle diese “sicheren” String-Handling-Funktionen wie z snprintf() und vsnprintf() sind Korrekturen, die in späteren Standards hinzugefügt wurden, um Pufferüberlauf-Exploits usw.

Wikipedia erwähnt strncat() als Alternative zum Schreiben eines eigenen Safes strncpy():

*dst="\0";
strncat(dst, src, LEN);

BEARBEITEN

das habe ich vermisst strncat() überschreitet LEN Zeichen, wenn null die Zeichenfolge beendet, wenn sie länger oder gleich LEN Zeichen ist.

Wie auch immer, der Punkt der Verwendung strncat() Anstelle einer selbst entwickelten Lösung wie z memcpy(..., strlen(...))/Was ist das die Implementierung von strncat() kann in der Bibliothek ziel-/plattformoptimiert sein.

Natürlich müssen Sie überprüfen, ob dst mindestens das Nullzeichen enthält, also die korrekte Verwendung von strncat() wäre so etwas wie:

if (LEN) {
    *dst="\0"; strncat(dst, src, LEN-1);
}

Das gebe ich auch zu strncpy() ist nicht sehr nützlich, um einen Teilstring in einen anderen String zu kopieren, wenn die Quelle kürzer als n Zeichen ist, wird der Zielstring abgeschnitten.

Ursprünglich die 7. Ausgabe UNIX Dateisystem (siehe DIR(5)) hatte Verzeichniseinträge, die Dateinamen auf 14 Byte begrenzten; Jeder Eintrag in einem Verzeichnis bestand aus 2 Bytes für die Inode-Nummer plus 14 Bytes für den Namen, auf 14 Zeichen mit Null aufgefüllt, aber nicht unbedingt mit Null abgeschlossen. Das ist meine Überzeugung strncpy() wurde entwickelt, um mit diesen Verzeichnisstrukturen zu arbeiten – oder zumindest funktioniert es perfekt für diese Struktur.

In Betracht ziehen:

• Ein Dateiname mit 14 Zeichen wurde nicht nullterminiert.
• Wenn der Name kürzer als 14 Bytes war, wurde er mit Nullen auf die volle Länge (14 Bytes) aufgefüllt.

Genau das würde erreicht werden durch:

strncpy(inode->d_name, filename, 14);

So, strncpy() wurde ideal an seine ursprüngliche Nischenanwendung angepasst. Es ging nur zufällig darum, Überläufe von nullterminierten Strings zu verhindern.

(Beachten Sie, dass das Auffüllen mit Nullen bis zur Länge 14 kein ernsthafter Overhead ist – wenn die Länge des Puffers 4 KB beträgt und Sie nur 20 Zeichen sicher hineinkopieren möchten, dann sind die zusätzlichen 4075 Nullen ein ernsthafter Overkill und können leicht passieren zu quadratischem Verhalten führen, wenn Sie einem langen Puffer wiederholt Material hinzufügen.)

Es gibt bereits Open-Source-Implementierungen wie strlcpy die sicher kopieren.

http://en.wikipedia.org/wiki/Strlcpy

In den Literaturhinweisen befinden sich Links zu den Quellen.

Strncpy ist sicherer gegen Stapelüberlaufangriffe durch die Benutzer Ihres Programms, es schützt Sie nicht vor Fehlern Sie der Programmierer, z. B. das Drucken einer nicht nullterminierten Zeichenfolge, wie Sie es beschrieben haben.

Sie können einen Absturz aufgrund des von Ihnen beschriebenen Problems vermeiden, indem Sie die Anzahl der von printf gedruckten Zeichen begrenzen:

char my_string[10];
//other code here
printf("%.9s",my_string); //limit the number of chars to be printed to 9

Einige neue Alternativen sind in ISO/IEC TR 24731 (Check https://buildsecurityin.us-cert.gov/daisy/bsi/articles/knowledge/coding/317-BSI.html zur Info). Die meisten dieser Funktionen verwenden einen zusätzlichen Parameter, der die maximale Länge der Zielvariablen angibt, sicherstellen, dass alle Zeichenfolgen nullterminiert sind und Namen haben, die auf enden _s (für “sicher” ?), um sie von ihren früheren “unsicheren” Versionen zu unterscheiden.¹

Leider werden sie immer noch unterstützt und sind möglicherweise nicht mit Ihrem speziellen Toolset verfügbar. Spätere Versionen von Visual Studio geben Warnungen aus, wenn Sie die alten unsicheren Funktionen verwenden.

Wenn Ihre Werkzeuge nicht die neuen Funktionen unterstützen, sollte es ziemlich einfach sein, eigene Wrapper für die alten Funktionen zu erstellen. Hier ist ein Beispiel:

errCode_t strncpy_safe(char *sDst, size_t lenDst,
                       const char *sSrc, size_t count)
{
    // No NULLs allowed.
    if (sDst == NULL  ||  sSrc == NULL)
        return ERR_INVALID_ARGUMENT;

   // Validate buffer space.
   if (count >= lenDst)
        return ERR_BUFFER_OVERFLOW;

   // Copy and always null-terminate
   memcpy(sDst, sSrc, count);
   *(sDst + count) = '\0';

   return OK;
}

Sie können die Funktion an Ihre Bedürfnisse anpassen, um beispielsweise immer so viel wie möglich vom String zu kopieren, ohne dass es zu einem Überlauf kommt. Tatsächlich kann die VC++-Implementierung dies tun, wenn Sie bestehen _TRUNCATE als die count.

¹Natürlich müssen Sie die Größe des Zielpuffers immer noch genau angeben: Wenn Sie einen 3-Zeichen-Puffer angeben, sagen Sie es strcpy_s() Es hat Platz für 25 Zeichen, Sie haben immer noch Probleme.

Verwenden strlcpy()hier angegeben: http://www.courtesan.com/todd/papers/strlcpy.html

Wenn Ihre libc keine Implementierung hat, versuchen Sie es mit dieser:

size_t strlcpy(char* dst, const char* src, size_t bufsize)
{
  size_t srclen =strlen(src);
  size_t result =srclen; /* Result is always the length of the src string */
  if(bufsize>0)
  {
    if(srclen>=bufsize)
       srclen=bufsize-1;
    if(srclen>0)
       memcpy(dst,src,srclen);
    dst[srclen]='\0';
  }
  return result;
}

(Geschrieben von mir im Jahr 2004 – der Gemeinfreiheit gewidmet.)

Anstatt von strncpy()Du könntest benutzen

snprintf(buffer, BUFFER_SIZE, "%s", src);

Hier ist ein Einzeiler, der höchstens kopiert size-1 Nicht-Null-Zeichen von src zu dest und fügt ein Null-Terminator hinzu:

static inline void cpystr(char *dest, const char *src, size_t size)
{ if(size) while((*dest++ = --size ? *src++ : 0)); }