El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Consideraciones de Seguridad

Siguiente ►
►

La seguridad en la programación es un aspecto crucial que no debe ser subestimado. En este módulo, abordaremos las mejores prácticas y técnicas para escribir código seguro en C, un lenguaje conocido por su potencia y flexibilidad, pero también por sus vulnerabilidades si no se maneja adecuadamente.

Conceptos Clave

  1. Desbordamiento de Buffer: Ocurre cuando se escribe más datos en un buffer de los que puede contener, lo que puede sobrescribir la memoria adyacente.
  2. Inyección de Código: Se refiere a la inserción de código malicioso en un programa, generalmente a través de entradas no validadas.
  3. Gestión de Memoria: La correcta asignación y liberación de memoria es crucial para evitar fugas de memoria y otros problemas.
  4. Validación de Entradas: Asegurarse de que todas las entradas del usuario sean validadas y sanitizadas para evitar ataques.
  5. Manejo de Errores: Implementar un manejo de errores robusto para evitar que el programa se comporte de manera inesperada.

Desbordamiento de Buffer

Ejemplo de Desbordamiento de Buffer

#include <stdio.h>
#include <string.h>

void vulnerableFunction(char *str) {
    char buffer[10];
    strcpy(buffer, str); // Copia sin verificar el tamaño
    printf("Buffer: %s\n", buffer);
}

int main() {
    char largeString[20] = "ThisIsTooLong";
    vulnerableFunction(largeString);
    return 0;
}

Explicación

En el ejemplo anterior, strcpy copia largeString en buffer sin verificar si buffer tiene suficiente espacio. Esto puede sobrescribir la memoria adyacente, causando un comportamiento inesperado o incluso permitiendo la ejecución de código malicioso.

Solución

Utiliza funciones seguras como strncpy:

#include <stdio.h>
#include <string.h>

void secureFunction(char *str) {
    char buffer[10];
    strncpy(buffer, str, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0'; // Asegura la terminación nula
    printf("Buffer: %s\n", buffer);
}

int main() {
    char largeString[20] = "ThisIsTooLong";
    secureFunction(largeString);
    return 0;
}

Inyección de Código

Ejemplo de Inyección de Código

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

void executeCommand(char *command) {
    char buffer[50];
    sprintf(buffer, "ls %s", command);
    system(buffer);
}

int main() {
    char userInput[20];
    printf("Enter directory: ");
    scanf("%s", userInput);
    executeCommand(userInput);
    return 0;
}

Explicación

El código anterior es vulnerable a la inyección de comandos. Un usuario malintencionado podría ingresar algo como ; rm -rf / para ejecutar comandos adicionales.

Solución

Valida y sanitiza las entradas del usuario:

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

void executeCommand(char *command) {
    char buffer[50];
    if (strstr(command, ";") == NULL && strstr(command, "&") == NULL) {
        snprintf(buffer, sizeof(buffer), "ls %s", command);
        system(buffer);
    } else {
        printf("Invalid input detected.\n");
    }
}

int main() {
    char userInput[20];
    printf("Enter directory: ");
    scanf("%19s", userInput); // Limita la entrada a 19 caracteres
    executeCommand(userInput);
    return 0;
}

Gestión de Memoria

Ejemplo de Fuga de Memoria

#include <stdlib.h>

void memoryLeak() {
    int *ptr = (int *)malloc(sizeof(int) * 10);
    // No se libera la memoria
}

int main() {
    memoryLeak();
    return 0;
}

Solución

Asegúrate de liberar la memoria asignada:

#include <stdlib.h>

void noMemoryLeak() {
    int *ptr = (int *)malloc(sizeof(int) * 10);
    // Uso de la memoria
    free(ptr); // Liberar la memoria
}

int main() {
    noMemoryLeak();
    return 0;
}

Validación de Entradas

Ejemplo de Validación de Entradas

#include <stdio.h>

int main() {
    int age;
    printf("Enter your age: ");
    if (scanf("%d", &age) != 1) {
        printf("Invalid input.\n");
        return 1;
    }
    if (age < 0 || age > 120) {
        printf("Age out of range.\n");
        return 1;
    }
    printf("Your age is %d\n", age);
    return 0;
}

Explicación

El código anterior valida que la entrada sea un número entero y que esté dentro de un rango razonable.

Manejo de Errores

Ejemplo de Manejo de Errores

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

int main() {
    FILE *file = fopen("nonexistent.txt", "r");
    if (file == NULL) {
        perror("Error opening file");
        return 1;
    }
    // Operaciones con el archivo
    fclose(file);
    return 0;
}

Explicación

El uso de perror proporciona un mensaje de error detallado si fopen falla.

Resumen

En esta sección, hemos cubierto varias consideraciones de seguridad importantes al programar en C:

  • Desbordamiento de Buffer: Utiliza funciones seguras y verifica los tamaños de los buffers.
  • Inyección de Código: Valida y sanitiza todas las entradas del usuario.
  • Gestión de Memoria: Asegúrate de liberar toda la memoria asignada.
  • Validación de Entradas: Verifica que las entradas del usuario sean válidas y estén dentro de los rangos esperados.
  • Manejo de Errores: Implementa un manejo de errores robusto para evitar comportamientos inesperados.

Estas prácticas te ayudarán a escribir código más seguro y robusto, protegiendo tus aplicaciones de posibles vulnerabilidades y ataques.

◄ Anterior
◄
Siguiente ►
►

Curso de Programación en C

Módulo 1: Introducción a C

Módulo 2: Tipos de Datos y Variables

Módulo 3: Flujo de Control

Módulo 4: Funciones

Módulo 5: Arreglos y Cadenas

Módulo 6: Punteros

Módulo 7: Estructuras y Uniones

Módulo 8: Asignación Dinámica de Memoria

Módulo 9: Manejo de Archivos

Módulo 10: Temas Avanzados

Módulo 11: Mejores Prácticas y Optimización

Módulo 12: Proyecto y Evaluación Final

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados