C(++)

• gets(char *str): Esta función NO comprueba la longitud del string; al asignar los datos a un array que es de una longitud menor, produce un desbordamiento del búfer. Al hacerlo con uno de mayor longitud, llena todos los espacios restantes con 0 desperdiciando memoria.
  

  SpoilerCódigo de demostración Code C 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <stdio.h> #include <stdlib.h> int main(void){ char usuario[8]; int permitir = 0; printf("Introduce tu nombre de usuario: "); gets(usuario); // el usuario introduce 'malicioso' if(concederAcceso(usuario)){ permitir = 1; } if(permitir != 0){ // se han sobreescrito datos por el desbordamiento de usuario accionPrivilegiada(); } return EXIT_SUCCESS; }

  
  En este caso es preferible usar fgets(char *str, int n, FILE *stream) y memoria dinámica; en el cual n correspondería al límite de lectura (si antes no encuentra \n, \0 o EOF) y *stream correspondería al puntero con la dirección de la que deben de extraerse los datos [stdin para este caso].
  
• strcpy(char *dest, const char *src): Al igual que gets, no realiza una comprobación de la longitud del string y el error se puede cometer de la misma forma, de hecho, toda su familia de funciones (strcmp, strcat) también lo es por la misma vía. El primer argumento corresponde a un puntero con dirección al destino y el segundo a un puntero constante con dirección a la fuente de la que provienen los datos.
  
  En este caso es preferible usar la familia strl-, o la familia strn, que incluyen al final una variable size_t que corresponde al tamaño de los datos. La familia strn no copia el carácter nulo '\0'.
• sprintf(char *str, const char *format, ...): Igual que las otras dos, no realiza comprobación de la longitud del string, dando lugar a desbordamientos al formatear el string.
  

  SpoilerCódigo de demostración Code C 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <stdio.h> #include <stdlib.h> enum{ BUFFER_SIZE = 10 }; int main(void){ char buffer[BUFFER_SIZE]; int check = 0; sprintf(buffer, "%s", "Este string es realmente largo..."); printf("check: %d", check); /* No va a imprimir 0 */ return EXIT_SUCCESS; }

  
  
  La solución es usar snprintf(char *str, size_t size, const char *format, ...); que evita desbordamiento de búfer al descartar el exceso y además retorna en valor de entero el tamaño del string formateado, con lo que se pueden realizar excepciones que comprueben si el tamaño del string introducido era mayor al límite.

• Toda la familia de printf: Aquí entran los ataques al formateo de datos. Datos que normalmente serían privados, propios del programa e inaccesible por otros, pueden ser accedidos al llamar a la función de forma externa. Este es un gran fallo de seguridad.
  
  La solución es ser muy riguroso al momento de realizar el formateo de datos y evitar en lo posible la entrada de datos por parte del usuario a estas funciones.
• Toda la familia de scanf:
Esta función es muy peculiar, fue hecha para recolectar del búfer de entrada una gran variedad de datos, desde los tipos básicos hasta valores científicos. Esto es bueno... ¿no? Es lo que en el curso te dijeron que debías de usar... Es funcional, pero peligrosa.



SpoilerCómo crashear a un programa en un par de líneas Code C 1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> #include <stdlib.h> int main(void) { int a; printf("Introduce un numero: "); scanf("%d", &a); printf("Haz introducido %d.\n", a); return EXIT_SUCCESS; }


Ejecutas el programa:


a dit :

Introduce un numero: 42
Haz introducido 42.



Todo bien. Se realiza la conversión de un doble flotante a un entero. ¿Qué tal si introducimos un tipo distinto?



a dit :

Introduce un numero: sfadsfadsddads
Haz introducido 2583.



¿¡Qué está ocurriendo aquí!? Scanf intenta realizar la conversión, pero al no haber ningún número, convierte a nada. El valor de a nunca se define, por lo que la variable tendrá un comportamiento indefinido.

El comportamiento indefinido de una función o una variable es peligroso, porque al momento de utilizarla podría no funcionar como uno espera. Podría no ocurrir sólo esto, sino también que el programa se crashee. Esto en otros lenguajes se evita ya que no se ejecuta el código a menos que cada tipo se defina de alguna forma.

Scanf verifica en el string con los argumentos formateados, "%d", si en búfer no se encuentra ningún número, pasará de cualquier otro tipo y convertirá a nada, pues el valor a convertir no fue definido.

Scanf retorna la cantidad de elementos convertidos satisfactoriamente, con eso sería suficiente, ¿no? Podríamos hacer que no pare de escanear hasta que los argumentos correctos se introduzcan,
Code C

---

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
#include <stdlib.h>

int main(void){
    int a;
    printf("Introduce un numero: ");
    while(scanf("%d", &a) != 1){
        // la entrada no fue un número? pregunta de nuevo:
        printf("Introduce un numero: ");
    }
    printf("Introduciste %d.\n", a);

    return EXIT_SUCCESS;
}

hasta que...


a dit :

Introduce un numero: asd Introduce un numero: Introduce un numero: Introduce un numero: Introduce un numero: Introduce un numero: Introduce un numero: Introduce un numero: Introduce un numero: Introduce un numero: ^Z



¡Oh por Glob! ¿Qué pasó? Scanf no fue hecha para leer entrada sino para ESCANEARLA. Scanf nunca leerá algo que no se le ha mandado a escanear. asd no es un número, por lo que ni siquiera será escaneado, por lo que, Scanf irá nuevamente al búfer de entrada y se encontrará con lo mismo, entrando en un bucle infinito de escaneos fallidos.

Podríamos limpiar el búfer de entrada con fflush(stdin);... No. Es una terrible práctica, primero porque no todos los sistemas lo harán, y segundo, porque aunque se pueda hacer en algunos, el comportamiento del búfer de entrada quedará indeterminado, algo que ya hace saltar alarmas.

Pero... ¿qué pasa si intentamos escanear un string? (reemplaza la "%d" por una "%s")

Tenemos una variable de string de 10 de tamaño, introducimos datos y el scanf se encsrga de escanearlo:


a dit :

Introduce un string: hola! 123
Salida: hola! 123




a dit :

Introduce un string: Hipopotomonstrosesquipedaliofobia


...

El string ha producido un desbordamiento del búfer, bien el programa podría crashear, avisar de un fallo de segmentación o funcionar "correctamente". El comportamiento es indeterminado en el momento en el que el desbordamiento se realiza. Una forma de arreglar esto es determinar en el scanf la cantidad que debe de leer, siendo en vez de "%s", utilizar %Ns", en el que N es la cantidad de caracteres.

Si sólo se quiere leer entrada, bien puede usarse fgets y realizar una función propia. Hay varias funciones incorporadas en la biblioteca estándar que permiten la conversión de unos tipos a otros.

Scanf es una función que de la forma adecuada, puede llegar a ser bastante poderosa. Hay que saber usarla de la forma correcta.

int main(void){
    int a = 5, b = 11;
    char c = a*b;

    putc(c, stdout);
}

    c *= 2;

    double d = 0.08;
    c /= b / d;