In che modo questo frammento C può essere scritto in modo più sicuro?

Question

Ho il seguente frammento di codice C e devono identificare l'errore e suggerire un modo di scriverlo in modo più sicuro:

char somestring[] = "Send money!\n"; 
char *copy; 

copy = (char *) malloc(strlen(somestring)); 

strcpy(copy, somestring); 
printf(copy); 

Quindi l'errore è che strlen ignora la finale '\0' di una stringa e quindi non è verrà assegnata una quantità di memoria sufficiente per la copia, ma non sono sicuro di cosa stiano per scrivere in modo più sicuro?

Potrei semplicemente usare malloc(strlen(somestring)+1)) presumo ma sto pensando che ci deve essere un modo migliore di quello?

---

EDIT: OK, ho accettato una risposta, ho il sospetto che la soluzione strdup non ci si aspetterebbe da noi perché non è parte di ANSI C. Sembra essere un bel questione soggettiva così ho non sono sicuro che quello che ho accettato sia effettivamente il migliore Grazie comunque per tutte le risposte.

Answer 1

char somestring[] = "Send money!\n"; 
char *copy; 
size_t copysize; 

copysize = strlen(somestring)+1; 
copy = (char *) malloc(copysize); 
if (copy == NULL) 
    bail("Oh noes!\n"); 

strncpy(copy, somestring, copysize); 
printf("%s", copy); 

differenze osservato in precedenza:

• Risultato di malloc() devono essere controllati!
• Compute e store la dimensione della memoria!
• Utilizzare strncpy() perché strcpy() è cattivo. In questo esempio inventato non farà male, ma non prendere l'abitudine di usarlo.

EDIT:

A quelli pensando dovrei usare strdup() ... che funziona solo se si prende il punto di vista molto più stretta della domanda. Questo non è solo stupido, è che si affaccia una risposta ancora migliore:

char somestring[] = "Send money!\n"; 
char *copy = somestring; 
printf(copy); 

Se avete intenzione di essere ottusi, almeno essere bravo a farlo.

Answer 2

char somestring[] = "Send money!\n"; 
char *copy = strdup(something); 

if (copy == NULL) { 
    // error 
} 

o semplicemente mettere questa logica in una funzione separata xstrdup:

char * xstrdup(const char *src) 
{ 
    char *copy = strdup(src); 

    if (copy == NULL) { 
     abort(); 
    } 

    return copy; 
} 

Answer 3

Il modo più sicuro sarebbe usare strncpy anziché strcpy. Quella funzione prende un terzo argomento: la lunghezza della stringa da copiare. Questa soluzione non si estende oltre ANSI C, quindi funzionerà in tutti gli ambienti (mentre altri metodi possono funzionare solo con sistemi conformi a POSIX).

char somestring[] = "Send money!\n"; 
char *copy; 

copy = (char *) malloc(strlen(somestring)); 

strncpy(copy, somestring, strlen(somestring)); 
printf(copy); 

Answer 4

1. strlen + 1, per il \ 0 terminatore
2. malloc potrebbe non riuscire; controllare sempre il valore di ritorno malloc

Answer 5

Il modo migliore per scrivere in modo più sicuro, se si fosse veramente interessati a una cosa del genere, sarebbe di scriverlo in Ada.

somestring : constant string := "Send money!"; 
declare 
    copy : constant string := somestring; 
begin 
    put_line (somestring); 
end; 

Stesso risultato, quindi quali sono le differenze?

• Il tutto viene eseguito nello stack (senza riferimenti). La deallocazione è automatica e sicura.
• Tutto è automaticly gamma-controllati in modo non c'è alcuna possibilità di buffer-overflow exploit
• entrambe le stringhe sono costanti, quindi non c'è alcuna possibilità di avvitamento e comandate.
• Sarà probabilmente il modo più veloce di rispetto alla C, non solo per la mancanza di allocazione dinamica, ma perché non c'è quella scansione extra attraverso la stringa richiesta da strlen().

Si noti che in Ada "stringa" non è un particolare costrutto dinamico. È la matrice di caratteri incorporata. Tuttavia, gli array Ada possono essere dimensionati in base alla dichiarazione dall'array che si assegna loro.

Answer 6

Ick ... strdup() utilizzare come tutti gli altri detto e scrivere voi stessi se si deve. Dal momento che si ha il tempo di pensare a questo ora ... controllare il 25 Most Dangerous Programming Errors at Mitre, quindi prendere in considerazione il motivo per cui la frase printf(copy) dovrebbe mai appaiono nel codice. Proprio qui con malloc(strlen(str)) in termini di assoluta cattiveria per non parlare del mal di testa di rintracciare perché causa un sacco di dolore quando la copia è qualcosa come "%s%n" ...

Answer 7

Non posso commentare le risposte sopra, ma oltre a controllare il codice ritorno e utilizzando strncpy, non si dovrebbe mai fare:

printf(string) 

Ma utilizzare:

printf("%s", string); 

ref: http://en.wikipedia.org/wiki/Format_string_attack

Answer 8

Vorrei commentare le soluzioni precedenti ma non ho abbastanza rep. Utilizzando strncpy qui è così sbagliato come utilizzare strcpy (Poiché non v'è assolutamente alcun rischio di overflow). C'è una funzione chiamata memcpy in < string.h> ed è pensato proprio per questo. Non è solo molto più veloce, ma anche la funzione corretto da utilizzare per copiare le stringhe di lunghezza nota in serie C.

Dalla risposta accettata:

char somestring[] = "Send money!\n"; 
char *copy; 
size_t copysize; 

copysize = strlen(somestring)+1; 
copy = (char *) malloc(copysize); 
if (copy == NULL) 
    bail("Oh noes!\n"); 

memcpy(copy, somestring, copysize); /* You don't use str* functions for this! */ 
printf("%s", copy); 

Answer 9

modi per rendere il codice più sicuro (e più corretto).

1. Non eseguire una copia non necessaria. Dall'esempio, non è apparentemente richiesto che sia effettivamente necessario copiare somestring. Puoi farlo direttamente.
2. Se si deve fare una copia di una stringa, scrivere una funzione per farlo (o utilizzare strdup se lo avete). Quindi devi solo farlo in un posto.
3. Se possibile, inizializzare il puntatore sulla copia immediatamente quando lo si dichiara.
4. Ricordarsi di allocare spazio per il terminatore null.
5. Ricordarsi di verificare il valore restituito da malloc.
6. Ricordarsi di liberare la memoria di malloc.
7. Non chiamare printf con una stringa di formato non attendibile. Utilizzare printf("%s", copy) o puts(copy).
8. Utilizzare un linguaggio orientato agli oggetti con una classe stringa o qualsiasi lingua con supporto stringa incorporato per evitare la maggior parte di questi problemi.

Answer 10

ad aggiungere di più per le vie di Adrian McCarthy per rendere il codice più sicuro,

Utilizzare un analizzatore di codice statico, sono molto bravo a trovare questo tipo di errori