È possibile sfruttare una funzione vulnerabile se il suo input è sicuro?

Question

supponga che ho un codice avente Buffer Overflow come seguendo

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

    if(len >= 100){ 
     return -1; 
    } 
    strncpy(buffer,str,strlen(str)); 
    return 0; 
} 

(presi da questo question)

C'è un modo per sfruttare questa vulnerabilità se ricevendo input da un'altra funzione (non input dell'utente) e la lunghezza di str è sempre inferiore a 100?

Per esempio

int main() { 
    int user_input; 
    if (cin >> user_input) { 
     if(user_input == 1) 
      func("aaaa"); 
     else 
      func("bbbb"); 
    } 
} 

Assumere non c'è altra vulnerabilità nel codice.

Solo una domanda ipotetica, qualche idea?

Answer 1

In breve, non c'è vulnerabilità. Ogni input è sanificato = nessuna vulnerabilità.

Ma questo non significa che dovresti lasciarlo non risolto. Sebbene non vi sia alcuna vulnerabilità fisica, esiste una notevole quantità di potenziale per una vulnerabilità. Ora non si passa più di 100 caratteri. Ma per quanto riguarda alcuni mesi da ora in poi? Ricorderai che puoi passare solo l'input più corto di 100 caratteri? Io non la penso così

È possibile risolvere il problema da:

1. scegliendo di tenere strlen in size_t (ma questo non sarà aggirare buffer overflow se la variabile è più lunga di 4 GB)
2. utilizzando un buffer allocato in modo dinamico e controllando se si riuscito a malloc con successo
3. usando strnlen insieme sizeof(buffer) piuttosto che strlen
4. passando len come secondo parametro (probabilmente fastidioso)

L'utilizzo di strncpy(a, b, strlen(b)) corrisponde a strcpy(a,b). Ciò è in qualche modo impedito con il controllo nell'istruzione if, ma la scelta dello unsigned short per la sua memorizzazione lo rende comunque inutile. È inoltre preferibile utilizzare strncpy(a, b, len) per rendere evidente che len deve essere presente, nel caso in cui il controllo venga rimosso di nuovo.