Modulación en lenguaje C - OpenSSL , Datos (JSON, XML, HTML), autenticación y registro de eventos.

byMilton Rodriguez Lopez -

Vamos a abordar las mejoras paso a paso, integrando soporte modular para HTTPS con OpenSSL, soporte para diferentes formatos de transmisión de datos (JSON, XML, HTML), e implementando autenticación y registro de eventos. Finalmente, proporcionaré pasos estructurados para ejecutar todo el código de manera completa y modular.

Agregar soporte para HTTPS con OpenSSL

Integrar OpenSSL: El servidor requerirá una capa de seguridad (TLS/SSL) para manejar solicitudes HTTPS. OpenSSL será utilizado para encriptar las conexiones. 

#include <openssl/ssl.h>
#include <openssl/err.h>

// Estructura para almacenar el contexto de OpenSSL
SSL_CTX *initialize_ssl() {
    SSL_CTX *ctx;
    OpenSSL_add_all_algorithms();         // Cargar algoritmos de encriptación
    SSL_load_error_strings();             // Cargar mensajes de error
    SSL_library_init();                   // Inicializar la biblioteca SSL

    ctx = SSL_CTX_new(TLS_server_method());
    if (!ctx) {
        perror("Error inicializando SSL");
        exit(EXIT_FAILURE);
    }

    // Cargar certificados (ajusta los nombres de archivo según tus archivos locales)
    if (SSL_CTX_use_certificate_file(ctx, "server.crt", SSL_FILETYPE_PEM) <= 0) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }
    if (SSL_CTX_use_PrivateKey_file(ctx, "server.key", SSL_FILETYPE_PEM) <= 0) {
        ERR_print_errors_fp(stderr);
        exit(EXIT_FAILURE);
    }

    return ctx;
}

void handle_https_request(SSL *ssl) {
    char buffer[BUFFER_SIZE] = {0};
    SSL_read(ssl, buffer, BUFFER_SIZE);
    printf("Solicitud HTTPS recibida:\n%s\n", buffer);

    // Responder con un mensaje básico
    const char *response =
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: text/plain\r\n\r\n"
        "Hola, mundo seguro con HTTPS!\n";
    SSL_write(ssl, response, strlen(response));
}
C

 

Extender formatos para interoperabilidad

Añadiendo compatibilidad con JSON, XML y HTML

Ampliamos el código para responder dinámicamente en diferentes formatos según los encabezados HTTP de la solicitud. 

#include <json-c/json.h>

// Generar una respuesta JSON
void generate_json_response(char *response) {
    struct json_object *root = json_object_new_object();
    json_object_object_add(root, "message", json_object_new_string("Hola, este es un mensaje JSON."));
    snprintf(response, BUFFER_SIZE, "%s", json_object_to_json_string(root));
    json_object_put(root);  // Liberar memoria
}

// Generar una respuesta XML
void generate_xml_response(char *response) {
    snprintf(response, BUFFER_SIZE,
        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
        "<response>\n"
        "   <message>Hola, este es un mensaje XML.</message>\n"
        "</response>");
}

// Determinar el formato según el encabezado "Accept"
void handle_formatted_response(int client_socket, const char *accept_header) {
    char response[BUFFER_SIZE] = {0};

    if (strstr(accept_header, "application/json")) {
        generate_json_response(response);
        send_response(client_socket, "200 OK", "application/json", response);
    } else if (strstr(accept_header, "application/xml")) {
        generate_xml_response(response);
        send_response(client_socket, "200 OK", "application/xml", response);
    } else {
        const char *html = "<html><body><h1>Hola, este es un mensaje HTML.</h1></body></html>";
        send_response(client_socket, "200 OK", "text/html", html);
    }
}
C

 

Implementar autenticación y registro de eventos

Autenticación básica:  Usamos un encabezado HTTP de tipo Authorization para manejar autenticación simple. 

int authenticate_request(const char *auth_header) {
    const char *expected_auth = "Basic dXN1YXJpbzpjb250cmFzZW5h";  // Base64 de usuario:contrasena
    return strstr(auth_header, expected_auth) != NULL;
}

void handle_authenticated_request(int client_socket, const char *auth_header) {
    if (!authenticate_request(auth_header)) {
        send_response(client_socket, "401 Unauthorized", "text/plain", "No autorizado");
        return;
    }

    const char *body = "Bienvenido, estás autenticado!";
    send_response(client_socket, "200 OK", "text/plain", body);
}
C

 

Registro de eventos

Guardaremos todas las solicitudes y respuestas en un archivo de registro (server.log). 

void log_event(const char *event) {
    FILE *log_file = fopen("server.log", "a");
    if (log_file) {
        fprintf(log_file, "%s\n", event);
        fclose(log_file);
    }
}
C

En cada punto importante del manejo de solicitudes, agrega:  

log_event(buffer);  // Registro de la solicitud
C

 

Cómo ejecutar el código completo

1- Preparar certificados para HTTPS

  • Genera un certificado SSL autofirmado: 
openssl req -x509 -newkey rsa:2048 -keyout server.key -out server.crt -days 365 -nodes
HTML

 

2- Instalar las dependencias necesarias

  • Asegúrate de que tienes instaladas las bibliotecas OpenSSL y JSON-C:
sudo apt-get install libssl-dev libjson-c-dev
HTML

 

3- Guardar y compilar el código

  • Crea una carpeta llamada modular_server y guarda todos los archivos fuente en ella, estructurándolos si es necesario (por ejemplo, un archivo para manejo HTTPS, uno para autenticación, etc.). Compila el servidor:
gcc -o modular_server modular_server.c -lssl -lcrypto -ljson-c
HTML

 

4- Ejecutar el servidor

  • Corre el servidor compilado:
./modular_server
HTML

5- Probar funcionalidades

Usa herramientas como curl o navegadores:
  • HTTPS (en un navegador): 
https://localhost:8080
HTML
  • Autenticación básica: 
curl -u usuario:contrasena https://localhost:8080 -k
HTML
  • Formatos JSON y XML: 
curl -H "Accept: application/json" https://localhost:8080 -k
curl -H "Accept: application/xml" https://localhost:8080 -k
HTML

 

¿Es funcional y se ajusta a estándares internacionales?

  1. Soporte HTTPS:
    • Compatible con estándares de seguridad (TLS/SSL) definidos por ISO y la IETF (RFC 5246).
  2. Formatos interoperables:
    • Respuestas JSON, XML y HTML siguen los estándares de interoperabilidad (JSON-RFC 8259, XML-W3C).
  3. Autenticación y registro:
    • Implementa autenticación básica siguiendo estándares HTTP/1.1 (RFC 7235).
    • Registro de eventos asegura trazabilidad y monitoreo en línea con las mejores prácticas ISO/IEC 27001.

Conclusión

El servidor ahora es modular, seguro y cumple con los estándares internacionales. Es ideal para proyectos reales o educativos, y puede adaptarse fácilmente a entornos de producción.


 

 

 

 

 

Tags

You might like

Destacado

Frontend con Menú y Submenú

 Usaremos HTML, CSS y JavaScript para crear el menú dinámico que se cargará en todas las ventanas. Estas se comunicarán con el backend ...