Perché questo codice è vulnerabile agli attacchi di overflow del buffer?

int func(char* str)
{
   char buffer[100];
   unsigned short len = strlen(str);

   if(len >= 100)
   {
        return (-1);
   }

   strncpy(buffer,str,strlen(str));
   return 0;
}

Questo codice è vulnerabile a un attacco di overflow del buffer e sto cercando di capire perché. Sto pensando che abbia a che fare con l' lenessere dichiarato un shortanziché un int, ma non ne sono davvero sicuro.

Qualche idea?

Sulla maggior parte dei compilatori il valore massimo di an unsigned shortè 65535.

Qualsiasi valore sopra che viene racchiuso, quindi 65536 diventa 0 e 65600 diventa 65.

Ciò significa che lunghe stringhe della giusta lunghezza (ad es. 65600) supereranno il controllo e trabocceranno il buffer.

Utilizzare size_tper archiviare il risultato di strlen(), non unsigned shorte confrontarlo lencon un'espressione che codifica direttamente la dimensione di buffer. Quindi per esempio:

char buffer[100];
size_t len = strlen(str);
if (len >= sizeof(buffer) / sizeof(buffer[0]))  return -1;
memcpy(buffer, str, len + 1);

Il problema è qui:

strncpy(buffer,str,strlen(str));
                   ^^^^^^^^^^^

Se la stringa è maggiore della lunghezza del buffer di destinazione, strncpy lo copierà comunque. Si sta basando il numero di caratteri della stringa come numero da copiare anziché la dimensione del buffer. Il modo corretto per farlo è il seguente:

strncpy(buffer,str, sizeof(buff) - 1);
buffer[sizeof(buff) - 1] = '\0';

Quello che fa è limitare la quantità di dati copiati alla dimensione effettiva del buffer meno uno per il carattere che termina null. Quindi impostiamo l'ultimo byte nel buffer sul carattere null come protezione aggiuntiva. La ragione di ciò è perché strncpy copierà fino a n byte, incluso il null di terminazione, se strlen (str) <len - 1. In caso contrario, il null non viene copiato e si ha uno scenario di crash perché ora il buffer ha un terminale non terminato corda.

Spero che questo ti aiuti.

EDIT: dopo ulteriori esami e input da altri, segue una possibile codifica per la funzione:

int func (char *str)
  {
    char buffer[100];
    unsigned short size = sizeof(buffer);
    unsigned short len = strlen(str);

    if (len > size - 1) return(-1);
    memcpy(buffer, str, len + 1);
    buffer[size - 1] = '\0';
    return(0);
  }

Dato che conosciamo già la lunghezza della stringa, possiamo usare memcpy per copiare la stringa dalla posizione a cui fa riferimento str nel buffer. Nota che nella pagina del manuale di strlen (3) (su un sistema FreeBSD 9.3), è indicato quanto segue:

 The strlen() function returns the number of characters that precede the
 terminating NUL character.  The strnlen() function returns either the
 same result as strlen() or maxlen, whichever is smaller.

Ciò che interpreto è che la lunghezza della stringa non include il null. Questo è il motivo per cui copio len + 1 byte per includere il valore null e il test verifica che la lunghezza <dimensione del buffer - 2. Meno uno perché il buffer inizia nella posizione 0 e meno un altro per assicurarsi che ci sia spazio per il null.

EDIT: Si scopre che la dimensione di qualcosa inizia con 1 mentre l'accesso inizia con 0, quindi -2 prima non era corretto perché avrebbe restituito un errore per qualcosa> 98 byte ma dovrebbe essere> 99 byte.

EDIT: Sebbene la risposta su un short senza segno sia generalmente corretta poiché la lunghezza massima che può essere rappresentata è di 65.535 caratteri, non importa davvero perché se la stringa è più lunga, il valore andrà a capo. È come prendere 75.231 (che è 0x000125DF) e mascherare i primi 16 bit che ti danno 9695 (0x000025DF). L'unico problema che vedo con questo è i primi 100 caratteri oltre 65.535 poiché il controllo di lunghezza consentirà la copia, ma copierà fino ai primi 100 caratteri della stringa in tutti i casi e termina null la stringa . Quindi, anche con il problema avvolgente, il buffer non verrà comunque traboccato.

Questo può di per sé o meno costituire un rischio per la sicurezza a seconda del contenuto della stringa e del motivo per cui la si sta utilizzando. Se è solo un testo semplice che è leggibile dall'uomo, in genere non ci sono problemi. Ottieni solo una stringa troncata. Tuttavia, se si tratta di qualcosa di simile a un URL o addirittura a una sequenza di comandi SQL, potresti avere un problema.

Anche se stai usando strncpy, la lunghezza del taglio dipende ancora dal puntatore della stringa passata. Non hai idea di quanto sia lunga quella stringa (la posizione del terminatore null rispetto al puntatore, cioè). Quindi chiamare strlenda solo ti apre alla vulnerabilità. Se vuoi essere più sicuro, usa strnlen(str, 100).

Il codice completo corretto sarebbe:

int func(char *str) {
   char buffer[100];
   unsigned short len = strnlen(str, 100); // sizeof buffer

   if (len >= 100) {
     return -1;
   }

   strcpy(buffer, str); // this is safe since null terminator is less than 100th index
   return 0;
}

La risposta con la confezione è corretta. Ma c'è un problema che penso non sia stato menzionato se (len> = 100)

Bene, se Len fosse 100, avremmo copiato 100 elementi e non avremmo trascinato \ 0. Ciò significherebbe chiaramente che qualsiasi altra funzione, a seconda della stringa corretta, andrebbe ben oltre l'array originale.

La stringa problematica di C è IMHO irrisolvibile. Faresti sempre meglio ad avere dei limiti prima della chiamata, ma anche questo non ti aiuterà. Non c'è controllo dei limiti e quindi gli overflow del buffer possono sempre e purtroppo accadranno ....

Al di là dei problemi di sicurezza legati alla chiamata strlenpiù di una volta, in genere non si dovrebbero usare metodi di stringa su stringhe la cui lunghezza è nota con precisione [per la maggior parte delle funzioni di stringa, esiste solo un caso molto ristretto in cui dovrebbero essere usati - su stringhe per le quali un massimo la lunghezza può essere garantita, ma la lunghezza precisa non è nota]. Una volta che la lunghezza della stringa di input è nota e la lunghezza del buffer di output è nota, si dovrebbe capire quanto una regione deve essere copiata e quindi utilizzare memcpy()per eseguire effettivamente la copia in questione. Sebbene sia possibile che si verifichino strcpyprestazioni superiori memcpy()quando si copia una stringa di solo 1-3 byte o giù di lì, su molte piattaforme memcpy()è probabile che sia più del doppio rispetto alle stringhe più grandi.

Sebbene ci siano alcune situazioni in cui la sicurezza verrebbe a scapito delle prestazioni, questa è una situazione in cui l'approccio sicuro è anche quello più veloce. In alcuni casi, può essere ragionevole scrivere un codice che non è sicuro contro input che si comportano in modo strano, se il codice che fornisce gli input può garantire che siano ben educati e se la protezione da input maleducati ostacolerebbe le prestazioni. Garantire che le lunghezze delle stringhe siano controllate solo una volta migliora sia le prestazioni che la sicurezza, anche se è possibile fare qualcosa in più per proteggere la sicurezza anche quando si traccia manualmente la lunghezza delle stringhe: per ogni stringa che dovrebbe avere un null finale, scrivere esplicitamente il null finale piuttosto che aspettarsi che la stringa di origine l'abbia. Quindi, se uno scrivesse un strdupequivalente:

char *strdupe(char const *src)
{
  size_t len = strlen(src);
  char *dest = malloc(len+1);
  // Calculation can't wrap if string is in valid-size memory block
  if (!dest) return (OUT_OF_MEMORY(),(char*)0); 
  // OUT_OF_MEMORY is expected to halt; the return guards if it doesn't
  memcpy(dest, src, len);      
  dest[len]=0;
  return dest;
}

Si noti che l'ultima istruzione potrebbe generalmente essere omessa se memcpy avesse elaborato len+1byte, ma se un altro thread dovesse modificare la stringa di origine, il risultato potrebbe essere una stringa di destinazione non terminata con NUL.