Protección de la identidad de los agentes de IA con la PKI X.509 en AWS
Securing AI agent identity with X.509 PKI on AWS
Deepakkumar Sharma
Cuando los agentes de IA acceden a bases de datos, API y operaciones empresariales confidenciales, establecer una identidad criptográfica a través de la infraestructura de clave pública (PKI) X.509 se convierte en un requisito fundamental. El principal desafío consiste en demostrar qué agente hizo una solicitud, evitar la falsificación entre los agentes y confirmar que cada agente actúa únicamente en nombre de un usuario autorizado. Los enfoques tradicionales, como compartir claves de API entre componentes o transferir tokens de OAuth a través de cadenas de agentes, no cumplen con los requisitos de confianza cero que exigen las
implementaciones empresariales.
Los marcos de IA con múltiples agentes utilizan cada vez más el Protocolo de contexto modelo (MCP) para conectar a los agentes con herramientas y fuentes de datos externas. El MCP define cómo un agente basado en un modelo de lenguaje de gran tamaño (LLM) invoca herramientas como las consultas a bases de datos o las operaciones de correo electrónico. Sin embargo, MCP no tiene un estándar de autenticación incorporado. Su diseño es independiente del transporte. Esto crea una brecha crítica: sin los mecanismos de identidad adecuados, cualquier componente podría hacerse pasar por un agente, reproducir las credenciales interceptadas
o invocar herramientas sin autorización.
En esta publicación, le mostramos cómo abordar esta brecha utilizando Keyfactor EJBCA en combinación con los servicios de AWS. EJBCA es una plataforma de PKI que admite la implementación de alta disponibilidad, la automatización de las API REST y la validación del protocolo de estado de los certificados en línea (OCSP). La arquitectura de referencia utiliza cuatro mecanismos de seguridad complementarios. En primer lugar, los sobres de solicitud firmados proporcionan una prueba criptográfica de posesión en cada llamada de un agente. En segundo lugar, las aserciones de delegación firmadas por los usuarios autorizan a los agentes a no compartir sus credenciales. En tercer lugar, los tokens basados en la RFC 8693 con el alcance de la audiencia limitan el alcance de la exposición cuando se divulga un solo token. En cuarto lugar, la verificación de revocación del OCSP en tiempo real propaga
los cambios de credenciales de forma inmediata en todos los agentes.
La solución utiliza Amazon Bedrock para la inferencia del LLM a través del SDK de agentes de AWS Strands. Si bien esta arquitectura de referencia utiliza una base de datos como recurso protegido, el mismo patrón de autenticación se aplica a cualquier servidor de herramientas compatible con MCP. El código fuente completo de todos los ejemplos está disponible en el repositorio de GitHub adjunto
.
Acerca de Keyfactor EJBCA
Keyfactor proporciona una plataforma de gestión de identidades de máquinas ampliamente adoptada y utilizada por más de 1500 clientes empresariales en todo el mundo, según Keyfactor. Estas organizaciones abarcan los servicios financieros, la atención médica, la fabricación y el gobierno. Keyfactor ayuda a las organizaciones a establecer y mantener la confianza criptográfica mediante la administración del ciclo de vida de los certificados, las operaciones de PKI y el gobierno de la identidad de las máquinas
.
EJBCA Enterprise es la plataforma de autoridad certificadora (CA) y PKI de Keyfactor, diseñada para la implementación de alta disponibilidad y la automatización de las API REST. Disponible como producto empresarial, EJBCA proporciona la emisión de certificados X.509, la validación OCSP, la distribución de listas de revocación de certificados (CRL) y la gestión completa del ciclo de vida de los certificados a través de una consola web y una API REST. EJBCA admite la implementación local, en contenedores o en Amazon Elastic Compute Cloud (Amazon
EC2).
La asociación entre AWS y Keyfactor reúne los servicios gestionados de AWS (Amazon Bedrock, AWS Secrets Manager, Amazon Relational Database Service (Amazon RDS)) con una infraestructura de PKI que admite la administración del ciclo de vida de los certificados, la inscripción automatizada y la revocación en tiempo real. Esta combinación aborda una brecha en el ecosistema de agentes de IA. Mientras que AWS proporciona las capas de procesamiento, almacenamiento e inferencia de inteligencia artificial, Keyfactor proporciona la capa de identidad criptográfica que vincula a los agentes con credenciales verificables, revocables y de corta duración. Esta arquitectura de referencia conjunta, desarrollada en colaboración por los equipos de ingeniería de AWS y Keyfactor, demuestra cómo integrar estas tecnologías. Puede adaptar los patrones que se muestran aquí a sus propias implementaciones con varios agentes
.
Descripción general de la solución
La arquitectura implementa tres capas de autenticación, cada una de las cuales aborda un límite de confianza diferente en la cadena de comunicación del agente. Estas tres capas utilizan los cuatro mecanismos de seguridad introducidos anteriormente: sobres firmados como prueba de posesión, aseveraciones de delegación para la autorización sin necesidad de credenciales, fichas con alcance de audiencia para limitar la exposición y OCSP para la revocación en tiempo real. Los mecanismos se combinan en varias capas
, como se muestra en la tabla siguiente.
Capa
Límite de confianza
Mecanismo
Valida
1. Autenticación de usuario
De usuario a sistema
Certificado OAuth + X.509 + creación de delegación
Identidad de usuario, enlace de credenciales
2. De agente a agente
De agente a agente
Sobres firmados (PoP + nonce + marca de tiempo)
Identidad de la persona que llama, actualización de la solicitud, sin repetición
3. Autenticación MCP
Del agente al servidor de herramientas
Símbolo con ámbito específico, sobre y delegación
Todas las identidades, cadena de autorización, OCSP
La figura 1 muestra las tres capas de autenticación y cómo fluyen las credenciales entre el usuario, los agentes y el servidor de herramientas MCP. El diagrama ilustra la separación entre las credenciales de usuario (que permanecen en el flujo de inicio de sesión), las credenciales de agente (con un alcance por agente) y la cadena de delegación que las conecta
.
Figura 1: Arquitectura de autenticación de PKI de tres capas para sistemas de agentes de IA en AWS
La figura 2 muestra el flujo de tráfico detallado durante una sesión de usuario típica. Muestra la secuencia de pasos de autenticación, desde el inicio de sesión hasta la emisión del certificado, la delegación de agentes, la invocación de herramientas y la limpieza de la sesión
.
Figura 2: Flujo del tráfico de autenticación desde el inicio de sesión del usuario hasta la delegación de agentes, la invocación de herramientas y la limpieza de la sesión
Servicios de AWS utilizados
Los siguientes servicios de AWS forman la base de la arquitectura de referencia.
Servicio
Propósito
Base amazónica
Inferencia de LLM a través del SDK de Strands Agents
Amazon RDS para MySQL
Se accede a la base de datos de aplicaciones mediante las herramientas de MCP
Amazon Simple Email Service (Amazon SES)
Entrega de correo electrónico para el agente de correo electrónico
Administrador de secretos de AWS
Almacenamiento seguro para paquetes, tokens y metadatos de PKCS12
Amazon EC2
Alberga el servidor Keycloak IDP y EJBCA PKI
Tutorial de la solución
Los pasos siguientes describen cada componente de la arquitectura, desde el inicio de sesión inicial del usuario hasta la limpieza de la sesión. Cada paso se basa en el anterior y establece una cadena de confianza que conecta al usuario humano con la ejecución final de la herramienta
.
Prerrequisitos
Una cuenta de AWS activa con acceso a Amazon Bedrock, Amazon RDS para MySQL, Amazon SES y AWS Secrets Manager.
Keycloak 26.2 o posterior (obligatorio para el intercambio de tokens estándar según la RFC 8693). Las versiones anteriores utilizan un intercambio antiguo que es incompatible
).
Keyfactor EJBCA Enterprise con la API REST V1 y un respondedor OCSP configurados.
Certificado de administrador de la API EJBCA (api-admin.p12) para la autenticación de la API REST.
Entorno de desarrollo Python 3.9+.
Familiaridad con los certificados X.509, OCSP, OAuth 2.0, las firmas digitales RSA y los almacenes de claves PKCS #12.
Paso 1: Inicio de sesión de usuario, emisión de certificados y creación de delegaciones
El flujo de inicio de sesión establece la identidad del usuario mediante tres mecanismos y, a continuación, delega la autoridad a los agentes de IA sin compartir las credenciales del usuario. Esta separación es fundamental: los agentes reciben un comprobante de autorización sin tener nunca la clave privada del usuario ni el token de OAuth de sesión completa
.
En primer lugar, la aplicación autentica al usuario con Keycloak mediante la concesión de una contraseña de OAuth 2.0 y recibe un token de acceso a la sesión completa y un token de actualización. Inmediatamente después, la aplicación realiza un intercambio de tokens según la RFC 8693 para obtener un token con un alcance reducido. La audiencia de este token está restringida al servidor MCP. Solo este token limitado se entrega a los agentes. Si queda expuesto inadvertidamente, no puede acceder a ningún otro servicio
de la organización.
En segundo lugar, la aplicación genera localmente un par de claves RSA 2048+ y envía una solicitud de firma de certificado (CSR) a EJBCA a través del punto final de la API REST pkcs10enroll. EJBCA firma la CSR y devuelve el certificado. La aplicación agrupa el certificado y la clave privada en un contenedor PKCS12 y los almacena en AWS Secrets Manager. La clave privada nunca sale del límite de la aplicación. No se envía a EJBCA, no se comparte con los agentes ni se almacena en el sistema de archivos. Se emiten tres certificados de agente utilizando el mismo flujo basado en la CSR,
uno por función de agente.
En tercer lugar, la clave privada del usuario firma una afirmación de delegación. Se trata de un documento JSON en el que se enumeran las huellas digitales SHA-256 de los tres certificados de agente, junto con el nombre del asunto del usuario, la hora de emisión y la fecha de caducidad. Esta delegación demuestra que el usuario autorizó a estos agentes específicos a actuar en su nombre. Los agentes llevan esta delegación en lugar del certificado del usuario.
# RFC 8693 Token Exchange: alcance reducido a la audiencia de MCP
downscoped_token = keycloak.token_exchange (
original_token, audience="mysql-mcp-server», scope="database:write»
)
# Generación de claves del lado del cliente (la clave de usuario nunca abandona este flujo)
private_key = rsa.generate_private_key (public_exponent=65537, key_size=2048)
csr = build_csr (private_key, f"cn= {nombre de usuario}, E= {nombre de usuario} @org .com»)
user_cert = ejbca.pkcs10enroll (csr, ca_name="userCA»)
# El usuario firma la delegación sobre las huellas dactilares del certificado del agente
delegación = mint_delegation (
nombre de usuario = nombre de usuario,
user_cert_pem=user_cert,
user_key_pem = private_key_pem,
agent_cert_pems= [orch_cert, mysql_cert, email_cert]
)
# Resultado: {sub, agent_fingerprint [], iat, exp, user_cert_pem,
signature_b64}
Paso 2: sobres firmados de agente a agente
Cuando el agente orquestador envía una solicitud a un subagente (como el agente de MySQL o el agente de correo electrónico), no se limita a pasarle su certificado para identificarlo. En su lugar, firma toda la carga útil de la solicitud, incluidos el nombre de la herramienta, los argumentos, una marca de tiempo y un nonce criptográficamente aleatorio, utilizando su clave privada con el RSA-PSS-SHA256. El sobre firmado resultante constituye una prueba de posesión. El agente receptor puede verificar que la persona que llama realmente posee la clave privada correspondiente al
certificado presentado.
El agente receptor realiza seis comprobaciones de validación en el sobre antes de procesar la solicitud:
Verificación de firma: demuestra que el remitente posee la clave privada (prueba de posesión).
Fecha de caducidad de la marca: el sobre debe estar dentro de ENVELOPE_MAX_AGE_SECONDS (60 segundos por defecto) respecto a la hora actual.
Exclusividad de Nonce: el ReplayCache rechaza cualquier nonce visto anteriormente, lo que impide la reproducciónde la solicitud.
Validación en cadena de CA:el certificado del remitente debe estar en cadena con la CA de confianza (userCA.pem).
Autorización de funciones: el sufijo de funcióndel certificado CN debe estar en ALLOWED_CALLER_ROLES para este agente.
Verificación de revocación del OCSP: una comprobación en tiempo real de la EJBCA confirma que el certificado no se ha revocado.
Si el orquestador necesita volver a enviar el mismo mensaje (por ejemplo, después de un error transitorio), debe crear un sobre nuevo con un nonce nuevo. Los sobres antiguos no se pueden reproducir, ni siquiera los puede reproducir
El servidor MCP (FastMCP) es el límite de confianza final antes de que se ejecute cualquier operación de base de datos. Realiza cuatro comprobaciones de validación en cada invocación de herramientas e implementa una defensa en profundidad. Incluso si una credencial está sujeta a un acceso no autorizado, las comprobaciones restantes evitan las operaciones
no autorizadas.
La secuencia de autenticación:
Introspección del token: una POST en el punto final de Keycloak /token/introspect verifica que el token esté activo y que su audiencia contenga «mcp-server». Se rechaza un token de sesión completa
sin la audiencia correcta.
Verificación del sobre: el sobre firmado por el agente se valida para comprobar que la firma es correcta, la fecha y hora, la unicidad de Nonce, la confianza en la cadena de CA, la coincidencia de roles (mysql-agent) y la no revocación de OCSP.
Verificación de la delegación: se valida la afirmación de delegación del usuario. La firma demuestra que el titular de la clave del usuario autorizó esta delegación, que la huella digital del certificado del agente que llama aparece en la lista de autorizados y que el certificado del usuario se comprueba mediante el OCSP
.
Verificación cruzada de identidad: el nombre de usuario del token, el asunto de la delegación y el prefijo CN del certificado del agente deben coincidir. Esto confirma la existencia de una cadena de identidad única y coherente desde el usuario hasta la ejecución de la herramienta
.
# Servidor MCP: cuatro comprobaciones de validación
#1. Token: debe estar activo con la audiencia correcta
info = introspección (token)
afirma info ["active"] y «mcp-server» en info ["aud"]
#2. Sobre: prueba de posesión + frescura + repetición + CA + rol + OCSP
payload = verify_envelope (sobre, «mysql-agent», ca_pem, replay_cache)
#3. Delegación: el usuario autorizó este agente y el certificado de usuario no fue revocado
claims = verify_delegation (delegation, agent_cert_pem, ca_pem)
# 4. Verificación cruzada: cadena de identidad coherente
assert token_username == claims ["sub"] == agent_cn.rsplit («_», 1) [0]
# Todas las comprobaciones han sido aprobadas: ejecuta la herramienta
resultado = execute_sql (payload ["args"] ["sql"])
Paso 4: Prevención de repeticiones
Cada sobre firmado lleva un nonce único, una cadena hexadecimal criptográficamente aleatoria de 128 bits generada con el módulo de secretos de Python. El ReplayCache es un almacén en memoria seguro para subprocesos que recuerda cada nonce hasta que caduque su período de actualización (2 veces ENVELOPE_MAX_AGE_SECONDS). Si aparece el mismo nonce en una segunda solicitud, el sobre se rechaza inmediatamente, incluso si su firma es válida y la marca de tiempo es reciente
.
La
validación de la marca de tiempo complementa la verificación del nonce. La marca de tiempo de un sobre debe estar dentro de ENVELOPE_MAX_AGE_SECONDS (60 segundos por defecto) de la hora actual del servidor. En conjunto, estos mecanismos abordan cuatro escenarios
de acceso no autorizado:
Reproducción grabada: un usuario no autorizado captura un sobre válido y lo vuelve a enviar más tarde. El nonce ya estaba visto
.
Entrega retrasada: un sobre interceptado durante el transporte llega pasado el plazo de frescura. La comprobación de la marca de hora
falla.
Reutilización de solicitudes obsoletas: se vuelve a enviar un sobre antiguo almacenado en caché por un proxy. Las comprobaciones nonce y timestamp fallan.
Falsificación precalculada: un usuario no autorizado no puede predecir si quiere firmar previamente los sobres en el futuro.
Paso 5: generación de claves del lado del cliente
Una propiedad de seguridad fundamental de esta arquitectura es que las claves privadas se generan localmente y nunca se transmiten a ningún sistema externo. La aplicación genera más de 2048 pares de claves RSA mediante la biblioteca de criptografía de Python. Crea una CSR que contiene solo la clave pública y la información del asunto, y envía únicamente la CSR a EJBCA a través del punto final pkcs10enroll.
La
EJBCA valida la CSR, aplica el perfil del certificado (validez de 7 días, restricciones de uso de la clave), la firma con la clave de la CA y devuelve el certificado emitido. A continuación, la aplicación agrupa la clave privada local con el certificado devuelto en un contenedor PKCS12 y la almacena en
AWS Secrets Manager.
Este diseño proporciona varias propiedades de seguridad:
La clave privada del usuario solo se usa al iniciar sesión para firmar la afirmación de delegación. Nunca se comparte con los agentes
.
La
clave privada de cada agente solo la usa ese agente para firmar los sobres. Nunca se comparte entre los agentes
.
EJBCA nunca ve ni almacena claves privadas. Funciona únicamente como una autoridad de certificación
.
Si Secrets Manager está sujeto a un acceso no autorizado, la contraseña PKCS12 (que se almacena por separado) añade una capa adicional.
El material clave se puede rotar de forma independiente si se vuelve a inscribir con una nueva CSR la próxima vez que se inicie sesión.
Paso 6: Cierre de sesión completo y revocación de credenciales
El
cierre de sesión desencadena una cascada de revocaciones que invalida inmediatamente todas las credenciales pendientes. La secuencia hace que no queden credenciales válidas
una vez finalizada:
Revocar el certificado de usuario en EJBCA: esto invalida inmediatamente todas las delegaciones pendientes, ya que la verificación de la delegación comprueba el certificado del usuario a través del OCSP en tiempo real.
Revocar los tres certificados de agente: esto invalida todos los sobres firmados pendientes, ya que la verificación de los sobres incluye el OCSP.
Elimine todos los secretos de AWS Secrets Manager: utilice ForceDeleteWithoutRecovery para eliminarlos de forma inmediata sin ventana de recuperación.
Finalizar la sesión de Keycloak: invalida el token reducido en el punto final de finalización de la sesión.
La cascada de revocación es la propiedad clave de seguridad. La revocación de un certificado de usuario único en la capa de PKI revoca inmediatamente toda la autoridad de los agentes intermedios sin necesidad de revocar individualmente los tokens, eliminar sesiones o ponerse en contacto con cada agente. El OCSP proporciona el mecanismo de propagación y, dado que cada solicitud comprueba el OCSP
, el efecto es inmediato.
Consideraciones de seguridad
Las opciones de diseño de esta arquitectura abordan varias propiedades de seguridad que son importantes para las implementaciones de varios agentes en producción.
Aislamiento de
claves privadas. La clave privada del usuario solo existe durante el flujo de inicio de sesión y se usa únicamente para firmar la delegación. Las claves de los agentes se clasifican por agente y nunca se comparten. Ningún material clave sobrepasa los límites de la confianza
.
La delegación en comparación con el intercambio de credenciales. Los agentes demuestran su autoridad a través de una cadena criptográfica (delegando la huella dactilar del agente hasta la firma del sobre) sin tener nunca en sus manos las credenciales de los usuarios. Si se descubre la clave de un agente, solo se revela la clave de ese agente, no la del usuario
.
Tokens con alcance de audiencia. El intercambio de tokens según la RFC 8693 produce un token que solo acepta el servidor MCP. Un token con un alcance reducido divulgado de forma inadvertida no puede autenticarse en las API de administración de Keycloak, en otros
servicios o incluso en una instancia de servidor MCP diferente.
Prevención de repeticiones. La combinación de no caducar por solicitud y un período de actualización de 60 segundos confirma que cada solicitud es de un solo uso y tiene un límite de tiempo. El ReplayCache
es seguro para subprocesos y se limpia automáticamente.
Diseño cerrado a prueba de fallos. Cada error de validación resulta en una denegación inmediata. OCSP inalcanzable: denegación. Firma no válida: denegar. Marca de tiempo caducada: denegar. Reproducido no una vez: denegar. Público equivocado: negar. Los controles de seguridad no se degradan fácilmente
.
Cascada de
revocación. La revocación inmediata de un certificado de usuario invalida todas las delegaciones, todas las facultades de los agentes y todos los sobres pendientes. Esto se propaga a través del OCSP en tiempo real sin necesidad
de limpiar las credenciales de forma individual.
Cadena de confianza exclusiva para el futuro. El mapa ALLOWED_CALLER_ROLES establece que solo Orchestrator-agent puede llamar a mysql-agent y email-agent. Los subagentes no pueden llamarse entre sí, no pueden llamar al orquestador
y no pueden hacerse pasar por el usuario.
Consideraciones de gobernanza de la IA
La arquitectura de PKI proporciona límites de comportamiento integrados para los agentes de IA de este sistema. Las implementaciones de producción deben utilizar Amazon Bedrock Guardrails para aplicar el filtrado de contenido, evitar temas y comprobar las respuestas de los agentes desde tierra, junto con los controles de acceso basados en la PKI que se describen
en esta publicación.
Límites de herramientas: el agente de IA opera bajo estrictas restricciones de herramientas. Solo puede invocar herramientas MCP predefinidas (execute_sql, describe_table, list_tables). El agente no puede ejecutar código arbitrario ni
acceder a recursos fuera del alcance de su certificado.
Supervisión humana: todas las acciones del agente se registran y son auditables. AWS CloudTrail captura las llamadas a la API de AWS y el servidor MCP registra todas las invocaciones de herramientas validadas con la cadena de identidad completa (usuario, agente, marca de tiempo y operación
).
Gestión de datos: las consultas y los resultados de los usuarios se mantienen dentro del límite de la sesión autenticada. El token orientado a la audiencia limita el acceso a los datos a
la instancia específica del servidor MCP.
Límites de comportamiento basados en certificados: los agentes solo pueden invocar las herramientas para las que tengan certificados válidos. Un agente sin un certificado de mysql-agent no puede acceder a la base de datos, independientemente de lo que el
LLM pueda generar como instrucciones.
Ampliación de la arquitectura
Puede ampliar esta arquitectura para admitir otros tipos de agentes, el escalado horizontal y el aislamiento de varios inquilinos. En los siguientes párrafos se describen los puntos de extensión más comunes
.
Para agregar nuevos tipos de agentes, solo necesita agregar una entrada en ALLOWED_CALLER_ROLES. Los certificados se emiten automáticamente al iniciar sesión y la afirmación de delegación incluye de forma dinámica la huella digital del nuevo agente. No se requieren cambios en la infraestructura
.
Para el escalado horizontal, puede implementar el respondedor OCSP de EJBCA en modo de alta disponibilidad detrás de un balanceador de carga. AWS Secrets Manager admite altas tasas de solicitud adecuadas para esta carga de trabajo. Amazon ElastiCache puede respaldar ReplayCache para las
implementaciones distribuidas.
Para reforzar la arquitectura de producción, puede usar claves de firma EJBCA respaldadas por un módulo de seguridad de hardware (HSM) a través de AWS CloudHSM o un HSM local. El grapado de respuestas de OCSP reduce la latencia de validación y los registros de transparencia de los certificados proporcionan un registro de auditoría completo de los certificados emitidos
.
Para las implementaciones con varios inquilinos, puede crear autoridades de certificación por inquilino o autoridades de delegación por inquilino para el aislamiento criptográfico de los inquilinos. En combinación con las cuentas de AWS por inquilino, esto
ofrece un fuerte aislamiento entre los inquilinos.
También puede complementar la identidad de los agentes basada en la PKI con las funciones de administración de identidades y accesos (IAM) de AWS. Utilice la PKI para la autenticación de agente a agente y la IAM para la autorización de los servicios de AWS. Los dos sistemas funcionan de forma independiente y proporcionan una defensa en profundidad
.
Limpiar
Para evitar cargos continuos, elimine los recursos creados durante este tutorial:
Elimine la instancia de Amazon RDS para MySQL (o la pila de AWS CloudFormation si utilizó la configuración con scripts).
Elimine todos los secretos de AWS Secrets Manager, incluidos los certificados de usuario y los certificados de agente con el prefijo mcp/.
Elimine la dirección de correo electrónico del remitente verificada de Amazon SES.
Cierre las instancias de Amazon EC2 que ejecuten Keycloak y EJBCA (si están implementadas para esta demostración).
Revoca y elimina todos los certificados de prueba en EJBCA mediante la consola de administración de EJBCA o la API REST.
Elimine el dominio Keycloak (mcp-realm) y los clientes asociados.
Si utilizó la configuración basada en scripts, ejecute. /scripts/cleanup.sh (Linux) o. /scripts/cleanup.bat (Windows) para automatizar estos pasos.
Conclusión
En esta publicación, mostramos una arquitectura de referencia para proteger las comunicaciones de los agentes de IA mediante la PKI X.509 con los servicios Keyfactor EJBCA y AWS. La arquitectura aborda la brecha de identidad fundamental en los sistemas de IA con múltiples agentes
a través de cuatro mecanismos complementarios:
Los sobres de solicitud firmados proporcionan una prueba criptográfica de posesión en cada llamada entre agentes, lo que hace que sea mucho más difícil para una parte no autorizada falsificar la identidad de un agente o reproducir sus solicitudes.
Las afirmaciones de delegación firmadas por los usuarios desvinculan la autorización del intercambio de credenciales. Los agentes demuestran que están autorizados a actuar en nombre del usuario sin tener la clave privada del usuario ni el token de sesión completa
.
Los tokens con alcance de audiencia según el RFC 8693 limitan el alcance de cualquier divulgación de un token a un único límite de servicio.
La
comprobación de revocación por OCSP en tiempo real confirma que la revocación de credenciales surte efecto de forma inmediata en todo el sistema. La revocación de un certificado de usuario pone fin inmediatamente
a toda la autoridad de los agentes intermedios.
Esta arquitectura es independiente del marco. Si bien lo demostramos con el SDK de AWS Strands Agents y FastMCP, los mismos patrones de PKI se aplican a LangChain, CrewAI, AutoGen o cualquier otro marco multiagente que utilice protocolos de herramientas. A medida que los agentes de IA proliferan y obtienen acceso a operaciones cada vez más delicadas, la infraestructura de identidad de los agentes pasa de ser opcional a
esencial.
Para comenzar con esta arquitectura de referencia, consulta el repositorio de GitHub adjunto. Para obtener más información sobre los servicios utilizados, consulta los siguientes recursos:
When AI agents access databases, APIs, and sensitive business operations, establishing cryptographic identity through X.509 public key infrastructure (PKI) becomes a critical requirement. The core challenge is proving which agent made a request, preventing forgery between agents, and confirming that each agent acts only on behalf of an authorized user. Traditional approaches such as sharing API keys between components or passing OAuth tokens through agent chains fall short of the zero-trust requirements that enterprise deployments demand.
Multi-agent AI frameworks increasingly use the Model Context Protocol (MCP) to connect agents to external tools and data sources. MCP defines how a large language model (LLM)-powered agent invokes tools such as database queries or email operations. However, MCP has no built-in authentication standard. It is transport-agnostic by design. This creates a critical gap: Without proper identity mechanisms, any component could impersonate an agent, replay intercepted credentials, or invoke tools without authorization.
In this post, we show you how to address this gap using Keyfactor EJBCA combined with AWS services. EJBCA is a PKI platform that supports high-availability deployment, REST API automation, and Online Certificate Status Protocol (OCSP) validation. The reference architecture uses four complementary security mechanisms. First, signed request envelopes provide cryptographic proof-of-possession on every agent call. Second, user-signed delegation assertions authorize agents without sharing credentials. Third, RFC 8693 audience-scoped tokens limit the scope of exposure from any single token disclosure. Fourth, real-time OCSP revocation checking propagates credential changes immediately across all agents.
The solution uses Amazon Bedrock for LLM inference through the AWS Strands Agents SDK. While this reference architecture uses a database as the protected resource, the same authentication pattern applies to any MCP-compatible tool server. Complete source code for all examples is available in the accompanying GitHub repository.
About Keyfactor EJBCA
Keyfactor provides a widely adopted machine identity management platform used by more than 1,500 enterprise customers worldwide, according to Keyfactor. These organizations span financial services, healthcare, manufacturing, and government. Keyfactor helps organizations establish and maintain cryptographic trust through certificate lifecycle management, PKI operations, and machine identity governance.
EJBCA Enterprise is Keyfactor’s Certificate Authority (CA) and PKI platform, designed for high-availability deployment and REST API automation. Available as an enterprise product, EJBCA provides X.509 certificate issuance, OCSP validation, certificate revocation list (CRL) distribution, and full certificate lifecycle management through both a web console and REST API. EJBCA supports deployment on-premises, in containers, or on Amazon Elastic Compute Cloud (Amazon EC2).
The partnership between AWS and Keyfactor brings together AWS managed services (Amazon Bedrock, AWS Secrets Manager, Amazon Relational Database Service (Amazon RDS)) with PKI infrastructure that supports certificate lifecycle management, automated enrollment, and real-time revocation. This combination addresses a gap in the AI agent ecosystem. While AWS provides the compute, storage, and AI inference layers, Keyfactor provides the cryptographic identity layer that binds agents to verifiable, revocable, short-lived credentials. This joint reference architecture, developed collaboratively by the AWS and Keyfactor engineering teams, demonstrates how to integrate these technologies. You can adapt the patterns shown here to your own multi-agent deployments.
Solution overview
The architecture implements three authentication layers, each addressing a different trust boundary in the agent communication chain. These three layers use the four security mechanisms introduced earlier: signed envelopes for proof-of-possession, delegation assertions for credential-free authorization, audience-scoped tokens for exposure limitation, and OCSP for real-time revocation. The mechanisms combine across layers as shown in the following table.
Layer
Trust boundary
Mechanism
Validates
1. User Auth
User to System
OAuth + X.509 cert + delegation minting
User identity, credential binding
2. Agent-to-Agent
Agent to Agent
Signed envelopes (PoP + nonce + timestamp)
Caller identity, request freshness, no replay
3. MCP Auth
Agent to Tool Server
Scoped token + envelope + delegation
All identities, authorization chain, OCSP
Figure 1 shows the three authentication layers and how credentials flow between the user, agents, and the MCP tool server. The diagram illustrates the separation between user credentials (which stay in the login flow), agent credentials (scoped per agent), and the delegation chain that connects them.
Figure 1: Three-layer PKI authentication architecture for AI agent systems on AWS
Figure 2 illustrates the detailed traffic flow during a typical user session. It shows the sequence of authentication steps from login through certificate issuance, agent delegation, tool invocation, and session cleanup.
Figure 2: Authentication traffic flow from user login through agent delegation, tool invocation, and session cleanup
AWS services used
The following AWS services form the foundation of the reference architecture.
Service
Purpose
Amazon Bedrock
LLM inference through Strands Agents SDK
Amazon RDS for MySQL
Application database accessed through MCP tools
Amazon Simple Email Service (Amazon SES)
Email delivery for the Email Agent
AWS Secrets Manager
Secure storage for PKCS12 bundles, tokens, and metadata
Amazon EC2
Hosts Keycloak IDP and EJBCA PKI server
Solution walkthrough
The following steps walk through each component of the architecture, from initial user login through to session cleanup. Each step builds on the previous one, establishing a chain of trust that connects the human user to the final tool execution.
Prerequisites
An active AWS account with access to Amazon Bedrock, Amazon RDS for MySQL, Amazon SES, and AWS Secrets Manager.
Keycloak 26.2 or later (required for RFC 8693 standard token exchange. Previous versions use a legacy exchange that is incompatible).
Keyfactor EJBCA Enterprise with REST API V1 and an OCSP responder configured.
EJBCA API administrator certificate (api-admin.p12) for REST API authentication.
Python 3.9+ development environment.
Familiarity with X.509 certificates, OCSP, OAuth 2.0, RSA digital signatures, and PKCS#12 key stores.
Step 1: User login, certificate issuance, and delegation minting
The login flow establishes the user’s identity through three mechanisms and then delegates authority to the AI agents without sharing the user’s credentials. This separation is critical: Agents receive proof of authorization without ever holding the user’s private key or full-session OAuth token.
First, the application authenticates the user against Keycloak using an OAuth 2.0 password grant, receiving a full-session access token and refresh token. Immediately after, the application performs an RFC 8693 token exchange to obtain a downscoped token. This token’s audience is restricted to the MCP server. Only this limited token is handed to agents. If it’s inadvertently exposed, it can’t access any other service in the organization.
Second, the application generates an RSA 2048+ key pair locally and submits a Certificate Signing Request (CSR) to EJBCA through the pkcs10enroll REST API endpoint. EJBCA signs the CSR and returns the certificate. The application bundles the certificate and private key into a PKCS12 container and stores it in AWS Secrets Manager. The private key never leaves the application boundary. It is not sent to EJBCA, not shared with agents, and not stored on the filesystem. Three agent certificates are issued using the same CSR-based flow, one per agent role.
Third, the user’s private key signs a delegation assertion. This is a JSON document listing the SHA-256 fingerprints of all three agent certificates, along with the user’s subject name, issuance time, and expiry. This delegation proves that the user authorized these specific agents to act on their behalf. Agents carry this delegation instead of the user’s certificate.
When the orchestrator agent routes a request to a sub-agent (such as the MySQL agent or Email agent), it does not simply pass its certificate for identification. Instead, it signs the entire request payload, including the tool name, arguments, a timestamp, and a cryptographically random nonce, using its private key with RSA-PSS-SHA256. The resulting signed envelope provides proof-of-possession. The receiving agent can verify that the caller actually holds the private key corresponding to the presented certificate.
The receiving agent performs six validation checks on the envelope before processing the request:
Signature verification: Proves the sender possesses the private key (proof-of-possession).
Timestamp freshness: The envelope must be within ENVELOPE_MAX_AGE_SECONDS (default 60 seconds) of the current time.
Nonce uniqueness: The ReplayCache rejects any previously seen nonce, preventing request replay.
CA chain validation: The sender’s certificate must chain to the trusted CA (UserCA.pem).
Role authorization: The certificate CN’s role suffix must be in ALLOWED_CALLER_ROLES for this agent.
OCSP revocation check: A real-time check against EJBCA confirms the certificate has not been revoked.
If the orchestrator needs to re-send the same prompt (for example, after a transient failure), it must create a new envelope with a fresh nonce. Old envelopes can’t be replayed, even by the legitimate sender.
The MCP server (FastMCP) is the final trust boundary before any database operation runs. It performs four validation checks on every tool invocation, implementing defense-in-depth. Even if one credential is subject to unauthorized access, the remaining checks prevent unauthorized operations.
The authentication sequence:
Token introspection: A POST to the Keycloak /token/introspect endpoint verifies the token is active and its audience contains “mcp-server”. A full-session token without the correct audience is rejected.
Envelope verification: The agent’s signed envelope is validated for signature correctness, timestamp freshness, nonce uniqueness, CA chain trust, role match (mysql-agent), and OCSP non-revocation.
Delegation verification: The user’s delegation assertion is validated. The signature proves the user’s key holder authorized this delegation, the calling agent’s certificate fingerprint appears in the authorized list, and the user’s certificate is checked through OCSP.
Identity cross-check: The token username, the delegation subject, and the agent certificate CN prefix must all match. This confirms a single consistent identity chain from user through to tool execution.
# MCP Server - Four validation checks
# 1. Token: must be active with correct audience
info = introspect(token)
assert info["active"] and "mcp-server" in info["aud"]
# 2. Envelope: proof-of-possession + freshness + replay + CA + role + OCSP
payload = verify_envelope(envelope, "mysql-agent", ca_pem, replay_cache)
# 3. Delegation: user authorized this agent + user cert not revoked
claims = verify_delegation(delegation, agent_cert_pem, ca_pem)
# 4. Cross-check: consistent identity chain
assert token_username == claims["sub"] == agent_cn.rsplit("_", 1)[0]
# All checks passed - execute tool
result = execute_sql(payload["args"]["sql"])
Step 4: Replay prevention
Every signed envelope carries a unique nonce, a 128-bit cryptographically random hex string generated with Python’s secrets module. The ReplayCache is a thread-safe in-memory store that remembers every nonce until its freshness window expires (2x ENVELOPE_MAX_AGE_SECONDS). If the same nonce appears in a second request, the envelope is immediately rejected, even if its signature is valid and the timestamp is fresh.
The timestamp validation complements the nonce check. An envelope’s timestamp must be within ENVELOPE_MAX_AGE_SECONDS (default 60 seconds) of the server’s current time. Together, these mechanisms address four unauthorized access scenarios:
Recorded replay: An unauthorized user captures a valid envelope and resubmits it later. The nonce was already seen.
Delayed delivery: An envelope intercepted in transit arrives after the freshness window. The timestamp check fails.
Stale request reuse: An old envelope cached by a proxy is resubmitted. Both nonce and timestamp checks fail.
Precomputed forgery: An unauthorized user cannot predict future nonces to pre-sign envelopes.
Step 5: Client-side key generation
A critical security property of this architecture is that private keys are generated locally and never transmitted to any external system. The application generates RSA 2048+ key pairs using the Python cryptography library. It constructs a CSR containing only the public key and subject information, and sends only the CSR to EJBCA through the pkcs10enroll endpoint.
EJBCA validates the CSR, applies the certificate profile (7-day validity, key usage constraints), signs it with the CA key, and returns the issued certificate. The application then bundles the locally held private key with the returned certificate into a PKCS12 container and stores it in AWS Secrets Manager.
This design provides several security properties:
The user’s private key is used only at login to sign the delegation assertion. It’s never shared with agents.
Each agent’s private key is used only by that agent to sign envelopes. It’s never shared between agents.
EJBCA never sees or stores private keys. It operates purely as a certificate authority.
If Secrets Manager is subject to unauthorized access, the PKCS12 password (stored separately) adds an additional layer.
Key material can be rotated independently by re-enrolling with a new CSR at next login.
Step 6: Complete logout and credential revocation
Logout triggers a revocation cascade that immediately invalidates all outstanding credentials. The sequence results in no remaining valid credentials after completion:
Revoke user certificate in EJBCA: This immediately invalidates all outstanding delegations, because delegation verification checks the user’s certificate through OCSP in real time.
Revoke all three agent certificates: This invalidates all outstanding signed envelopes, since envelope verification includes OCSP.
Delete all secrets from AWS Secrets Manager: Using ForceDeleteWithoutRecovery for immediate removal with no recovery window.
Terminate Keycloak session: Invalidates the downscoped token through the session termination endpoint.
The revocation cascade is the key security property. Revoking a single user certificate at the PKI layer promptly revokes all downstream agent authority without needing to individually revoke tokens, delete sessions, or contact each agent. OCSP provides the propagation mechanism, and because every request checks OCSP, the effect is immediate.
Security considerations
The design choices in this architecture address several security properties that are important for production multi-agent deployments.
Private key isolation. The user’s private key exists only during the login flow and is used solely to sign the delegation. Agent keys are scoped per-agent and never shared. No key material crosses trust boundaries.
Delegation compared to credential sharing. Agents prove their authority through a cryptographic chain (delegation to agent fingerprint to envelope signature) without ever holding user credentials. If an agent key is exposed, only that agent’s key is revealed, not the user’s.
Audience-scoped tokens. RFC 8693 token exchange produces a token accepted only by the MCP server. An inadvertently disclosed downscoped token cannot authenticate against Keycloak admin APIs, other services, or even a different MCP server instance.
Replay prevention. The combination of per-request nonces and a 60-second freshness window confirms that every request is single-use and time-bound. The ReplayCache is thread-safe and self-cleaning.
Fail-closed design. Every validation failure results in immediate denial. OCSP unreachable: deny. Invalid signature: deny. Expired timestamp: deny. Replayed nonce: deny. Wrong audience: deny. There’s no graceful degradation for security checks.
Revocation cascade. Revoking one user certificate promptly invalidates all delegations, all agent authority, and all outstanding envelopes. This is propagated through real-time OCSP without requiring individual credential cleanup.
Forward-only trust chain. The ALLOWED_CALLER_ROLES map enforces that only orchestrator-agent can call mysql-agent and email-agent. Sub-agents cannot call each other, can’t call upward to the orchestrator, and cannot impersonate the user.
AI governance considerations
The PKI architecture provides built-in behavior boundaries for the AI agents in this system. Production deployments should use Amazon Bedrock Guardrails to enforce content filtering, topic avoidance, and grounding checks on agent responses, alongside the PKI-based access controls described in this post.
Tool boundaries: The AI agent operates under strict tool constraints. It can only invoke pre-defined MCP tools (execute_sql, describe_table, list_tables). The agent can’t execute arbitrary code or access resources outside its certificate scope.
Human oversight: All agent actions are logged and auditable. AWS CloudTrail captures AWS API calls, and the MCP server logs every validated tool invocation with the full identity chain (user, agent, timestamp, and operation).
Data handling: User queries and results stay within the authenticated session boundary. The audience-scoped token confines data access to the specific MCP server instance.
Certificate-based behavior boundaries: Agents can only invoke tools they hold valid certificates for. An agent without a mysql-agent certificate cannot access the database, regardless of what the LLM might generate as instructions.
Extending the architecture
You can extend this architecture to support additional agent types, horizontal scaling, and multi-tenant isolation. The following paragraphs describe the most common extension points.
To add new agent types, you only need to add an entry in ALLOWED_CALLER_ROLES. Certificates are automatically issued at login, and the delegation assertion dynamically includes the new agent’s fingerprint. No infrastructure changes are required.
For horizontal scaling, you can deploy EJBCA’s OCSP responder in high-availability mode behind a load balancer. AWS Secrets Manager supports high request rates suitable for this workload. The ReplayCache can be backed by Amazon ElastiCache for distributed deployments.
To harden the architecture for production, you can use hardware security module (HSM)-backed EJBCA signing keys through AWS CloudHSM or an on-premises HSM. OCSP response stapling reduces validation latency, and Certificate Transparency logs provide a full audit trail of issued certificates.
For multi-tenant deployments, you can create per-tenant Certificate Authorities or per-tenant delegation authorities for cryptographic tenant isolation. Combined with per-tenant AWS accounts, this delivers strong isolation between tenants.
You can also complement PKI-based agent identity with AWS Identity and Access Management (IAM) roles. Use PKI for agent-to-agent authentication and IAM for AWS service authorization. The two systems work independently, providing defense in depth.
Clean up
To avoid ongoing charges, remove the resources created during this walkthrough:
Delete the Amazon RDS for MySQL instance (or the AWS CloudFormation stack if you used the scripted setup).
Delete all secrets from AWS Secrets Manager, including user certificates and agent certificates under the mcp/ prefix.
Remove the verified sender email address from Amazon SES.
Terminate the Amazon EC2 instances running Keycloak and EJBCA (if deployed for this demonstration).
Revoke and delete all test certificates in EJBCA by using the EJBCA admin console or REST API.
Remove the Keycloak realm (mcp-realm) and associated clients.
If you used the scripted setup, run ./scripts/cleanup.sh (Linux) or ./scripts/cleanup.bat (Windows) to automate these steps.
Conclusion
In this post, we demonstrated a reference architecture for securing AI agent communications using X.509 PKI with Keyfactor EJBCA and AWS services. The architecture addresses the fundamental identity gap in multi-agent AI systems through four complementary mechanisms:
Signed request envelopes provide cryptographic proof-of-possession on every inter-agent call, making it significantly harder for an unauthorized party to forge an agent’s identity or replay its requests.
User-signed delegation assertions decouple authorization from credential sharing. Agents prove they are authorized to act on the user’s behalf without holding the user’s private key or full-session token.
RFC 8693 audience-scoped tokens limit the scope of exposure from any token disclosure to a single service boundary.
Real-time OCSP revocation checking confirms that credential revocation takes immediate effect across the entire system. Revoking one user certificate promptly ends all downstream agent authority.
This architecture is framework-agnostic. While we demonstrated it with the AWS Strands Agents SDK and FastMCP, the same PKI patterns apply to LangChain, CrewAI, AutoGen, or any other multi-agent framework that uses tool protocols. As AI agents proliferate and gain access to increasingly sensitive operations, agent identity infrastructure moves from optional to essential.
To get started with this reference architecture, see the accompanying GitHub repository. For more information about the services used, see the following resources: