Guía para Proteger la API con Autenticación Segura (OAuth 2.0 sobre TLS 1.3)¶

Este documento detalla los pasos que realicé para configurar la autenticación basada en tokens OAuth 2.0 en los endpoints RESTful del subdominio integraciones.airam.com del Sistema CRM, asegurando que solo aplicaciones externas autorizadas pudieran acceder a datos como listas de contactos, oportunidades o tareas, y que todas las comunicaciones estuvieran cifradas con TLS 1.3. La configuración se realizó en un entorno Windows 11 Home con ASP.NET Core para el servidor web (Kestrel) y un certificado autofirmado generado con openssl. También verifiqué que las solicitudes sin token fueran rechazadas y que las comunicaciones estuvieran cifradas.

Requisitos Previos¶

• Un proyecto ASP.NET Core configurado para el Sistema CRM (por ejemplo, CrmMvc.Web).
• Un certificado SSL/TLS configurado para TLS 1.3 (generado previamente con openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout airam.com.key -out airam.com.crt para el dominio airam.com).
• Acceso administrativo al servidor.
• Herramientas instaladas: Postman para pruebas de API, openssl, y nmap (instalados con Chocolatey: Nginx v1.29.0, OpenSSL v3.5.1, Nmap v7.97).
• Conocimiento básico de OAuth 2.0 y configuración de ASP.NET Core.
• Un servidor de autorización (usaré IdentityServer4 para este ejemplo).

Pasos para Configurar la Autenticación Segura con OAuth 2.0 sobre TLS 1.3¶

Paso 1: Configurar el Servidor de Autorización (IdentityServer4)¶

1. Instalé IdentityServer4:
   • Agregué el paquete NuGet IdentityServer4 al proyecto CrmMvc.Web con el comando:

     dotnet add package IdentityServer4
     

2. Configuré IdentityServer4 en el proyecto:
   • Creé un archivo Config.cs en el proyecto para definir los recursos, alcances y clientes de OAuth 2.0:

     using IdentityServer4.Models;
     using System.Collections.Generic;
     
     public static class Config
     {
         public static IEnumerable<IdentityResource> IdentityResources =>
             new List<IdentityResource>
             {
                 new IdentityResources.OpenId(),
                 new IdentityResources.Profile()
             };
     
         public static IEnumerable<ApiScope> ApiScopes =>
             new List<ApiScope>
             {
                 new ApiScope("crm_api", "CRM API")
             };
     
         public static IEnumerable<Client> Clients =>
             new List<Client>
             {
                 new Client
                 {
                     ClientId = "external_app",
                     ClientSecrets = { new Secret("MySecureSecret123".Sha256()) },
                     AllowedGrantTypes = GrantTypes.ClientCredentials,
                     AllowedScopes = { "crm_api" }
                 }
             };
     }
     

   • En Program.cs, configuré IdentityServer4 como middleware:

     builder.Services.AddIdentityServer()
         .AddInMemoryIdentityResources(Config.IdentityResources)
         .AddInMemoryApiScopes(Config.ApiScopes)
         .AddInMemoryClients(Config.Clients)
         .AddDeveloperSigningCredential(); // Para pruebas; usar un certificado en producción
     
     var app = builder.Build();
     app.UseIdentityServer();
     

3. Configuré el subdominio integraciones.airam.com:
   • Aseguré que el subdominio estuviera mapeado al servidor en el archivo hosts de Windows (C:\Windows\System32\drivers\etc\hosts):

     127.0.0.1 integraciones.airam.com
     

   • Actualicé appsettings.json para usar el certificado existente y el subdominio:

     "Kestrel": {
       "Endpoints": {
         "Https": {
           "Url": "https://integraciones.airam.com:443",
           "Certificate": {
             "Path": "C:\\Certificates\\cert.pfx",
             "Password": "MySecurePassword123"
           }
         }
       }
     }
     

Paso 2: Proteger los Endpoints de la API con OAuth 2.0¶

1. Creé los endpoints de la API:
   • En el proyecto CrmMvc.Web, añadí un controlador para la API (Controllers/CrmApiController.cs):

     using Microsoft.AspNetCore.Authorization;
     using Microsoft.AspNetCore.Mvc;
     
     [Route("api/[controller]")]
     [ApiController]
     [Authorize(AuthenticationSchemes = "Bearer")]
     public class CrmApiController : ControllerBase
     {
         [HttpGet("contactos")]
         public IActionResult GetContactos()
         {
             return Ok(new { Contactos = new[] { "Contacto1", "Contacto2" } });
         }
     
         [HttpGet("oportunidades")]
         public IActionResult GetOportunidades()
         {
             return Ok(new { Oportunidades = new[] { "Oportunidad1", "Oportunidad2" } });
         }
     
         [HttpGet("tareas")]
         public IActionResult GetTareas()
         {
             return Ok(new { Tareas = new[] { "Tarea1", "Tarea2" } });
         }
     }
     

2. Configuré la autenticación en la API:
   • En Program.cs, añadí la autenticación OAuth 2.0:

     builder.Services.AddAuthentication("Bearer")
         .AddJwtBearer("Bearer", options =>
         {
             options.Authority = "https://integraciones.airam.com:443";
             options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
             {
                 ValidateAudience = false
             };
         });
     
     builder.Services.AddAuthorization();
     
     var app = builder.Build();
     app.UseAuthentication();
     app.UseAuthorization();
     

Paso 3: Asegurar TLS 1.3 en el Servidor¶

1. Forcé TLS 1.3 en Kestrel:
   • Modifiqué Program.cs para asegurar que solo TLS 1.3 estuviera habilitado:

     builder.WebHost.ConfigureKestrel(options =>
     {
         options.ConfigureHttpsDefaults(httpsOptions =>
         {
             httpsOptions.SslProtocols = System.Security.Authentication.SslProtocols.Tls13;
         });
     });
     

2. Deshabilité protocolos antiguos:
   • Usé el Editor de Registro (regedit) en Windows 11 Home:
     • Navegué a HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\SCHANNEL\Protocols.
     • Creé claves para TLS 1.0, TLS 1.1 y TLS 1.2, y establecí el valor DWORD Enabled en 0 para deshabilitarlas.
     • Creé una clave para TLS 1.3 y establecí Enabled en 1.
     • Reinicié el sistema para aplicar los cambios.

Paso 4: Configurar el Firewall¶

1. Permití tráfico HTTPS:
   • En el Firewall de Windows con Seguridad Avanzada, creé una regla de entrada para el puerto 443:
     • Tipo: Puerto, Protocolo: TCP, Puerto: 443, Acción: Permitir la conexión.
   • Añadí app.UseHttpsRedirection(); en Program.cs para redirigir el tráfico HTTP (puerto 80) a HTTPS.

Paso 5: Verificar la Configuración¶

1. Obtuve un token de acceso:
   • Usé Postman para obtener un token OAuth 2.0 del servidor de autorización:
     • Envié una solicitud POST a https://integraciones.airam.com:443/connect/token con los parámetros:

       grant_type: client_credentials
       client_id: external_app
       client_secret: MySecureSecret123
       scope: crm_api
       

     • Obtuve un token de acceso en la respuesta (por ejemplo, access_token: "eyJ...").
2. Probé los endpoints con token válido:
   • Envié una solicitud GET a https://integraciones.airam.com:443/api/crmapi/contactos con el encabezado:

     Authorization: Bearer eyJ...
     

     • Salida:

       {
         "Contactos": ["Contacto1", "Contacto2"]
       }
       

     • Repetí para /api/crmapi/oportunidades y /api/crmapi/tareas, confirmando respuestas exitosas.
3. Probé los endpoints sin token:
   • Envié una solicitud GET a https://integraciones.airam.com:443/api/crmapi/contactos sin el encabezado Authorization.
     • Salida:

       HTTP 401 Unauthorized
       

     • Esto confirmó que las solicitudes sin token válido fueron rechazadas.
4. Verifiqué TLS 1.3 con nmap:
   • Ejecuté el comando:

     nmap --script ssl-enum-ciphers -p 443 integraciones.airam.com
     

     • Salida:

       Starting Nmap 7.97 ( https://nmap.org ) at 2025-08-02 16:16 -0400
       Nmap scan report for integraciones.airam.com (127.0.0.1)
       Host is up (0.00s latency).
       Other addresses for integraciones.airam.com (not scanned): ::1
       
       PORT    STATE  SERVICE
       443/tcp open   https
       | ssl-enum-ciphers:
       |   TLSv1.3:
       |     ciphers:
       |       TLS_AES_256_GCM_SHA384 (secp256r1) - A
       |       TLS_AES_128_GCM_SHA256 (secp256r1) - A
       
       Nmap done: 1 IP address (1 host up) scanned in 1.50 seconds
       

     • Esto confirmó que solo TLS 1.3 estaba habilitado con cifrados robustos.
5. Verifiqué TLS 1.3 con openssl:
   • Ejecuté:

     openssl s_client -connect integraciones.airam.com:443 -tls1_3
     

     • Salida:

       Protocol  : TLSv1.3
       Cipher    : TLS_AES_256_GCM_SHA384
       

     • Intenté conectar con -tls1_2, lo que resultó en un error handshake failure, confirmando que los protocolos antiguos estaban deshabilitados.

Resumen¶

• Configuré el entorno instalando Nginx (v1.29.0), OpenSSL (v3.5.1), y Nmap (v7.97) con Chocolatey, verificando sus versiones.
• Implementé OAuth 2.0 en los endpoints RESTful del subdominio integraciones.airam.com usando IdentityServer4, asegurando que solo aplicaciones externas autorizadas accedieran a los datos del CRM.
• Forcé TLS 1.3 en Kestrel y deshabilité protocolos antiguos mediante el registro de Windows.
• Verifiqué que las solicitudes sin token fueran rechazadas (HTTP 401 Unauthorized) y que las comunicaciones usaran TLS 1.3 con cifrados seguros (TLS_AES_256_GCM_SHA384).
• Nota: Para producción, planeo usar un certificado de una CA confiable como Let’s Encrypt y un servidor de autorización externo (por ejemplo, Auth0) para mayor escalabilidad.

Buen trabajo