如何在 API 后端从 AWS Cognito 验证 JWT？

Question

我正在构建一个由 Angular2 单页应用程序和在 ECS 上运行的 REST API 组成的系统。 API 在 .Net/Nancy 上运行，但这种情况很可能会改变。

我想尝试一下 Cognito，这就是我想象的身份验证工作流程：

1. SPA 登录用户并接收 JWT
2. SPA 在每个请求中都将 JWT 发送到 REST API
3. REST API 验证 JWT 是真实的

我的问题是关于第 3 步的。我的服务器（或者更确切地说：我的无状态、自动缩放、负载平衡的 Docker 容器）如何验证令牌是真实的？ 因为“服务器”还没有发布 JWT 本身，它不能使用自己的 secret（如基本 JWT 示例here 中所述）。

我已阅读 Cognito 文档并在 Google 上搜索了很多内容，但我找不到任何关于如何在服务器端处理 JWT 的好的指南。

Answer 1

原来我没有正确阅读文档。解释了here（向下滚动到“在您的 Web API 中使用 ID 令牌和访问令牌”）。

API 服务可以下载 Cognito 的机密并使用它们来验证收到的 JWT。完美。

编辑

@Groady 的评论是正确的：但是如何您验证令牌？我会说使用像jose4j 或nimbus（都是Java）这样久经考验的库，并且不要自己从头开始实施验证。

Here 是一个使用 nimbus 的 Spring Boot 示例实现，当我最近不得不在 java/dropwizard 服务中实现它时，它让我开始了。

Answer 2

我遇到了类似的问题，但没有使用 API 网关。就我而言，我想验证通过 AWS Cognito Developer Authenticated 身份路由获得的 JWT 令牌的签名。

与各个网站上的许多海报一样，我无法准确拼凑出我需要在外部（即服务器端或通过脚本）验证 AWS JWT 令牌签名的位

我想我想通了并向verify an AWS JWT token signature 提了一个要点。它将使用 PyCrypto 中 Crypto.Signature 的 pyjwt 或 PKCS1_v1_5c 验证 AWS JWT/JWS 令牌

所以，是的，在我的情况下这是 python，但它在节点中也很容易实现（npm install jsonwebtoken jwk-to-pem 请求）。

我试图强调 cmets 中的一些陷阱，因为当我试图弄清楚这一点时，我大部分时间都在做正确的事情，但存在一些细微差别，例如 python dict ordering，或缺少它，以及 json 表示。

希望它可以帮助某个地方的人。

Answer 3

这是在 NodeJS 上验证签名的一种方法：

var jwt = require('jsonwebtoken');
var jwkToPem = require('jwk-to-pem');
var pem = jwkToPem(jwk);
jwt.verify(token, pem, function(err, decoded) {
  console.log(decoded)
});


// Note : You can get jwk from https://cognito-idp.{region}.amazonaws.com/{userPoolId}/.well-known/jwks.json 

Answer 4

简答：
您可以从以下端点获取用户池的公钥：
https://cognito-idp.{region}.amazonaws.com/{userPoolId}/.well-known/jwks.json
如果您使用此公钥成功解码令牌，则该令牌是有效的，否则它是伪造的。

长答案：
通过 cognito 成功进行身份验证后，您将获得访问和 id 令牌。现在您要验证此令牌是否已被篡改。传统上，我们会将这些令牌发送回身份验证服务（首先颁发此令牌）以检查令牌是否有效。这些系统使用symmetric key encryption 算法（例如HMAC）使用密钥加密有效负载，因此只有该系统能够判断此令牌是否有效。
传统认证 JWT 令牌标头：

{
   "alg": "HS256",
   "typ": "JWT"
}

注意这里使用的加密算法是对称的 - HMAC + SHA256

但是像 Cognito 这样的现代身份验证系统使用 asymmetric key encryption 算法（如 RSA）使用一对公钥和私钥来加密有效负载。有效载荷使用私钥加密，但可以通过公钥解码。使用这种算法的主要优点是我们不必请求单个身份验证服务来判断令牌是否有效。由于每个人都可以访问公钥，因此任何人都可以验证令牌的有效性。验证负载相当分散，没有单点故障。
Cognito JWT 令牌标头：

{
  "kid": "abcdefghijklmnopqrsexample=",
  "alg": "RS256"
}

本例使用的非对称加密算法——RSA + SHA256

Answer 5

这在 dot net 4.5 中对我有用

    public static bool VerifyCognitoJwt(string accessToken)
    {
        string[] parts = accessToken.Split('.');

        string header = parts[0];
        string payload = parts[1];

        string headerJson = Encoding.UTF8.GetString(Base64UrlDecode(header));
        JObject headerData = JObject.Parse(headerJson);

        string payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(payload));
        JObject payloadData = JObject.Parse(payloadJson);

        var kid = headerData["kid"];
        var iss = payloadData["iss"];

        var issUrl = iss + "/.well-known/jwks.json";
        var keysJson= string.Empty;

        using (WebClient wc = new WebClient())
        {
            keysJson = wc.DownloadString(issUrl);
        }

        var keyData = GetKeyData(keysJson,kid.ToString());

        if (keyData==null)
            throw new ApplicationException(string.Format("Invalid signature"));

        var modulus = Base64UrlDecode(keyData.Modulus);
        var exponent = Base64UrlDecode(keyData.Exponent);

        RSACryptoServiceProvider provider = new RSACryptoServiceProvider();

        var rsaParameters= new RSAParameters();
        rsaParameters.Modulus = new BigInteger(modulus).ToByteArrayUnsigned();
        rsaParameters.Exponent = new BigInteger(exponent).ToByteArrayUnsigned();

        provider.ImportParameters(rsaParameters);

        SHA256CryptoServiceProvider sha256 = new SHA256CryptoServiceProvider();
        byte[] hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(parts[0] + "." + parts[1]));

        RSAPKCS1SignatureDeformatter rsaDeformatter = new RSAPKCS1SignatureDeformatter(provider);
        rsaDeformatter.SetHashAlgorithm(sha256.GetType().FullName);

        if (!rsaDeformatter.VerifySignature(hash, Base64UrlDecode(parts[2])))
            throw new ApplicationException(string.Format("Invalid signature"));

        return true;
    }

 public class KeyData
    {
        public string Modulus { get; set; }
        public string Exponent { get; set; }
    }

    private static KeyData GetKeyData(string keys,string kid)
    {
        var keyData = new KeyData();

        dynamic obj = JObject.Parse(keys);
        var results = obj.keys;
        bool found = false;

        foreach (var key in results)
        {
            if (found)
                break;

            if (key.kid == kid)
            {
                keyData.Modulus = key.n;
                keyData.Exponent = key.e;
                found = true;
            }
        }

        return keyData;
    }

Answer 6

执行授权码授予流程

假设你：

• 已在 AWS Cognito 中正确配置了用户池，并且

• 可以通过以下方式注册/登录并获得访问代码：

  https://<your-domain>.auth.us-west-2.amazoncognito.com/login?response_type=code&client_id=<your-client-id>&redirect_uri=<your-redirect-uri>
  

您的浏览器应该重定向到<your-redirect-uri>?code=4dd94e4f-3323-471e-af0f-dc52a8fe98a0

---

现在您需要将该代码传递到您的后端并让它为您请求令牌。

POST https://<your-domain>.auth.us-west-2.amazoncognito.com/oauth2/token

• 将您的 Authorization 标头设置为 Basic 并根据您在 AWS Cognito 中配置的应用程序客户端使用 username=<app client id> 和 password=<app client secret>
• 在您的请求正文中设置以下内容：
  • grant_type=authorization_code
  • code=<your-code>
  • client_id=<your-client-id>
  • redirect_uri=<your-redirect-uri>

如果成功，您的后端应该会收到一组 base64 编码的令牌。

{
    id_token: '...',
    access_token: '...',
    refresh_token: '...',
    expires_in: 3600,
    token_type: 'Bearer'
}

---

现在，根据documentation，您的后端应该通过以下方式验证 JWT 签名：

1. 解码 ID 令牌
2. 将本地密钥 ID（孩子）与公共孩子进行比较
3. 使用公钥来验证使用您的 JWT 库的签名。

由于 AWS Cognito 为每个用户池生成两对 RSA 加密密钥，因此您需要确定用于加密令牌的密钥。

这是一个演示验证 JWT 的 NodeJS sn-p。

import jsonwebtoken from 'jsonwebtoken'
import jwkToPem from 'jwk-to-pem'

const jsonWebKeys = [  // from https://cognito-idp.us-west-2.amazonaws.com/<UserPoolId>/.well-known/jwks.json
    {
        "alg": "RS256",
        "e": "AQAB",
        "kid": "ABCDEFGHIJKLMNOPabc/1A2B3CZ5x6y7MA56Cy+6ubf=",
        "kty": "RSA",
        "n": "...",
        "use": "sig"
    },
    {
        "alg": "RS256",
        "e": "AQAB",
        "kid": "XYZAAAAAAAAAAAAAAA/1A2B3CZ5x6y7MA56Cy+6abc=",
        "kty": "RSA",
        "n": "...",
        "use": "sig"
    }
]

function validateToken(token) {
    const header = decodeTokenHeader(token);  // {"kid":"XYZAAAAAAAAAAAAAAA/1A2B3CZ5x6y7MA56Cy+6abc=", "alg": "RS256"}
    const jsonWebKey = getJsonWebKeyWithKID(header.kid);
    verifyJsonWebTokenSignature(token, jsonWebKey, (err, decodedToken) => {
        if (err) {
            console.error(err);
        } else {
            console.log(decodedToken);
        }
    })
}

function decodeTokenHeader(token) {
    const [headerEncoded] = token.split('.');
    const buff = new Buffer(headerEncoded, 'base64');
    const text = buff.toString('ascii');
    return JSON.parse(text);
}

function getJsonWebKeyWithKID(kid) {
    for (let jwk of jsonWebKeys) {
        if (jwk.kid === kid) {
            return jwk;
        }
    }
    return null
}

function verifyJsonWebTokenSignature(token, jsonWebKey, clbk) {
    const pem = jwkToPem(jsonWebKey);
    jsonwebtoken.verify(token, pem, {algorithms: ['RS256']}, (err, decodedToken) => clbk(err, decodedToken))
}


validateToken('xxxxxxxxx.XXXXXXXX.xxxxxxxx')

Answer 7

这是基于Derek (answer) 的详细解释。我已经能够为 PHP 创建一个工作示例。

我已使用https://github.com/firebase/php-jwt 进行 pem 创建和代码验证。

此代码在您收到一组 base64 编码令牌后使用。

<?php

require_once(__DIR__ . '/vendor/autoload.php');

use Firebase\JWT\JWT;
use Firebase\JWT\JWK;
use Firebase\JWT\ExpiredException;
use Firebase\JWT\SignatureInvalidException;
use Firebase\JWT\BeforeValidException;

function debugmsg($msg, $output) {
    print_r($msg . "\n");
}

$tokensReceived = array(
    'id_token' => '...',
    'access_token' => '...',
    'refresh_token' => '...',
    'expires_in' => 3600,
    'token_type' => 'Bearer'
);

$idToken = $tokensReceived['id_token'];

// 'https://cognito-idp.us-west-2.amazonaws.com/<pool-id>/.well-known/jwks.json'
$keys = json_decode('<json string received from jwks.json>');

$idTokenHeader = json_decode(base64_decode(explode('.', $idToken)[0]), true);
print_r($idTokenHeader);

$remoteKey = null;

$keySets = JWK::parseKeySet($keys);

$remoteKey = $keySets[$idTokenHeader['kid']];

try {
    print_r("result: ");
    $decoded = JWT::decode($idToken, $remoteKey, array($idTokenHeader['alg']));
    print_r($decoded);
} catch(Firebase\JWT\ExpiredException $e) {
    debugmsg("ExpiredException","cognito");
} catch(Firebase\JWT\SignatureInvalidException $e) {
    debugmsg("SignatureInvalidException","cognito");
} catch(Firebase\JWT\BeforeValidException $e) {
    debugmsg("BeforeValidException","cognito");
}

?>

Answer 8

您可以从此处的 Lambda 代码中获得见解

https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-using-tokens-verifying-a-jwt.html

https://github.com/awslabs/aws-support-tools/tree/master/Cognito/decode-verify-jwt

在 Go 语言中 https://gist.github.com/tmaiaroto/e2ee5e88fc6ae035307d7c5ee71a99cf

Answer 9

cognito-jwt-verifier 是一个小型 npm 包，用于验证 ID 并访问从您的节点/Lambda 后端中的 AWS Cognito 获得的 JWT 令牌，并且具有最小的依赖关系。

免责声明：我是本文的作者。我想出了它，因为我找不到任何为我检查所有框的东西：

• 最小的依赖关系
• 与框架无关
• JWKS（公钥）缓存
• 测试覆盖率

用法（更详细的例子见 github repo）：

const { verifierFactory } = require('@southlane/cognito-jwt-verifier')
 
const verifier = verifierFactory({
  region: 'us-east-1',
  userPoolId: 'us-east-1_PDsy6i0Bf',
  appClientId: '5ra91i9p4trq42m2vnjs0pv06q',
  tokenType: 'id', // either "access" or "id"
})

const token = 'eyJraWQiOiI0UFFoK0JaVE...' // clipped 
 
try {
  const tokenPayload = await verifier.verify(token)
} catch (e) {
  // catch error and act accordingly, e.g. throw HTTP 401 error
}

Answer 10

有人还编写了一个名为 cognitojwt 的 python 包，它可以在异步/同步模式下解码和验证 Amazon Cognito JWT。

Answer 11

AWS 专门为此发布了一个 NodeJS 库：https://github.com/awslabs/aws-jwt-verify。

该库与此处提到的其他库具有类似的机制，例如自动下载和缓存 JWKS（可以用来验证 Cognito JWT 的公钥）。它是用纯 TypeScript 编写的，并且有 0 个依赖项。

import { CognitoJwtVerifier } from "aws-jwt-verify";

// Verifier that expects valid access tokens:
const verifier = CognitoJwtVerifier.create({
  userPoolId: "<user_pool_id>",
  tokenUse: "access",
  clientId: "<client_id>",
});

try {
  const payload = await verifier.verify(
    "eyJraWQeyJhdF9oYXNoIjoidk..." // the JWT as string
  );
  console.log("Token is valid. Payload:", payload);
} catch {
  console.log("Token not valid!");
}

（顺便说一句，该库还包括一个适用于除 Cognito 之外的其他身份提供者的类）

免责声明：我是图书馆的作者之一。我们期待客户的反馈——请给我们留下一个 GitHub 问题。