Bassin d'utilisateurs de Cognito: comment rafraîchir le Token D'accès en utilisant le Token de rafraîchissement

si vous êtes dans une situation où le SDK JavaScript de Cognito ne va pas fonctionner à vos fins, vous pouvez toujours voir comment il gère le processus de rafraîchissement dans le SDK source:

Vous pouvez le voir dans refreshSession que le Cognito InitiateAuth le paramètre est appelé avec REFRESH_TOKEN_AUTH set AuthFlow valeur, et un objet transmis en tant que AuthParameters valeur.

cet objet devra être configuré pour répondre aux besoins de votre Pool D'utilisateurs. En particulier, vous pouvez avoir à passer dans votre SECRET_HASH si votre ID de client App ciblé a un secret de client App associé. Les applications Client créées pour être utilisées avec le SDK Javascript ne peuvent pas contenir de secret client, et donc un SECRET_HASH n'est pas nécessaire de se connecter avec eux.

une autre mise en garde qui pourrait vous jeter pour une boucle est si votre Pool D'utilisateurs est réglé pour se souvenir des appareils, et vous ne passez pas dans le DEVICE_KEY et REFRESH_TOKEN. L'API Cognito renvoie actuellement Non Valide"Actualiser Token" erreur si vous passez dans le RefreshToken sans passer dans votre DeviceKey. Cette erreur est retournée même si vous passez dans un . Le thread lié ci-dessus illumine que, bien que J'espère AWS mises à jour leur manipulation d'erreur pour être moins cryptique à l'avenir.

comme indiqué dans ce thread, si vous utilisez Administrationauth et ADMIN_NO_SRP_AUTH, votre réponse d'authentification réussie ne actuellement contiennent moins de!--13-->; ce qui signifie que vous n'aurez pas de DeviceKey pour passer pendant que vous essayez de rafraîchir vos jetons.

Mon application appelle une implémentation en Python, donc voici un exemple qui a fonctionné pour moi:

def refresh_token(self, username, refresh_token):
    try:
        return client.initiate_auth(
            ClientId=self.client_id,
            AuthFlow='REFRESH_TOKEN_AUTH',
            AuthParameters={
                'REFRESH_TOKEN': refresh_token,
                'SECRET_HASH': self.get_secret_hash(username)
                // Note that SECRET_HASH is missing from JSDK
                // Note also that DEVICE_KEY is missing from my example
            }
        )
    except botocore.exceptions.ClientError as e:
        return e.response

le sdk Javascript gère le rafraîchissement interne des tokens. Lorsque vous appelez "getSession" pour obtenir des tokens, en l'absence de tout accès et ID tokens valide, le SDK utilise le jeton de rafraîchissement pour obtenir de nouveaux accès et ID tokens. Il invoque l'authentification de l'utilisateur, exigeant que l'utilisateur fournisse le nom d'utilisateur et le mot de passe, seulement lorsque le jeton de rafraîchissement est également expiré.

ce qui Concerne, Mahesh

j'ai eu du mal avec ceci en Javascript. Voici ma solution, elle est basée sur https://github.com/aws/amazon-cognito-identity-js mais il ne s'appuie pas sur le stockage de sorte que vous pouvez l'utiliser dans une fonction lambda si vous le souhaitez. Edit: correction du code, grâce à des Crayons de couleur

const userPool = new AWSCognito.CognitoUserPool({
  UserPoolId: <COGNITO_USER_POOL>,
  ClientId: <COGNITO_APP_ID>
})

userPool.client.makeUnauthenticatedRequest('initiateAuth', {
  ClientId: <COGNITO_APP_ID>,
  AuthFlow: 'REFRESH_TOKEN_AUTH',
  AuthParameters: {
    'REFRESH_TOKEN': <REFRESH_TOKEN> // client refresh JWT
  }
}, (err, authResult) => {
  if (err) {
     throw err
  }
  console.log(authResult) // contains new session
})

rafraîchir une session avec le SDK navigateur amazon-cognito-identity-js; il le fait principalement pour vous, et à moins que vous ne fassiez quelque chose d'inhabituel, vous n'aurez pas besoin de gérer le jeton de rafraîchissement directement. Voici ce que vous devez savoir:

supposons que vous avez instancié le pool d'utilisateurs comme ceci:

const userPool = new AmazonCognitoIdentity.CognitoUserPool({
  UserPoolId: USER_POOL_ID,
  ClientId: USER_POOL_CLIENT_ID
});

Pour trouver le dernier nom d'utilisateur authentifié, vous voulez faire cela:

const cognitoUser = cognitoUserPool.getCurrentUser();

s'il en trouve un, cognitoUser sera non null, et vous pouvez le faire, ce qui rafraîchissez vos jetons dans les coulisses si nécessaire:

cognitoUser.getSession(function(err, data) {
  if (err) {
    // Prompt the user to reauthenticate by hand...
  } else {
    const cognitoUserSession = data;
    const yourIdToken = cognitoUserSession.getIdToken().jwtToken;
    const yourAccessToken = cognitoUserSession.getAccessToken().jwtToken;
  }
});

si vous ne voulez pas que ces jetons persistent dans le stockage local, vous pouvez:

cognitoUser.signOut();

la façon dont il fonctionne est, après une authentification réussie, le navigateur stockera vos jetons JWT, y compris ce jeton de rafraîchissement. Il les stocke dans le stockage local dans votre navigateur par défaut, bien que vous puissiez fournir votre propre objet de stockage si vous le souhaitez. Par défaut, le token refresh est valide pour 30d, mais c'est une propriété (RefreshTokenValidity) de votre UserPoolClient, que vous pouvez modifier. Quand vous faites ce qui précède, getSession() va d'abord voir si les tokens que vous avez dans le stockage existent et sont toujours valides; sinon, il va essayer d'utiliser n'importe quel refreshToken qu'il trouve là pour vous authentifier dans une nouvelle session.

http://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-tokens-with-identity-providers.html indique que l'iOS et Android SDKs fera cela pour vous, bien que je n'ai pas utilisé ceux-ci donc ne peut pas répondre pour cela.

voici un exemple de la façon de le faire avec JavaScript du côté du serveur en utilisant le noeud.js.

const AccessToken = new CognitoAccessToken({ AccessToken: tokens.accessToken });
const IdToken = new CognitoIdToken({ IdToken: tokens.idToken });
const RefreshToken = new CognitoRefreshToken({ RefreshToken: tokens.refreshToken });

const sessionData = {
  IdToken: IdToken,
  AccessToken: AccessToken,
  RefreshToken: RefreshToken
};
const userSession = new CognitoUserSession(sessionData);

const userData = {
  Username: email,
  Pool: this.userPool
};

const cognitoUser = new CognitoUser(userData);
cognitoUser.setSignInUserSession(userSession);

cognitoUser.getSession(function (err, session) { // You must run this to verify that session (internally)
  if (session.isValid()) {
    // Update attributes or whatever else you want to do
  } else {
    // TODO: What to do if session is invalid?
  }
});

Vous pouvez voir un travail complet exemple de mon blog comment authentifier les utilisateurs avec des Tokens en utilisant Cognito.