Autenticación Básica en Servidores Web

Implementa sistemas de autenticación seguros en servidores web ESP32 para proteger el acceso a recursos y funciones críticas.

Módulo 9 Seguridad

Fundamentos de Autenticación Básica

HTTP Basic Auth

Método de autenticación que utiliza credenciales codificadas en Base64 en el header HTTP Authorization.

Credenciales Seguras

Gestión y validación de nombres de usuario y contraseñas para control de acceso.

Servidor Protegido

Implementación de rutas protegidas que requieren autenticación antes de permitir el acceso.

Implementación Básica de Autenticación

Servidor Web con Autenticación Básica

#include 
#include 

const char* ssid = "TU_WIFI";
const char* password = "TU_PASSWORD";
const char* auth_user = "admin";
const char* auth_pass = "esp32secure";

AsyncWebServer server(80);

void setup() {
  Serial.begin(115200);
  
  // Conectar a WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando a WiFi...");
  }
  
  Serial.println("WiFi conectado!");
  Serial.print("IP: ");
  Serial.println(WiFi.localIP());
  
  // Ruta principal protegida
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    if(!request->authenticate(auth_user, auth_pass)) {
      return request->requestAuthentication();
    }
    
    String html = R"rawliteral(
      
      
      
        ESP32 Servidor Seguro
        
      
      
        🔒 Acceso Autorizado
        
          Panel de Control ESP32
          Bienvenido al servidor seguro
          IP del dispositivo: )rawliteral" + WiFi.localIP().toString() + R"rawliteral(
        
      
      
    )rawliteral";
    
    request->send(200, "text/html", html);
  });
  
  // Ruta de configuración protegida
  server.on("/config", HTTP_GET, [](AsyncWebServerRequest *request){
    if(!request->authenticate(auth_user, auth_pass)) {
      return request->requestAuthentication();
    }
    request->send(200, "text/plain", "Configuración del sistema");
  });
  
  // Ruta pública sin autenticación
  server.on("/status", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send(200, "text/plain", "ESP32 Online - Puerto abierto");
  });
  
  server.begin();
  Serial.println("Servidor HTTP iniciado");
}

void loop() {
  // El servidor es asíncrono, no necesita código en loop()
}

Ejercicios Prácticos

Ejercicio 1: Servidor con Autenticación Básica

Básico 30 min

Objetivo: Implementar un servidor web ESP32 con autenticación básica HTTP.

Materiales necesarios:

ESP32 development board
Cable USB
Arduino IDE configurado
Red WiFi disponible

Pasos a seguir:

Configura las credenciales WiFi y de autenticación
Implementa el servidor con rutas protegidas
Prueba el acceso desde un navegador web
Verifica que solicite credenciales correctamente

Ejercicio 2: Múltiples Rutas con Diferentes Permisos

Intermedio 45 min

Objetivo: Crear un sistema con diferentes niveles de acceso para distintas rutas.

Sistema Multi-Usuario

// Diferentes usuarios con distintos permisos
const char* admin_user = "admin";
const char* admin_pass = "admin123";
const char* guest_user = "guest";
const char* guest_pass = "guest123";

// Función de verificación de credenciales
bool verifyCredentials(AsyncWebServerRequest *request, String requiredUser, String requiredPass) {
  if (!request->authenticate(requiredUser.c_str(), requiredPass.c_str())) {
    request->requestAuthentication();
    return false;
  }
  return true;
}

// Ruta solo para administradores
server.on("/admin", HTTP_GET, [](AsyncWebServerRequest *request){
  if (!verifyCredentials(request, admin_user, admin_pass)) return;
  request->send(200, "text/html", "Panel de Administración");
});

// Ruta accesible para guests
server.on("/data", HTTP_GET, [](AsyncWebServerRequest *request){
  if (!verifyCredentials(request, guest_user, guest_pass)) return;
  request->send(200, "text/json", "{'temperature': 25.6, 'humidity': 60}");
});

Proyecto Aplicado

Sistema de Monitoreo Seguro con DHT22

Proyecto Completo IoT Seguro

Características

Sensor DHT22 para temperatura y humedad
Autenticación básica HTTP
Interface web responsiva
API REST protegida
Logs de acceso en tiempo real

Componentes

ESP32
Sensor DHT22
Resistencia 10kΩ
Protoboard y cables
Fuente de alimentación

Código del Proyecto Completo

#include 
#include 
#include 
#include 

#define DHT_PIN 4
#define DHT_TYPE DHT22

DHT dht(DHT_PIN, DHT_TYPE);
AsyncWebServer server(80);

const char* ssid = "TU_WIFI";
const char* password = "TU_PASSWORD";
const char* auth_user = "admin";
const char* auth_pass = "sensor123";

void setup() {
  Serial.begin(115200);
  dht.begin();
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Conectando...");
  }
  
  // Dashboard principal
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    if(!request->authenticate(auth_user, auth_pass)) {
      return request->requestAuthentication();
    }
    
    float temp = dht.readTemperature();
    float hum = dht.readHumidity();
    
    String html = R"rawliteral(
      
      
      
        Monitor Ambiental Seguro
        
        
        
      
      
        
          
            🔒 Monitor Ambiental Seguro
            Acceso autenticado ✓
          
          
          
            🌡️ Temperatura
            )rawliteral" + String(temp) + R"rawliteral(°C
          
          
          
            💧 Humedad
            )rawliteral" + String(hum) + R"rawliteral(%
          
          
          
        
      
      
    )rawliteral";
    
    request->send(200, "text/html", html);
  });
  
  // API para obtener datos JSON
  server.on("/api/data", HTTP_GET, [](AsyncWebServerRequest *request){
    if(!request->authenticate(auth_user, auth_pass)) {
      return request->requestAuthentication();
    }
    
    DynamicJsonDocument doc(1024);
    doc["temperature"] = dht.readTemperature();
    doc["humidity"] = dht.readHumidity();
    doc["timestamp"] = millis();
    
    String response;
    serializeJson(doc, response);
    request->send(200, "application/json", response);
  });
  
  server.begin();
  Serial.println("Servidor seguro iniciado en: " + WiFi.localIP().toString());
}

void loop() {
  delay(1000);
}

Solución de Problemas

Problemas Comunes

Error 401 - No autorizado: Verificar credenciales de usuario
Ventana de login no aparece: Limpiar cache del navegador
Conexión rechazada: Confirmar puerto 80 disponible
Autenticación en bucle: Verificar encoding de credenciales

Tips de Seguridad

Usa contraseñas fuertes y únicas
Cambia credenciales por defecto
Considera usar HTTPS para mayor seguridad
Implementa timeout de sesión
Registra intentos de acceso fallidos

Evaluación y Criterios

Implementación Correcta

El servidor debe solicitar autenticación y validar credenciales correctamente

Seguridad Básica

Las rutas protegidas deben rechazar accesos no autorizados

Funcionalidad

Diferentes niveles de acceso funcionando según los permisos

Manejo de Errores

Respuestas apropiadas para credenciales incorrectas o faltantes