Introducción
Cuando hablo de certificados SSL/TLS con equipos de backend, casi siempre me encuentro con el mismo atajo peligroso: “no conecta en el entorno de pruebas, así que pon verify=False en Python o un callback => true en .NET y sigue”. Este atajo parece inofensivo porque resuelve el error de conexión en el momento, pero elimina justamente el mecanismo que impide los ataques man-in-the-middle (MITM). En otras palabras: la aplicación sigue “funcionando”, pero deja de saber si está hablando con el servidor legítimo.
En este artículo, voy a explicar cómo funcionan los certificados SSL/TLS de forma práctica y, sobre todo, cómo valido certificados correctamente en aplicaciones .NET y Python en escenarios reales de producción. Voy a cubrir el handshake de TLS 1.3, la cadena de confianza X.509, el trust store, mTLS, contenedores y el escenario que más dudas genera en los equipos de backend: una API llamando a otra API por HTTPS con un Load Balancer, NGINX, HAProxy, F5, Azure Application Gateway, AWS ALB o Kubernetes Ingress en medio. La idea es salir de la teoría abstracta e ir a código y arquitectura que puedes poner en producción sin pasar vergüenza en una auditoría.
Cuando una API llama a https://api2.interno.empresa.com, valida el certificado presentado por el endpoint HTTPS que recibió la conexión. En muchas arquitecturas, ese endpoint no es el contenedor de la API 2; es un Load Balancer o Proxy Inverso que realiza TLS Termination. Después de eso, el tráfico puede seguir hacia el backend por HTTP interno, HTTPS interno con una nueva validación, o TLS passthrough hasta el propio contenedor. Entender dónde termina TLS evita una confusión clásica: creer que la API cliente siempre valida el certificado del contenedor.
Este es el cuarto artículo de la serie Segurança para Devs (Seguridad para Devs). En los artículos anteriores traté autenticación, BFF y API Gateway. Ahora me centro en la capa de transporte, porque sin un TLS validado correctamente todo lo demás se vuelve frágil: un JWT robusto no salva un canal comprometido, un OAuth2 correcto no protege contra la interceptación de tráfico y un mTLS mal configurado puede convertirse en teatro de seguridad.
ℹ️ Información: TLS 1.3 (RFC 8446) redujo el handshake a 1-RTT en el caso común y eliminó suites y algoritmos antiguos e inseguros. Esto mejora la seguridad y la latencia al mismo tiempo.
Si quieres un resumen de la tesis desde el principio: validar certificados no es opcional. Es un control de integridad del canal. Cuando desactivo la verificación para “hacerlo funcionar”, cambio un error explícito por un riesgo silencioso. El objetivo aquí es mostrarte cómo mantener la conexión segura sin caer en esos atajos.
Requisitos previos
Para seguir los ejemplos sin fricción, recomiendo este entorno:
- .NET 10 SDK instalado para compilar los samples de C#.
- Python 3.12+ con
requestsdisponible. - Conocimientos básicos de HTTP/HTTPS, status codes y cabeceras.
- Familiaridad mínima con Docker e imágenes Linux (Debian/Ubuntu) para la parte de contenedores.
También ayuda tener acceso a un endpoint HTTPS de prueba con certificado propio (CA interna) y, si quieres reproducir mTLS, un certificado de cliente (.pfx en .NET o un par .crt/.key en Python).
Qué es TLS/SSL y por qué “SSL” es un término heredado
En el día a día, todavía oigo “certificado SSL” todo el tiempo, incluso en documentación de productos. Técnicamente, sin embargo, SSL (Secure Sockets Layer) es el nombre histórico. SSL 2.0 y SSL 3.0 están obsoletos desde hace años por problemas graves de seguridad. El protocolo actual es TLS (Transport Layer Security), con el foco moderno en TLS 1.2 y TLS 1.3.
¿Por qué importa esta distinción? Porque el lenguaje moldea las decisiones técnicas. Cuando trato TLS como “SSL”, suelo heredar una mentalidad antigua: compatibilidad por encima de seguridad, cifrados débiles para atender a clientes legados, tolerancia a certificados mal emitidos. Cuando lo trato como TLS moderno, priorizo suites seguras, validación estricta y observabilidad de expiración/revocación.
En la práctica, el certificado digital es un documento X.509 que vincula una identidad (dominio, organización, servicio) a una clave pública. TLS usa ese certificado para establecer un canal cifrado y autenticado entre cliente y servidor. El cliente valida si el certificado es de confianza, si el nombre del host coincide con el SAN/CN y si la cadena hasta una CA raíz de confianza se cierra correctamente.
Me gusta resumirlo así:
- El cifrado protege la confidencialidad del tráfico.
- La integridad garantiza que el paquete no fue alterado.
- La autenticidad confirma con quién estoy hablando.
Sin validación de certificado, mantengo el cifrado, pero pierdo la autenticidad. Es exactamente el punto que explota un atacante MITM.
⚠️ Atención: Si el cliente acepta cualquier certificado, TLS se convierte en un túnel cifrado hacia el atacante adecuado. Cifrado, pero comprometido.
Cómo funciona el handshake de TLS 1.3
El handshake de TLS 1.3 es el proceso de negociación entre cliente y servidor antes de que circulen los datos de la aplicación. Me resulta útil ver este flujo en cinco bloques:
- ClientHello: el cliente envía las versiones de TLS soportadas, suites criptográficas, extensiones (como SNI y ALPN) y una clave efímera para ECDHE.
- ServerHello: el servidor elige versión/suite, responde con su clave efímera e inicia los parámetros de la sesión.
- Certificate + CertificateVerify: el servidor envía la cadena de certificados y demuestra la posesión de la clave privada.
- Finished: ambos confirman que llegaron a las mismas claves de sesión.
- Application Data: el tráfico HTTP pasa a estar protegido por el canal establecido.

El cambio más importante respecto a las versiones antiguas es la reducción de complejidad. TLS 1.3 eliminó la renegociación insegura, eliminó el intercambio de claves RSA y convirtió ECDHE en el estándar para perfect forward secrecy (PFS). En términos prácticos, aunque la clave privada del servidor se filtre en el futuro, las sesiones antiguas no se descifran retroactivamente.
Otro punto que observo en producción: un error de handshake suele apuntar más a la configuración del certificado/trust store que a un bug de código. Por eso, el log detallado de fallos TLS es esencial. Cuando capturo hostname, issuer, thumbprint y estado de la cadena, resuelvo los incidentes mucho más rápido.
ℹ️ Información: TLS 1.3 usa solo suites AEAD modernas (como AES-GCM y ChaCha20-Poly1305), reduciendo la superficie de ataque y simplificando el hardening operativo.
Cadena de confianza: CA raíz, intermedia y certificado de entidad final
Un certificado no es una entidad aislada. Participa en una cadena de confianza. En general, tengo:
- Certificado de entidad final: pertenece al servidor (por ejemplo
api.minhaempresa.com). - CA intermedia: emite certificados de servidor y reduce la exposición de la raíz.
- CA raíz: ancla de confianza presente en el trust store del sistema cliente.
Cuando el cliente recibe el certificado del servidor, intenta montar esa cadena hasta una raíz de confianza local. Si la raíz no está en el trust store, la validación falla con un error de untrusted root. Esto es común en entornos corporativos con PKI interna, laboratorios y entornos air-gapped.
En certificados públicos de internet, la cadena normalmente termina en una CA raíz ya presente en el trust store del sistema o del navegador. Es el caso de los certificados emitidos por CA públicas (autoridades certificadoras) como Certisign, DigiCert, GlobalSign y Let’s Encrypt. En esos escenarios, no necesito distribuir una CA interna a clientes externos; el foco pasa a ser enviar la cadena intermedia correcta desde el servidor y mantener la renovación al día.
En el día a día, los problemas más frecuentes que veo son:
- Servidor que no envía la intermedia correcta.
- Certificado expirado o fuera de su ventana de validez.
- SAN sin el hostname esperado.
- Cadena de confianza en el host, pero no en el contenedor.
Este último es traicionero: en mi portátil funciona, en el pod no. El motivo normalmente es simple: la imagen no recibió la CA interna en el trust store del sistema.
Cuando trabajo con una CA privada, mi enfoque es doble:
- Instalo la CA en el trust store del sistema en el entorno controlado.
- Cuando es necesario, uso trust personalizado en la aplicación para escenarios aislados.
Esta segunda opción requiere disciplina. El trust personalizado es una buena herramienta cuando está bien delimitado, pero peligroso si se convierte en regla general sin gobernanza.
Validar certificados correctamente en .NET
En .NET, mi referencia de cliente HTTP moderno es HttpClient con SocketsHttpHandler. Permite configurar TLS sin trucos inseguros. El punto clave es: nunca devuelvo true de forma incondicional en el callback.
Cuando el endpoint usa un certificado público emitido por una CA pública de confianza, el camino estándar de .NET ya resuelve la validación usando el trust store del sistema. Solo añado trust personalizado cuando tengo una CA privada o un requisito de aislamiento específico.
Fragmento de sample con trust personalizado y validación real de la cadena:
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/Security/Certificates/
En el validator, rechazo de inmediato RemoteCertificateNotAvailable y RemoteCertificateNameMismatch, después reconstruyo la cadena con una política estricta (NoFlag) y revocación online. Si hay una CA personalizada, aplico TrustMode = CustomRootTrust y añado la raíz en CustomTrustStore.
Ejemplo de creación de un cliente mTLS:
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/Security/Certificates/
Dos detalles operativos marcan la diferencia en producción:
- Prefiero
X509CertificateLoaderen lugar de constructores heredados para evitar warnings y garantizar compatibilidad actual. - Monitorizo los errores de cadena y expiración en logs estructurados para disparar alertas antes de la caída.
Validar certificados correctamente en Python
En Python, veo el mismo anti-pattern que en .NET: verify=False para “destrabar” una integración. En producción, esto no puede existir. El camino correcto con requests es indicar el bundle de CA de confianza en verify, o mantener el trust store por defecto cuando se usa una CA pública.
Ejemplo seguro con requests:
| |
Si necesito un control más fino, creo un SSLContext explícito:
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/python/
Para mTLS en requests, paso el par certificado/clave del cliente en el parámetro cert:
| |
Este enfoque me sirve bien para automatizaciones, workers e integraciones backend-to-backend. En APIs sensibles, combino mTLS con un token de aplicación para defensa en capas.
Para un certificado público de servidor (por ejemplo, un dominio público emitido por Certisign u otra CA pública), lo habitual es mantener verify=True y usar el trust store nativo, sin un bundle de CA personalizado. Solo apunto verify a un archivo cuando necesito confiar en una CA privada o en una cadena fuera del estándar del sistema.
mTLS: cuando el cliente también presenta un certificado
En el TLS tradicional, solo el servidor presenta certificado. En mTLS (mutual TLS), cliente y servidor presentan certificados. Lo uso cuando quiero una identidad fuerte de servicio a servicio sin depender solo de un secreto estático.
Escenarios comunes en los que mTLS compensa el coste:
- Comunicación interna entre API Gateway y servicios críticos.
- Integración B2B con socios fijos y requisitos de compliance.
- Entornos financieros e industriales donde la identidad criptográfica es obligatoria.
mTLS no sustituye la autorización de negocio. Prueba la identidad técnica del cliente, pero aún necesito decidir si ese cliente puede ejecutar esa acción. En la práctica, trato mTLS como un control de borde y mantengo la autorización por scopes/claims en la aplicación.
Si quieres el contexto arquitectónico de la serie, este artículo conecta directamente con API Gateway: la pieza que falta en la seguridad de tu SPA, donde muestro cómo un gateway aplica políticas a escala.
Certificados en contenedores
Los contenedores cambian bastante el juego porque el trust store del host no se hereda automáticamente como mucha gente imagina. Cada imagen tiene su propio conjunto de CAs. Cuando recibo un error de TLS solo en el pod, casi siempre es una CA ausente en el filesystem de la imagen.
En Debian/Ubuntu, el flujo estándar es:
| |
Con esto, las bibliotecas que usan el trust store del sistema pasan a confiar en la CA interna. Evito poner certificados sensibles en variables de entorno. Para el certificado de cliente y la clave privada, monto el secret en tmpfs (como /run/secrets) y limito el permiso de lectura al proceso de la aplicación.
También tengo cuidado con la rotación:
- CA y certificados con fecha de vencimiento monitorizada.
- Pipeline de imagen preparado para el cambio sin downtime innecesario.
- Health checks que fallan pronto cuando la cadena no valida.
En Kubernetes, esto normalmente significa combinar Secret/CSI driver con un rollout controlado y observabilidad del handshake.
TLS Termination en Load Balancers y proxies inversos
En una arquitectura corporativa, la llamada rara vez es tan directa como “la API 1 abre TLS con el contenedor de la API 2”. El diseño más común es este:
| |
En este modelo, la API 1 valida el certificado del Load Balancer o Proxy Inverso, porque es él quien aparece como servidor TLS en la conexión. Si el DNS api2.interno.empresa.com apunta a un NGINX, F5, HAProxy, Azure Application Gateway, AWS ALB o Ingress Controller, es ese componente el que presenta el certificado al cliente. El contenedor de la API 2 puede estar sirviendo HTTP plano en una red privada y, aun así, la llamada externa de la API 1 sigue siendo HTTPS.
El código de la API cliente no necesita cambiar por esto:
| |
Desde el punto de vista de HttpClient, el flujo es simple: resolver el DNS, conectar a la IP devuelta, recibir el certificado del servidor TLS, validar hostname/cadena/validez y solo entonces enviar HTTP dentro del túnel cifrado. Lo que ocurre después del Load Balancer es transparente para la API cliente.
ℹ️ Información: Si la API cliente llama a
https://api2.interno.empresa.com, ese nombre debe estar en el SAN del certificado presentado por el Load Balancer o Proxy Inverso. El SAN del certificado del contenedor solo importa a quien abre TLS directamente con el contenedor.
La pregunta que suele aparecer es: “si el certificado está en el Load Balancer, ¿por qué la API necesita validarlo?” La respuesta es que, para la API cliente, el Load Balancer es el servidor TLS. La validación impide que la API envíe datos a un endpoint que solo parece ser api2.interno.empresa.com, pero que no tiene un certificado de confianza para ese nombre. TLS no autentica “el contenedor” por definición; TLS autentica el otro extremo de la conexión que se abrió.
Cuando el proxy inverso tiene una CA
La frase “el proxy inverso tiene el certificado de la CA” puede significar tres cosas diferentes, y cada una cubre un escenario distinto:
| Lo que tiene el proxy | Para qué sirve | Escenario cubierto |
|---|---|---|
| Certificado de servidor firmado por una CA | Presentar la identidad HTTPS a los clientes | TLS Termination en el Load Balancer/Proxy |
| Certificado de la CA de confianza | Validar el certificado de un upstream HTTPS | TLS Re-encryption entre proxy y backend |
| CA de clientes de confianza | Validar certificados presentados por clientes | mTLS en el borde del proxy inverso |
En el primer caso, el proxy no “tiene la CA” como clave de autoridad; tiene un certificado de servidor emitido por una CA pública o privada. Este es el caso más común de TLS Termination: la API 1 valida el certificado del proxy, y el proxy reenvía a la API 2.
En el segundo caso, el proxy tiene el certificado público de la CA en su trust store para validar el backend. Aquí el proxy actúa como cliente TLS cuando llama a https://api2-backend.interno.local. La API 1 valida el proxy; el proxy valida el backend. Son dos sesiones TLS independientes.
En el tercer caso, el proxy tiene una CA de clientes de confianza para exigir mTLS en la entrada. La API 1 presenta un certificado de cliente, el proxy valida ese certificado contra la CA configurada y solo entonces acepta la conexión. Esto autentica a la API que llama en el borde, pero no sustituye la autorización de negocio dentro de la aplicación.
⚠️ Atención: La clave privada de una CA no debe estar en un Load Balancer, NGINX o contenedor de aplicación. El proxy necesita el certificado de servidor y, cuando sea necesario, el certificado público de la CA para la validación. La clave privada de la CA pertenece al proceso de emisión, no al runtime de la API.
TLS Termination, Re-encryption y Passthrough
Los tres modelos siguientes resuelven problemas diferentes. Me gusta elegir explícitamente uno de ellos en el diseño de arquitectura, porque la frase “usa HTTPS” por sí sola no dice dónde empieza, termina o se reabre TLS.
| Modelo | Flujo | ¿Quién presenta el certificado al cliente? | ¿El backend usa TLS? | Cuándo usarlo |
|---|---|---|---|---|
| TLS Termination | Cliente -> HTTPS -> LB/proxy -> HTTP -> API | LB/proxy | No | Red privada controlada, menor complejidad operativa |
| TLS Re-encryption | Cliente -> HTTPS -> LB/proxy -> HTTPS -> API | LB/proxy | Sí | Entornos regulados, red interna compartida o tráfico sensible |
| TLS Passthrough | Cliente -> HTTPS -> LB TCP -> API | API/backend | Sí | Cuando el LB no debe terminar TLS ni inspeccionar HTTP |
En TLS Termination, el Load Balancer termina la sesión TLS y pasa a ver la petición HTTP. Esto permite enrutamiento por path, cabeceras, cookies y políticas de WAF, pero exige confianza en la red entre proxy y backend. En muchos entornos internos, este diseño es aceptable cuando existe segmentación de red, firewall, autenticación entre servicios y observabilidad.
En TLS Re-encryption, el proxy termina el TLS del cliente y abre una nueva conexión HTTPS hacia el backend. Este diseño crea dos protecciones independientes: el cliente valida el proxy, y el proxy valida el backend. Es el modelo que prefiero cuando el tráfico pasa por una red compartida, Kubernetes multi-tenant, service mesh o un entorno con requisitos regulatorios más estrictos.
En TLS Passthrough, el Load Balancer opera en la capa TCP y reenvía la conexión TLS sin abrir el contenido HTTP. El certificado presentado al cliente es el del backend, no el del proxy. La ganancia es mantener TLS de extremo a extremo hasta la aplicación; la pérdida es reducir los recursos de enrutamiento HTTP, inspección y WAF en el borde.
NGINX como punto de terminación TLS
Cuando uso NGINX como web server/proxy inverso, el punto central es siempre el mismo: el certificado presentado al cliente está en el bloque server HTTPS, mediante ssl_certificate y ssl_certificate_key.
Certificado público presentado al cliente
En el escenario público (una CA pública como Certisign, DigiCert, GlobalSign o Let’s Encrypt), mi práctica es configurar NGINX con la cadena completa (fullchain) para evitar errores de cadena incompleta en el cliente:
| |
En este ejemplo, NGINX realiza TLS Termination. El cliente valida api.minhaempresa.com, recibe el certificado de NGINX y solo después la petición sigue hacia http://app:8080 dentro de la red interna.
mTLS entre el cliente y NGINX
En el escenario interno con una CA privada, la configuración del certificado en NGINX es parecida, pero los clientes solo confiarán si la CA interna está en su trust store. Si el endpoint exige mTLS de cliente, habilito la verificación explícita:
| |
Aquí NGINX usa ssl_client_certificate como lista de CAs de confianza para validar los certificados presentados por los clientes. Esto cubre el escenario en el que la API 1 también necesita probar su identidad mediante certificado antes de acceder a la API 2.
NGINX validando el certificado del upstream HTTPS
Cuando NGINX también actúa como cliente TLS de un upstream HTTPS interno, activo la validación de certificado en el proxy para no caer en el anti-pattern de confiar a ciegas:
| |
Con esto, cubro los dos lados de la seguridad: el certificado que NGINX presenta hacia fuera y la validación del certificado cuando llama a servicios HTTPS internos.
Ejemplo Práctico
Como ejemplo práctico, uso dos implementaciones de cliente y tres topologías de infraestructura para validar:
- .NET en
src/BlogSamples/Security/Certificates/conHttpClientseguro, trust personalizado y mTLS. - Python en
python/ssl_validation_example.pyconrequestsy unSSLContextestricto. - API llamando a API a través de un Load Balancer: la API 1 accede a
https://api2.interno.empresa.comy valida el certificado presentado por el Load Balancer o Proxy Inverso. - TLS Re-encryption: el proxy termina HTTPS en el borde y abre una nueva conexión HTTPS validada hasta la API backend.
- TLS Passthrough: el proxy no termina TLS; el certificado que ve el cliente es el certificado del backend.
Flujo que recomiendo para validar de extremo a extremo:
- Levanta un endpoint HTTPS de prueba con una CA privada.
- Apunta un DNS interno al Load Balancer o NGINX.
- Ejecuta el cliente .NET con
CriarClienteComCaPrivadallamando al DNS público del servicio, no al nombre del contenedor. - Ejecuta el script Python pasando
TLS_CA_BUNDLE,TLS_CLIENT_CERTyTLS_CLIENT_KEYcuando haya mTLS. - Verifica los logs de cadena y hostname en ambos.
- Fuerza un error (hostname incorrecto o certificado expirado) para confirmar que la aplicación falla de forma segura.
📝 Ejemplo: Si el endpoint es
https://api.interna.localy el certificado tiene SAN solo paraapi.dev.local, la conexión debe fallar por discrepancia de nombre. Ese es el comportamiento correcto y esperado.
Con este flujo, demuestro dos cosas al equipo: que el camino feliz funciona y que el camino de fallo falla de la forma correcta. La seguridad madura no es solo “funciona cuando todo está bonito”; es predecible cuando algo se sale de lo esperado.
Consejos y Buenas Prácticas
Nunca desactives la validación (
verify=False,CERT_NONE, callback=> true). Cuando elimino la validación, elimino la autenticidad del canal y abro el camino al MITM. En su lugar, corrijo el trust store, el SAN o la cadena.Prefiere fijar (pin) la CA/intermedia en lugar del certificado de entidad final. El pin en el leaf se rompe con renovaciones frecuentes. El pin en una CA bien gobernada reduce el mantenimiento sin perder control.
Monitoriza la expiración y los fallos de handshake como métrica de plataforma. Trato los errores TLS como una señal operativa de alto valor. Alertar 30 días antes de la expiración evita un incidente evitable.
Usa mTLS en tráfico lateral sensible, especialmente entre gateway y backend. Esto reduce el riesgo de llamadas directas indebidas a servicios internos. Aun así, mantén la autorización por claims/scopes en la app.
Estandariza la instalación de CAs en imágenes y entornos locales. Documento el paso del trust store por distro y lo automatizo en el Dockerfile. Esto elimina el “en mi máquina funciona” de TLS.
En un dominio público, prefiere una CA pública bien soportada y automatización de la renovación. Esto reduce la fricción de distribuir confianza a clientes externos. Incluso con una CA pública, valido la cadena enviada por el servidor y monitorizo la expiración para evitar indisponibilidad.
Garantiza que el SAN corresponda al DNS usado por el cliente. Si la API llama a
api2.interno.empresa.com, ese nombre debe estar en el certificado presentado por el Load Balancer o Proxy Inverso. El certificado del backend solo entra en la validación cuando hay TLS Re-encryption o Passthrough.Elige explícitamente entre Termination, Re-encryption y Passthrough. TLS Termination simplifica la operación, Re-encryption protege también el tramo interno y Passthrough mantiene el certificado en el backend. No los trates a todos como “HTTPS” genérico, porque cada modelo cambia quién valida a quién.
No pongas la clave privada de la CA en el proxy inverso. El proxy necesita la clave privada del certificado de servidor para presentar su identidad y los certificados públicos de las CAs que usa para validar clientes o upstreams. La clave privada de la CA debe quedar protegida en el proceso de emisión, fuera del runtime.
Prueba escenarios negativos de forma intencional. Incluye casos con hostname inválido, certificado expirado y cadena incompleta en el pipeline de calidad. Si el cliente acepta esos escenarios, algo está mal.
Resumen Objetivo
- TLS 1.3 — es el protocolo moderno de transporte seguro; SSL es un legado obsoleto y no debe ser objetivo de configuraciones nuevas.
- Validación de certificado — debe confirmar la cadena de confianza, el hostname (SAN/CN), la validez temporal y, cuando aplique, la revocación.
- TLS Termination — ocurre cuando un Load Balancer o Proxy Inverso termina HTTPS, presenta el certificado al cliente y reenvía la petición al backend por HTTP o HTTPS.
- TLS Re-encryption — crea dos sesiones TLS independientes: cliente-proxy y proxy-backend; el cliente valida el proxy, y el proxy valida la API backend.
- TLS Passthrough — mantiene la sesión TLS hasta el backend; el certificado que ve el cliente es el de la aplicación, pero el proxy pierde la inspección HTTP detallada.
- Clientes .NET y Python — deben validar certificados con
SocketsHttpHandler,CustomRootTrust,verify,CERT_REQUIREDycheck_hostname=True, sin bypass inseguro. - mTLS — añade autenticación del cliente por certificado y es especialmente útil en la comunicación service-to-service crítica.
- NGINX con HTTPS — usa
ssl_certificateyssl_certificate_keypara presentar identidad;ssl_client_certificatevalida clientes mTLS yproxy_ssl_trusted_certificatevalida upstreams.
Lee También
- Autenticación y Autorización: JWT, OAuth2 y OpenID Connect
- BFF Backend For Frontend: Seguridad en SPAs
- API Gateway: la pieza que falta en la seguridad de tu SPA
- Prevenção de DDoS: Infraestrutura e Segurança em Aplicações Modernas
Referencias
- RFC 8446 - The Transport Layer Security (TLS) Protocol Version 1.3 — especificación oficial de TLS 1.3.
- RFC 5280 - Internet X.509 Public Key Infrastructure Certificate and CRL Profile — perfil de certificados X.509 y validación de la cadena.
- Microsoft Docs - X509Chain — API de construcción y validación de cadena en .NET.
- Microsoft Docs - SocketsHttpHandler — configuración de cliente HTTP moderno en .NET.
- Python Docs - ssl — configuración del contexto TLS en Python.
- Requests Docs - SSL Cert Verification — verificación de certificados en la biblioteca requests.
- OWASP Transport Layer Security Cheat Sheet — guía práctica de hardening TLS.
- NGINX Docs - ngx_http_ssl_module — directivas
ssl_certificate,ssl_certificate_keyy configuración HTTPS en el bloqueserver. - NGINX Docs - ngx_http_proxy_module — directivas
proxy_ssl_verifyyproxy_ssl_trusted_certificatepara validación TLS del upstream. - HAProxy Documentation - SSL/TLS — configuración de terminación TLS, certificados y validación en HAProxy.
- Kubernetes Documentation - Ingress TLS — uso de TLS en Ingress Controllers en Kubernetes.
- Azure Application Gateway - SSL termination and end-to-end SSL — opciones de terminación TLS y cifrado de extremo a extremo en Application Gateway.
- AWS Elastic Load Balancing - HTTPS listeners — configuración de listeners HTTPS y certificados en Application Load Balancer.

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.