使用Amazon Cognito为AI代理注入用户上下文 | AWS安全博客

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

{
  "sub": "user-identity-4e4c-example-7cede8e609a2",
  "cognito:groups": ["exampleChatApplicationAccess"],
  "iss": "https://cognito-idp.<region>.amazonaws.com/<region>_example",
  "version": 2,
  "client_id": "1example23456789",
  "origin_jti": "",
  "token_use": "access",
  "scope": "openid profile email",
  "auth_time": 499192140,
  "exp": 1445444940,
  "iat": 499192140,
  "jti": "",
  "username": "my-example-username"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

async function getAccessToken() {
  const clientId = 'exampleAiAgentClientId'; // use Secrets Manager
  const clientSecret = 'exampleAiAgentClientSecret'; // use Secrets Manager
  const tokenEndpoint = 'https://mydomain.auth.<region>.amazoncognito.com/oauth2/token';
  const scope = 'crossDomainService/read userData/read';
  const clientMetadata = '{"onBehalfOfToken":"<HUMAN-USER-ACCESS-TOKEN>", "callerApp":"ExampleChatApplication"}';

  const basicAuth = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');

  const body = new URLSearchParams({
    grant_type: 'client_credentials',
    scope,
    aws_client_metadata: clientMetadata
  });

  const res = await fetch(tokenEndpoint, {
    method: 'POST',
    headers: {
      'Authorization': `Basic ${basicAuth}`,
      'Content-Type': 'application/x-www-form-urlencoded'
    },
    body
  });

  if (!res.ok) {
    const error = await res.text();
    throw new Error(`Token request failed: ${res.status} ${error}`);
  }

  const { access_token } = await res.json();
  console.log('Access Token:', access_token);

  return access_token;
}

getAccessToken().catch(err => console.error('Error:', err.message));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

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

// Initialize the JWT verifier to verify the user’s access token
// Provide the user pool ID, token use, and client ID 
const jwtVerifier = CognitoJwtVerifier.create({
  userPoolId: process.env.USER_POOL_ID,  // user pool for user authentication
  clientId: process.env.CLIENT_ID,
  // groups: "exampleChatApplicationAccess", // optional group membership authorization
  tokenUse: 'access'
});

export const handler = async function(event, context) {
  try {
    const onBehalfOfToken = event.request.clientMetadata?.onBehalfOfToken || '';
    // It’s recommended that the provided “callerApp” value from the application is authorized for use with the app client for the AI agent
    const callerApp = event.request.clientMetadata?.callerApp || '';

    // The below console log will display the authenticated user’s JWT
    // Keep this logging with caution in a production environment
    console.log('Original event:', event);

    // Verify the access token from the human user
    // You could optionally also perform some authorization checks here as well
    // Example: check for the membership of a group
    let decodedJWT;
    if (onBehalfOfToken) {
      try {
        decodedJWT = await jwtVerifier.verify(onBehalfOfToken);
        console.log('Decoded JWT:', decodedJWT);
      } catch (err) {
        console.error('Token verification failed:', err);
        throw new Error('Token verification failed');
      }
    }

    // Create the onBehalfOf claim structure
    const behalfOfClaim = decodedJWT ? {
      sub: decodedJWT.sub,
      username: decodedJWT.username,
      groups: decodedJWT['cognito:groups'] || []
    } : {};

    // Customized token returned to client
    event.response = {
      "claimsAndScopeOverrideDetails": {
        "accessTokenGeneration": {
          "claimsToAddOrOverride": {
            "onBehalfOf": behalfOfClaim,
            "callerApp": callerApp
          },
        }
      }
    };

    return event;

  } catch (error) {
    console.error('Error in Lambda execution:', error);
    throw error;
  }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "sub": "agent-identity-4e4c-example-7cede8e609a2",
  "onBehalfOf": {
    "sub": "user-identity-4e4c-example-7cede8e609a2",
    "username": "my-example-username",
    "groups": ["readaccess"]
  },
  "iss": "https://cognito-idp..amazonaws.com/_example",
  "version": 2,
  "client_id": "1example23456789",
  "callerApp": "ExampleChatApplication",
  "token_use": "access",
  "scope": "crossDomainService123/read userData/read",
  "auth_time": 499192140,
  "exp": 1445444940,
  "iat": 499192140,
  "jti": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

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

// add custom logic to verify that AI agent is authorized to perform this action on behalf of the user

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

try {
  const payload = await verifier.verify(
    "eyJraWQeyJhdF9oYXNoIjoidk..." //this will be the AI agent's access token
  );
  console.log("Token is valid. Payload:", payload);
} catch {
  console.log("Token not valid!");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

permit(
  principal == Agent::"agent-identity-4e4c-example-7cede8e609a2",
  action == Action::"readOnly",
  resource == Resource::"crossDomainService123::userData"
)
when {
  resource.scope == Scope::"crossDomainService123/read" &&
  resource.owner == User::" user-identity-4e4c-example-7cede8e609a2" &&
  context.onBehalfOf.sub == " user-identity-4e4c-example-7cede8e609a2" &&
  context.callerApp == "ExampleChatApplication"
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import { VerifiedPermissionsClient, IsAuthorizedWithTokenCommand } from "@aws-sdk/client-verifiedpermissions";

const client = new VerifiedPermissionsClient({ region: "<region>" });

// Dynamically provided token 
const jwtToken = "eyJraWQiOiJrMWtleSIsInR..."; //AI agent's access token

async function checkAccess() {
  const input = {
    policy