Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Verificación de tokens web JSON
Los tokens web JSON (JWTs) se pueden decodificar, leer y modificar fácilmente. Un token de acceso modificado crea el riesgo de que se produzca un escalado de privilegios. Un token de ID modificado crea un riesgo de suplantación de identidad. La aplicación confía en el grupo de usuarios como emisor del token, pero ¿qué sucede si un usuario intercepta el token en tránsito? Debe asegurarse de que la aplicación reciba el token que Amazon Cognito ha emitido.
Amazon Cognito emite tokens que utilizan algunas de las características de integridad y confidencialidad de la especificación OpenID Connect (OIDC). Los tokens del grupo de usuarios indican la validez con objetos como la fecha de caducidad, el emisor y la firma digital. La firma, que es el tercer y último segmento del JWT delimitado por `.`, es el componente clave de la validación del token. Un usuario malintencionado puede modificar un token, pero si la aplicación recupera la clave pública y la compara con la firma, no coincidirán. Cualquier aplicación que procese la autenticación JWTs desde el OIDC debe realizar esta operación de verificación con cada inicio de sesión.
En esta página, hacemos algunas recomendaciones generales y específicas para la verificación de. JWTs El desarrollo de aplicaciones abarca diversos lenguajes de programación y plataformas. Dado que Amazon Cognito implementa OIDC lo suficientemente cerca de la especificación pública, cualquier biblioteca de JWT acreditada del entorno de desarrollador que elija puede gestionar los requisitos de verificación.
En estos pasos, se describe cómo verificar un JSON Web Token (JWT) de grupo de usuarios.
**Topics**
+ [Requisitos previos](#amazon-cognito-user-pools-using-tokens-prerequisites)
+ [Valide los tokens con aws-jwt-verify](#amazon-cognito-user-pools-using-tokens-aws-jwt-verify)
+ [Descripción e inspección de tokens](#amazon-cognito-user-pools-using-tokens-manually-inspect)
## Requisitos previos
Es posible que tu biblioteca, SDK o marco de software ya se encarguen de las tareas de esta sección. AWS SDKs proporciona herramientas para gestionar y gestionar los tokens del grupo de usuarios de Amazon Cognito en tu aplicación. AWS Amplify incluye funciones para recuperar y actualizar los tokens de Amazon Cognito.
Para obtener más información, consulte las páginas siguientes.
+ [Integración de la autenticación y la autorización de Amazon Cognito con aplicaciones web y móviles](cognito-integrate-apps.md)
+ [Ejemplos de código para Amazon Cognito Identity Provider mediante AWS SDKs](https://docs.aws.amazon.com/cognito/latest/developerguide/service_code_examples.html)
+ [Flujos de trabajo avanzados](https://docs.amplify.aws/lib/auth/advanced/q/platform/js/#retrieve-jwt-tokens) en *Amplify Dev Center*
Hay muchas bibliotecas disponibles para decodificar y verificar un JSON Web Token (JWT). Estas bibliotecas pueden resultarle de ayuda si desea procesar de forma manual los tokens para el procesamiento de la API del lado del servidor o si utiliza otros lenguajes de programación. Consulte la [lista de bibliotecas de OpenID Foundation para trabajar con tokens JWT](http://openid.net/developers/jwt/).
## Valide los tokens con aws-jwt-verify
En una aplicación de Node.js, AWS recomienda que la [aws-jwt-verifybiblioteca](https://github.com/awslabs/aws-jwt-verify) valide los parámetros del token que el usuario pasa a la aplicación. Con `aws-jwt-verify`, puede rellenar `CognitoJwtVerifier` con los valores de las reclamaciones que desea verificar para uno o varios grupos de usuarios. Estos son algunos de los valores que puede comprobar:
+ Que esos tokens de acceso o ID no tengan un formato incorrecto ni hayan caducado y tengan una firma válida.
+ Que esos tokens de acceso procedan de los [grupos de usuarios y clientes de aplicaciones correctos](https://github.com/awslabs/aws-jwt-verify#verifying-jwts-from-amazon-cognito).
+ Las afirmaciones del token de acceso contienen los [alcances OAuth 2.0 correctos](https://github.com/awslabs/aws-jwt-verify#checking-scope).
+ Que las claves que firmaron sus tokens de acceso e ID [coincidan con una clave `kid` de firma del *URI de JWKS* de sus grupos de usuarios](https://github.com/awslabs/aws-jwt-verify#the-jwks-cache).
El URI de JWKS contiene información pública sobre la clave privada que firmó el token de su usuario. Puede encontrar el URI de JWKS para su grupo de usuarios en `https://cognito-idp..amazonaws.com//.well-known/jwks.json`.
Para obtener más información y un código de ejemplo que puede usar en una aplicación de Node.js o en un AWS Lambda autorizador, consulte [https://github.com/awslabs/aws-jwt-verify](https://github.com/awslabs/aws-jwt-verify). GitHub
## Descripción e inspección de tokens
Antes de integrar la inspección de tokens en su aplicación, considere cómo se ensambla Amazon Cognito. JWTs Obtenga tokens de ejemplo de su grupo de usuarios. Decodifíquelos y examínelos bien para conocer sus características y determinar qué desea verificar y cuándo. Por ejemplo, es posible que desee examinar la pertenencia a un grupo en un escenario y los ámbitos en otro.
En las siguientes secciones se describe un proceso para inspeccionar manualmente Amazon Cognito JWTs mientras prepara la aplicación.
### Confirmar la estructura del JWT
Un token web JSON (JWT) incluye tres secciones con un delimitador `.` (punto) entre ellas.
**Encabezado**
El ID de clave, `kid`, y el algoritmo RS, `alg`, que Amazon Cognito utilizó para firmar el token. Amazon Cognito firma los tokens con un `alg` de `RS256`. `kid` es una referencia truncada a una clave de firma privada RSA de 2048 bits que se encuentra en poder del grupo de usuarios.
**Carga útil**
Reclamaciones de tokens. En un token de ID, las reclamaciones incluyen atributos de usuario e información sobre el grupo de usuarios, `iss`, y el cliente de la aplicación, `aud`. En un token de acceso, la carga incluye los ámbitos, la pertenencia a grupos, el nombre de su grupo de usuarios como `iss` y el de su cliente de aplicación como `client_id`.
**Signature**
La firma no se puede descodificar en base64url como el encabezado y la carga útil. Es un RSA256 identificador derivado de una clave de firma y de parámetros que puedes observar en tu URI de JWKS.
El encabezado y la carga útil son JSON y están codificados en base64url. Puede identificarlos por los caracteres de apertura `eyJ` que se descodifican para formar el carácter inicial `{`. Si su usuario presenta un JWT codificado en base64url a su aplicación y no está en el formato `[JSON Header].[JSON Payload].[Signature]`, no es un token de Amazon Cognito válido, por lo que puede descartarlo.
El siguiente ejemplo de aplicación verifica los tokens del grupo de usuarios con `aws-jwt-verify`.
```
// cognito-verify.js
// Usage example: node cognito-verify.js eyJra789ghiEXAMPLE
const { CognitoJwtVerifier } = require('aws-jwt-verify');
// Replace with your Amazon Cognito user pool ID
const userPoolId = 'us-west-2_EXAMPLE';
async function verifyJWT(token) {
try {
const verifier = CognitoJwtVerifier.create({
userPoolId,
tokenUse: 'access', // or 'id' for ID tokens
clientId: '1example23456789', // Optional, only if you need to verify the token audience
});
const payload = await verifier.verify(token);
console.log('Decoded JWT:', payload);
} catch (err) {
console.error('Error verifying JWT:', err);
}
}
// Example usage
if (process.argv.length < 3) {
console.error('Please provide a JWT token as an argument.');
process.exit(1);
}
const MyToken = process.argv[2];
verifyJWT(MyToken);
```
### Validación del JWT
La firma JWT es una combinación con hash del encabezado y la carga útil. Amazon Cognito genera dos pares de claves criptográficas RSA para cada grupo de usuarios. Una clave privada firma los tokens de acceso y la otra firma los tokens de ID.
**Para verificar la firma de un token JWT**
1. Descodifique el token de ID.
OpenID Foundation también [mantiene una lista de bibliotecas para trabajar con tokens JWT](http://openid.net/developers/jwt/).
También se puede utilizar AWS Lambda para decodificar el grupo de usuarios. JWTs Para obtener más información, consulte [Decodificar y verificar los tokens JWT de Amazon Cognito mediante](https://github.com/awslabs/aws-support-tools/tree/master/Cognito/decode-verify-jwt). AWS Lambda
1. Compare el ID de clave local (`kid`) con el `kid` público.
1. Descargue y almacene la JSON Web Key (JWK) pública correspondiente del grupo de usuarios. Está disponible como parte de un JSON Web Key Set (JWKS). Para localizarla, construya la siguiente URI `jwks_uri` para su entorno:
```
https://cognito-idp..amazonaws.com//.well-known/jwks.json
```
Para obtener más información sobre JWK y los conjuntos JWK, consulte [JSON Web Key (JWK)](https://tools.ietf.org/html/rfc7517).
**nota**
Es posible que Amazon Cognito rote las claves de firma en su grupo de usuarios. Como práctica recomendada, almacene en caché las claves públicas en su aplicación utilizando el `kid` como clave de caché y actualice la caché periódicamente. Compare el `kid` de los tokens que recibe su aplicación con su caché.
Si recibe un token con el emisor correcto pero con un `kid` diferente, es posible que Amazon Cognito haya rotado la clave de firma. Actualice la memoria caché desde el punto de conexión `jwks_uri` de su grupo de usuarios.
Este es un archivo `jwks.json` de muestra:
```
{
"keys": [{
"kid": "1234example=",
"alg": "RS256",
"kty": "RSA",
"e": "AQAB",
"n": "1234567890",
"use": "sig"
}, {
"kid": "5678example=",
"alg": "RS256",
"kty": "RSA",
"e": "AQAB",
"n": "987654321",
"use": "sig"
}]
}
```
**ID de clave (`kid`)**
El parámetro `kid` es una sugerencia que indica la clave que se ha utilizado para proteger la firma web JSON (JWS) del token.
**Algoritmo (`alg`)**
El parámetro de encabezado `alg` representa el algoritmo criptográfico que se utiliza para proteger el token de ID. Los grupos de usuarios utilizan un algoritmo RS256 criptográfico, que es una firma RSA con el SHA-256. Para obtener más información sobre RSA, consulte [Criptografía de RSA](https://tools.ietf.org/html/rfc3447).
**Tipo de clave (`kty`)**
El parámetro `kty` identifica la familia de algoritmos criptográficos que se utilizan con la clave, como “RSA” en este ejemplo.
**Exponente RSA (`e`)**
El parámetro `e` contiene el valor del exponente de la clave pública RSA. Se representa como un valor codificado en una URL en Base64. UInt
**Módulo RSA (`n`)**
El parámetro `n` contiene el valor del módulo de la clave pública RSA. Se representa como un valor codificado en Base64URLUInt.
**Uso (`use`)**
El parámetro `use` describe el uso previsto de la clave pública. En este ejemplo, el `use` valor `sig` representa la firma.
1. Busque la clave JSON web pública para un `kid` que coincida con el `kid` del JWT.
### Comprobar las notificaciones
**Para comprobar las notificaciones JWT**
1. Mediante uno de los siguientes métodos, compruebe que el token no haya caducado.
1. Descodifique el token y compare la reclamación `exp` con la hora actual.
1. Si tu token de acceso incluye una `aws.cognito.signin.user.admin` reclamación, envía una solicitud a una API similar. [GetUser](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_GetUser.html) Las solicitudes de API que [autorice con un token de acceso](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pools-API-operations.html#user-pool-apis-auth-unauth) devuelven un error si el token ha caducado.
1. Presente el token de acceso en una solicitud a [El punto de conexión userInfo](userinfo-endpoint.md). La solicitud devuelve un error si el token ha caducado.
1. La afirmación `aud` en un token de ID y la afirmación `client_id` de un token de acceso deberían coincidir con el ID de cliente de la aplicación creado en el grupo de usuarios de Amazon Cognito.
1. La notificación de emisor (`iss`) debería coincidir con el grupo de usuarios. Por ejemplo, un grupo de usuarios creado en la región `us-east-1` tendrá el siguiente valor `iss`:
`https://cognito-idp.us-east-1.amazonaws.com/`.
1. Compruebe la notificación `token_use`.
+ Si solo acepta el token de acceso en las operaciones de la API web, su valor debe ser `access`.
+ Si solo usa el token de ID, su valor debe ser `id`.
+ Si utiliza tokens de ID y de acceso, la notificación `token_use` debe ser `id` o `access`.
Ahora puede confiar en las notificaciones del token.