cognito express

Cognito-Express: Autenticação de API com AWS Congito

Sinopse

cognito-express autentica solicitações de API em um aplicativo Node.js (em execução em um servidor ou em uma função AWS Lambda) verificando a assinatura JWT do AccessToken ou IDToken gerado pelo Amazon Cognito.

Motivação

Este módulo permite autenticar solicitações de API Node.js verificando a assinatura JWT de AccessToken ou IDToken , sem a necessidade de chamar o Amazon Cognito para cada invocação de API.

O módulo pode ser integrado de maneira fácil e discreta em qualquer aplicativo ou estrutura que suporte middleware estilo Connect, incluindo Express.

Este módulo agrupa essencialmente as etapas 1 a 7 listadas na documentação oficial da AWS sobre como usar tokens de ID e tokens de acesso em suas APIs da Web

1. Baixe e armazene o conjunto JSON Web Token (JWT) para seu grupo de usuários.
2. Decodifique a string do token no formato JWT.
3. Verifique a reivindicação iss . Deve corresponder ao seu grupo de usuários.
4. Verifique a declaração tokenUse . Deve corresponder à sua preferência definida para tipos de token access ou id
5. Obtenha o garoto do cabeçalho do token JWT e recupere a chave JSON Web correspondente que foi armazenada na etapa 1.
6. Verifique a assinatura do token JWT decodificado.
7. Verifique a reivindicação de experiência e certifique-se de que o token não expirou.

Agora você pode confiar nas declarações dentro do token e usá-lo conforme for adequado às suas necessidades.

Pré-requisitos

Após a autenticação bem-sucedida de um usuário, o Amazon Cognito emite três tokens para o cliente:

• Token de identificação
• Token de acesso
• Atualizar token

(Observação: o mecanismo de login não é coberto por este módulo e você terá que construí-lo separadamente)

Salve esses tokens no aplicativo cliente (de preferência como cookies). Quando qualquer API for chamada do cliente, passe o AccessToken ou IDToken para o servidor.

Depende totalmente de você como passar o AccessToken ou IDToken . Aqui estão duas opções:

1. Adicionando-os explicitamente em cabeçalhos de solicitação
2. Basta salvar os tokens como cookies. Dessa forma, eles são anexados aos cabeçalhos de solicitação sempre que as APIs são invocadas.

Configuração

 //Initializing CognitoExpress constructor
const cognitoExpress = new CognitoExpress ( {
	region : "us-east-1" ,
	cognitoUserPoolId : "us-east-1_dXlFef73t" ,
	tokenUse : "access" , //Possible Values: access | id
	tokenExpiration : 3600000 //Up to default expiration of 1 hour (3600000 ms)
} ) ; 

Uso

 cognitoExpress . validate ( accessTokenFromClient , function ( err , response ) {
	if ( err ) {
		/*
			//API is not authenticated, do something with the error.
		    //Perhaps redirect user back to the login page
			
			//ERROR TYPES:
			
			//If accessTokenFromClient is null or undefined
			err = {
			    "name": "TokenNotFound",
			    "message": "access token not found"
			}
			
			//If tokenuse doesn't match accessTokenFromClient
			{
			    "name": "InvalidTokenUse",
			    "message": "Not an id token"
			}

			//If token expired
			err = {
			    "name": "TokenExpiredError",
			    "message": "jwt expired",
			    "expiredAt": "2017-07-05T16:41:59.000Z"
			}

			//If token's user pool doesn't match the one defined in constructor
			{
			    "name": "InvalidUserPool",
			    "message": "access token is not from the defined user pool"
			}

		*/
	} else {
		//Else API has been authenticated. Proceed.
		res . locals . user = response ; //Optional - if you want to capture user information
		next ( ) ;
	}
} ) ;

Também suporta padrão assíncrono/aguardado

 ( async function main ( ) {
  try {
    const response = await cognitoExpress . validate ( accessTokenFromClient ) ;
    console . log ( response ) ;
     //User is authenticated, proceed with rest of your business logic.

  } catch ( e ) {
    console . error ( e ) ;
     //User is not authenticated, do something with the error.
     //Perhaps redirect user back to the login page
  }
} ) ( ) ; 

Exemplo completo

app.js - servidor

 //app.js
"use strict" ;

const express = require ( "express" ) ,
	CognitoExpress = require ( "cognito-express" ) ,
	port = process . env . PORT || 8000 ;

const app = express ( ) ,
	authenticatedRoute = express . Router ( ) ; //I prefer creating a separate Router for authenticated requests

app . use ( "/api" , authenticatedRoute ) ;

//Initializing CognitoExpress constructor
const cognitoExpress = new CognitoExpress ( {
	region : "us-east-1" ,
	cognitoUserPoolId : "us-east-1_dXlFef73t" ,
	tokenUse : "access" , //Possible Values: access | id
	tokenExpiration : 3600000 //Up to default expiration of 1 hour (3600000 ms)
} ) ;

//Our middleware that authenticates all APIs under our 'authenticatedRoute' Router
authenticatedRoute . use ( function ( req , res , next ) {
	
	//I'm passing in the access token in header under key accessToken
	let accessTokenFromClient = req . headers . accesstoken ;

	//Fail if token not present in header. 
	if ( ! accessTokenFromClient ) return res . status ( 401 ) . send ( "Access Token missing from header" ) ;

	cognitoExpress . validate ( accessTokenFromClient , function ( err , response ) {
		
		//If API is not authenticated, Return 401 with error message. 
		if ( err ) return res . status ( 401 ) . send ( err ) ;
		
		//Else API has been authenticated. Proceed.
		res . locals . user = response ;
		next ( ) ;
	} ) ;
} ) ;


//Define your routes that need authentication check
authenticatedRoute . get ( "/myfirstapi" , function ( req , res , next ) {
	res . send ( `Hi ${ res . locals . user . username } , your API call is authenticated!` ) ;
} ) ;

app . listen ( port , function ( ) {
	console . log ( `Live on port: ${ port } !` ) ;
} ) ; 

client.js - exemplo angular

 //client.js - angular example

"use strict" ;

//I stored my access token value returned from Cognito in a cookie called ClientAccessToken

app . controller ( "MyFirstAPI" , function ( $scope , $http , $cookies ) {
	$http ( {
		method : "GET" ,
		url : "/api/myfirstapi" ,
		headers : {
			accesstoken : $cookies . get ( "ClientAccessToken" ) 
            }
		}
	} ) . then (
		function success ( response ) {
			//Authenticated. Do something with the response. 
		} ,
		function error ( err ) {
			console . error ( err ) ;
		}
	) ;
} ) ; 

Colaboradores

Gary Arora

Licença

MIT