@alliander-opensource/aws-jwt-sts 0.2.6

package/dist/index.keyrotate.js

@@ -0,0 +1,193 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Alliander NV
+//
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_kms_1 = require("@aws-sdk/client-kms");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const jsrsasign_1 = require("jsrsasign");
+const client = new client_kms_1.KMSClient({});
+const ALIAS_PREVIOUS = 'alias/sts/PREVIOUS';
+const ALIAS_CURRENT = 'alias/sts/CURRENT';
+const ALIAS_PENDING = 'alias/sts/PENDING';
+const ALIASES = [
+    ALIAS_PREVIOUS,
+    ALIAS_CURRENT,
+    ALIAS_PENDING
+];
+const handler = async (event) => {
+    // retrieve the step from the event
+    const step = (event.step);
+    // match the step with the corresponding function
+    switch (step) {
+        case 'deletePrevious':
+            await deletePrevious();
+            break;
+        case 'movePrevious':
+            await movePrevious();
+            break;
+        case 'moveCurrent':
+            await moveCurrent();
+            break;
+        case 'createPending':
+            await createPending();
+            break;
+        case 'generateArtifacts':
+            await generateJWKS();
+            await generateOpenIDConfiguration();
+            break;
+        default:
+            console.log('invalid step');
+    }
+};
+exports.handler = handler;
+async function deletePrevious() {
+    console.log('Deleting PREVIOUS aliased key');
+    const prevKeyId = await getKeyIdForAlias(ALIAS_PREVIOUS);
+    if (prevKeyId) {
+        const ScheduleDeleteResponse = await client.send(new client_kms_1.ScheduleKeyDeletionCommand({ KeyId: prevKeyId }));
+        console.log(ScheduleDeleteResponse);
+    }
+    else {
+        console.log('No PREVIOUS key at the moment, skip deletion');
+    }
+}
+async function movePrevious() {
+    console.log('moving PREVIOUS alias');
+    const currentKeyId = await getKeyIdForAlias(ALIAS_CURRENT);
+    if (currentKeyId) {
+        await updateOrCreateAlias(ALIAS_PREVIOUS, currentKeyId);
+    }
+    else {
+        console.log('No CURRENT key at the moment, skip assigning the PREVIOUS alias to this key.');
+    }
+}
+async function moveCurrent() {
+    console.log('Moving CURRENT alias');
+    const pendingKeyId = await getKeyIdForAlias(ALIAS_PENDING);
+    if (pendingKeyId) {
+        await updateOrCreateAlias(ALIAS_CURRENT, pendingKeyId);
+    }
+    else {
+        console.log('No PENDING key at the moment, skip assigning the CURRENT alias to this key.');
+    }
+}
+async function createPending() {
+    console.log('Creating new key for PENDING');
+    // Create new key
+    const createResponse = await client.send(new client_kms_1.CreateKeyCommand({
+        KeySpec: 'RSA_2048',
+        KeyUsage: 'SIGN_VERIFY'
+    }));
+    console.log(createResponse);
+    // Update the new key with pending alias
+    await updateOrCreateAlias(ALIAS_PENDING, createResponse.KeyMetadata.KeyId);
+}
+async function updateOrCreateAlias(aliasName, keyId) {
+    try {
+        const updateResponse = await client.send(new client_kms_1.UpdateAliasCommand({
+            AliasName: aliasName,
+            TargetKeyId: keyId
+        }));
+        console.log(updateResponse);
+    }
+    catch (err) {
+        if (err instanceof client_kms_1.NotFoundException) {
+            console.log('ALIAS not found, creating it.');
+            const createResponse = await client.send(new client_kms_1.CreateAliasCommand({
+                AliasName: aliasName,
+                TargetKeyId: keyId
+            }));
+            console.log(createResponse);
+        }
+        else {
+            throw (err);
+        }
+    }
+}
+async function getKeyIdForAlias(keyId) {
+    try {
+        const response = await client.send(new client_kms_1.DescribeKeyCommand({ KeyId: keyId }));
+        console.log(response);
+        return response.KeyMetadata?.KeyId;
+    }
+    catch (err) {
+        if (err instanceof client_kms_1.NotFoundException) {
+            return null;
+        }
+        else {
+            throw err;
+        }
+    }
+}
+async function generateJWKS() {
+    const allKeys = [];
+    for (const keyAlias of ALIASES) {
+        const keyId = await getKeyIdForAlias(keyAlias);
+        if (keyId) {
+            const jwkContents = await generateJWK(keyAlias);
+            await setKMSKeyTags(keyId, [{ TagKey: 'jwk_kid', TagValue: jwkContents.kid }]);
+            allKeys.push(jwkContents);
+        }
+    }
+    const result = { keys: allKeys };
+    await uploadToS3('discovery/keys', result);
+}
+async function generateOpenIDConfiguration() {
+    const issuer = process.env.ISSUER;
+    const openIdConfiguration = {
+        issuer,
+        jwks_uri: `${issuer}/discovery/keys`,
+        response_types_supported: [
+            'token'
+        ],
+        id_token_signing_alg_values_supported: [
+            'RS256'
+        ],
+        scopes_supported: [
+            'openid'
+        ],
+        token_endpoint_auth_methods_supported: [
+            'client_secret_basic'
+        ],
+        claims_supported: [
+            'aud',
+            'exp',
+            'iat',
+            'iss',
+            'sub'
+        ]
+    };
+    await uploadToS3('.well-known/openid-configuration', openIdConfiguration);
+}
+async function generateJWK(keyAlias) {
+    // Get the public key from kms
+    const getPubKeyResponse = await client.send(new client_kms_1.GetPublicKeyCommand({ KeyId: keyAlias }));
+    // generate HEX format from the response (DER)
+    const pubKeyHex = Buffer.from(getPubKeyResponse.PublicKey).toString('hex');
+    // Get the pub key in pem format
+    const pubKeyPem = jsrsasign_1.KJUR.asn1.ASN1Util.getPEMStringFromHex(pubKeyHex, 'PUBLIC KEY');
+    // return the JWK format for the key
+    const jwk = jsrsasign_1.KEYUTIL.getJWK(pubKeyPem);
+    jwk.use = 'sig';
+    jwk.alg = 'RS256';
+    return jwk;
+}
+async function setKMSKeyTags(keyAlias, tags) {
+    return await client.send(new client_kms_1.TagResourceCommand({ KeyId: keyAlias, Tags: tags }));
+}
+async function uploadToS3(key, contents) {
+    // get S3 bucket from environment variables
+    const s3Bucket = process.env.S3_BUCKET;
+    const s3client = new client_s3_1.S3Client({});
+    // Write jwk to s3 bucket
+    await s3client.send(new client_s3_1.PutObjectCommand({
+        Bucket: s3Bucket,
+        Key: key,
+        Body: Buffer.from(JSON.stringify(contents)),
+        ContentType: 'application/json',
+        ContentEncoding: ''
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.keyrotate.js","sourceRoot":"","sources":["../src/index.keyrotate.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-FileCopyrightText: 2023 Alliander NV\n//\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  KMSClient,\n  DescribeKeyCommand,\n  GetPublicKeyCommand,\n  CreateKeyCommand,\n  UpdateAliasCommand,\n  ScheduleKeyDeletionCommand,\n  TagResourceCommand,\n  Tag,\n  NotFoundException,\n  CreateAliasCommand\n} from '@aws-sdk/client-kms'\nimport { S3Client, PutObjectCommand } from '@aws-sdk/client-s3'\nimport { KEYUTIL, KJUR } from 'jsrsasign'\n\nconst client = new KMSClient({})\n\nconst ALIAS_PREVIOUS = 'alias/sts/PREVIOUS'\nconst ALIAS_CURRENT = 'alias/sts/CURRENT'\nconst ALIAS_PENDING = 'alias/sts/PENDING'\n\nconst ALIASES: string[] = [\n  ALIAS_PREVIOUS,\n  ALIAS_CURRENT,\n  ALIAS_PENDING\n]\n\nexport const handler = async (event: any): Promise<any> => {\n  // retrieve the step from the event\n  const step = (event.step)\n\n  // match the step with the corresponding function\n  switch (step) {\n    case 'deletePrevious':\n      await deletePrevious()\n      break\n    case 'movePrevious':\n      await movePrevious()\n      break\n    case 'moveCurrent':\n      await moveCurrent()\n      break\n    case 'createPending':\n      await createPending()\n      break\n    case 'generateArtifacts':\n      await generateJWKS()\n      await generateOpenIDConfiguration()\n      break\n\n    default:\n      console.log('invalid step')\n  }\n}\n\nasync function deletePrevious () {\n  console.log('Deleting PREVIOUS aliased key')\n\n  const prevKeyId = await getKeyIdForAlias(ALIAS_PREVIOUS)\n  if (prevKeyId) {\n    const ScheduleDeleteResponse = await client.send(\n      new ScheduleKeyDeletionCommand({ KeyId: prevKeyId })\n    )\n    console.log(ScheduleDeleteResponse)\n  } else {\n    console.log('No PREVIOUS key at the moment, skip deletion')\n  }\n}\n\nasync function movePrevious () {\n  console.log('moving PREVIOUS alias')\n  const currentKeyId = await getKeyIdForAlias(ALIAS_CURRENT)\n  if (currentKeyId) {\n    await updateOrCreateAlias(ALIAS_PREVIOUS, currentKeyId)\n  } else {\n    console.log('No CURRENT key at the moment, skip assigning the PREVIOUS alias to this key.')\n  }\n}\n\nasync function moveCurrent () {\n  console.log('Moving CURRENT alias')\n\n  const pendingKeyId = await getKeyIdForAlias(ALIAS_PENDING)\n  if (pendingKeyId) {\n    await updateOrCreateAlias(ALIAS_CURRENT, pendingKeyId)\n  } else {\n    console.log('No PENDING key at the moment, skip assigning the CURRENT alias to this key.')\n  }\n}\n\nasync function createPending () {\n  console.log('Creating new key for PENDING')\n\n  // Create new key\n  const createResponse = await client.send(new CreateKeyCommand({\n    KeySpec: 'RSA_2048',\n    KeyUsage: 'SIGN_VERIFY'\n  }))\n  console.log(createResponse)\n\n  // Update the new key with pending alias\n  await updateOrCreateAlias(ALIAS_PENDING, createResponse.KeyMetadata!.KeyId!)\n}\n\nasync function updateOrCreateAlias (aliasName: string, keyId: string) {\n  try {\n    const updateResponse = await client.send(new UpdateAliasCommand({\n      AliasName: aliasName,\n      TargetKeyId: keyId\n    }))\n    console.log(updateResponse)\n  } catch (err) {\n    if (err instanceof NotFoundException) {\n      console.log('ALIAS not found, creating it.')\n      const createResponse = await client.send(new CreateAliasCommand({\n        AliasName: aliasName,\n        TargetKeyId: keyId\n      }))\n      console.log(createResponse)\n    } else {\n      throw (err)\n    }\n  }\n}\n\nasync function getKeyIdForAlias (keyId: string) {\n  try {\n    const response = await client.send(new DescribeKeyCommand({ KeyId: keyId }))\n    console.log(response)\n    return response.KeyMetadata?.KeyId\n  } catch (err) {\n    if (err instanceof NotFoundException) {\n      return null\n    } else {\n      throw err\n    }\n  }\n}\n\nasync function generateJWKS () {\n  const allKeys: object[] = []\n\n  for (const keyAlias of ALIASES) {\n    const keyId = await getKeyIdForAlias(keyAlias)\n    if (keyId) {\n      const jwkContents = await generateJWK(keyAlias)\n      await setKMSKeyTags(keyId, [{ TagKey: 'jwk_kid', TagValue: jwkContents.kid }])\n      allKeys.push(jwkContents)\n    }\n  }\n\n  const result = { keys: allKeys }\n\n  await uploadToS3('discovery/keys', result)\n}\n\nasync function generateOpenIDConfiguration () {\n  const issuer = process.env.ISSUER\n\n  const openIdConfiguration = {\n    issuer,\n    jwks_uri: `${issuer}/discovery/keys`,\n    response_types_supported: [\n      'token'\n    ],\n    id_token_signing_alg_values_supported: [\n      'RS256'\n    ],\n    scopes_supported: [\n      'openid'\n    ],\n    token_endpoint_auth_methods_supported: [\n      'client_secret_basic'\n    ],\n    claims_supported: [\n      'aud',\n      'exp',\n      'iat',\n      'iss',\n      'sub'\n    ]\n  }\n\n  await uploadToS3('.well-known/openid-configuration', openIdConfiguration)\n}\n\nasync function generateJWK (keyAlias: string): Promise<any> {\n  // Get the public key from kms\n  const getPubKeyResponse = await client.send(new GetPublicKeyCommand({ KeyId: keyAlias }))\n\n  // generate HEX format from the response (DER)\n  const pubKeyHex = Buffer.from(getPubKeyResponse.PublicKey as Uint8Array).toString('hex')\n\n  // Get the pub key in pem format\n  const pubKeyPem = KJUR.asn1.ASN1Util.getPEMStringFromHex(pubKeyHex, 'PUBLIC KEY')\n\n  // return the JWK format for the key\n  const jwk: any = KEYUTIL.getJWK(pubKeyPem)\n\n  jwk.use = 'sig'\n  jwk.alg = 'RS256'\n\n  return jwk\n}\n\nasync function setKMSKeyTags (keyAlias: string, tags: Tag[]) {\n  return await client.send(new TagResourceCommand({ KeyId: keyAlias, Tags: tags }))\n}\n\nasync function uploadToS3 (key: string, contents: object) {\n  // get S3 bucket from environment variables\n  const s3Bucket = process.env.S3_BUCKET\n\n  const s3client = new S3Client({})\n\n  // Write jwk to s3 bucket\n  await s3client.send(new PutObjectCommand({\n    Bucket: s3Bucket,\n    Key: key, // File name you want to save as in S3\n    Body: Buffer.from(JSON.stringify(contents)),\n    ContentType: 'application/json',\n    ContentEncoding: ''\n  }))\n}\n"]}

package/dist/index.sign.d.ts

@@ -0,0 +1,2 @@
+import { Context, APIGatewayProxyResult } from 'aws-lambda';
+export declare const handler: (apiEvent: import("aws-lambda").APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyResult>;

package/dist/index.sign.js

@@ -0,0 +1,120 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Alliander NV
+//
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const client_kms_1 = require("@aws-sdk/client-kms");
+const base64url_1 = require("base64url");
+const logger_1 = require("@aws-lambda-powertools/logger");
+const KEY_ALIAS_CURRENT = 'alias/sts/CURRENT';
+const logger = new logger_1.Logger();
+const handler = async (apiEvent, context) => {
+    const identityArn = getARNFromIdentity(apiEvent.requestContext.identity?.userArn);
+    logger.debug(identityArn);
+    if (identityArn === undefined || identityArn === null) {
+        logger.info(`Unable to resolve identityArn for userArn: ${apiEvent.requestContext.identity?.userArn}`);
+        return respond('Unable to resolve identity', 400);
+    }
+    let aud = process.env.DEFAULT_AUDIENCE;
+    if (apiEvent.queryStringParameters && apiEvent.queryStringParameters.aud) {
+        aud = apiEvent.queryStringParameters.aud;
+    }
+    const kms = new client_kms_1.KMSClient({});
+    // Get KeyID which will be sent as kid in JWT token
+    const currentResponse = await kms.send(new client_kms_1.DescribeKeyCommand({ KeyId: `${KEY_ALIAS_CURRENT}` }));
+    const currentKeyId = currentResponse.KeyMetadata?.KeyId;
+    if (currentKeyId === undefined) {
+        return respond('KMS key could not be retrieved', 500);
+    }
+    // Retrieve Tags for KMS Key - the key is tagged with the `kid` from the JWK which is used in the JWT headers
+    const listResourceTagsResponse = await kms.send(new client_kms_1.ListResourceTagsCommand({ KeyId: currentKeyId }));
+    const kid = getTagValueFromTags('jwk_kid', listResourceTagsResponse.Tags ?? []);
+    if (kid == null) {
+        return respond('KMS key is not correctly tagged', 500);
+    }
+    const iss = process.env.ISSUER;
+    // JWT Token headers
+    const headers = {
+        alg: 'RS256',
+        typ: 'JWT',
+        kid: `${kid}`
+    };
+    // prepare token lifetime property values
+    const issuedAtDate = new Date();
+    const expirationDate = new Date(issuedAtDate);
+    const notBeforeDate = new Date(issuedAtDate);
+    expirationDate.setTime(expirationDate.getTime() + 60 * 60 * 1000); // valid for one hour
+    notBeforeDate.setTime(notBeforeDate.getTime() - 5 * 60 * 1000); // 5m before issuedAtDate
+    // JWT Token payload
+    const payload = {
+        sub: `${identityArn}`,
+        aud,
+        iss,
+        iat: Math.floor(issuedAtDate.getTime() / 1000),
+        exp: Math.floor(expirationDate.getTime() / 1000),
+        nbf: Math.floor(notBeforeDate.getTime() / 1000)
+    };
+    // Prepare message to be signed by KMS
+    const tokenHeaders = (0, base64url_1.default)(JSON.stringify(headers));
+    const tokenPayload = (0, base64url_1.default)(JSON.stringify(payload));
+    // Sign message with KMS
+    const signResponse = await kms.send(new client_kms_1.SignCommand({
+        KeyId: currentKeyId,
+        Message: Buffer.from(`${tokenHeaders}.${tokenPayload}`),
+        SigningAlgorithm: 'RSASSA_PKCS1_V1_5_SHA_256',
+        MessageType: 'RAW'
+    }));
+    logger.debug(JSON.stringify(signResponse));
+    const signature = Buffer
+        .from(signResponse.Signature)
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+    const token = `${tokenHeaders}.${tokenPayload}.${signature}`;
+    logger.debug(token);
+    return respond(JSON.stringify({
+        token
+    }));
+};
+exports.handler = handler;
+function respond(message, statusCode = 200) {
+    return {
+        statusCode,
+        body: message
+    };
+}
+function getARNFromIdentity(identityArn) {
+    if (identityArn === undefined || identityArn === null) {
+        return null;
+    }
+    // Regex for converting arn to base role
+    const captGroups = [
+        'arn:aws:sts:',
+        '(?<regionName>[^:]*)',
+        ':',
+        '(?<accountId>\\d{12})',
+        ':assumed-role\\/',
+        '(?<roleName>[A-z0-9\\-]+?)',
+        '\\/',
+        '(?<user>[^:]*)',
+        '$'
+    ];
+    const regex = new RegExp(captGroups.join(''));
+    const { regionName, accountId, roleName } = regex.exec(identityArn)?.groups ?? {};
+    if (regionName === undefined || accountId === undefined || roleName === undefined) {
+        return null;
+    }
+    // Build base role arn
+    return `arn:aws:iam:${regionName}:${accountId}:role/${roleName}`;
+}
+function getTagValueFromTags(tagKey, tags) {
+    for (const tag of tags) {
+        if (tag.TagKey === tagKey) {
+            return tag.TagValue;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.sign.js","sourceRoot":"","sources":["../src/index.sign.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-FileCopyrightText: 2023 Alliander NV\n//\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda'\nimport { KMSClient, SignCommand, DescribeKeyCommand, ListResourceTagsCommand, Tag } from '@aws-sdk/client-kms'\nimport base64url from 'base64url'\n\nimport { Logger } from '@aws-lambda-powertools/logger'\n\nconst KEY_ALIAS_CURRENT = 'alias/sts/CURRENT'\nconst logger = new Logger()\n\nexport const handler = async (apiEvent: APIGatewayEvent, context: Context): Promise<APIGatewayProxyResult> => {\n  const identityArn = getARNFromIdentity(apiEvent.requestContext.identity?.userArn)\n  logger.debug(identityArn!)\n\n  if (identityArn === undefined || identityArn === null) {\n    logger.info(`Unable to resolve identityArn for userArn: ${apiEvent.requestContext.identity?.userArn}`)\n    return respond('Unable to resolve identity', 400)\n  }\n\n  let aud = process.env.DEFAULT_AUDIENCE\n\n  if (apiEvent.queryStringParameters && apiEvent.queryStringParameters.aud) {\n    aud = apiEvent.queryStringParameters.aud\n  }\n\n  const kms = new KMSClient({})\n\n  // Get KeyID which will be sent as kid in JWT token\n  const currentResponse = await kms.send(new DescribeKeyCommand({ KeyId: `${KEY_ALIAS_CURRENT}` }))\n  const currentKeyId = currentResponse.KeyMetadata?.KeyId\n\n  if (currentKeyId === undefined) {\n    return respond('KMS key could not be retrieved', 500)\n  }\n\n  // Retrieve Tags for KMS Key - the key is tagged with the `kid` from the JWK which is used in the JWT headers\n  const listResourceTagsResponse = await kms.send(new ListResourceTagsCommand({ KeyId: currentKeyId }))\n  const kid = getTagValueFromTags('jwk_kid', listResourceTagsResponse.Tags ?? [])\n\n  if (kid == null) {\n    return respond('KMS key is not correctly tagged', 500)\n  }\n\n  const iss = process.env.ISSUER\n\n  // JWT Token headers\n  const headers: any = {\n    alg: 'RS256',\n    typ: 'JWT',\n    kid: `${kid}`\n  }\n\n  // prepare token lifetime property values\n  const issuedAtDate = new Date()\n  const expirationDate = new Date(issuedAtDate)\n  const notBeforeDate = new Date(issuedAtDate)\n  expirationDate.setTime(expirationDate.getTime() + 60 * 60 * 1000) // valid for one hour\n  notBeforeDate.setTime(notBeforeDate.getTime() - 5 * 60 * 1000) // 5m before issuedAtDate\n\n  // JWT Token payload\n  const payload: any = {\n    sub: `${identityArn}`, // Set role arn as message for payload\n    aud,\n    iss,\n    iat: Math.floor(issuedAtDate.getTime() / 1000),\n    exp: Math.floor(expirationDate.getTime() / 1000),\n    nbf: Math.floor(notBeforeDate.getTime() / 1000)\n  }\n\n  // Prepare message to be signed by KMS\n  const tokenHeaders = base64url(JSON.stringify(headers))\n  const tokenPayload = base64url(JSON.stringify(payload))\n\n  // Sign message with KMS\n  const signResponse = await kms.send(new SignCommand({\n    KeyId: currentKeyId,\n    Message: Buffer.from(`${tokenHeaders}.${tokenPayload}`),\n    SigningAlgorithm: 'RSASSA_PKCS1_V1_5_SHA_256',\n    MessageType: 'RAW'\n  }))\n  logger.debug(JSON.stringify(signResponse))\n\n  const signature = Buffer\n    .from(signResponse.Signature as Uint8Array)\n    .toString('base64')\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_')\n    .replace(/=/g, '')\n\n  const token = `${tokenHeaders}.${tokenPayload}.${signature}`\n  logger.debug(token)\n\n  return respond(JSON.stringify({\n    token\n  }))\n}\n\nfunction respond (message: string, statusCode: number = 200) {\n  return {\n    statusCode,\n    body: message\n  }\n}\n\nfunction getARNFromIdentity (identityArn: string | null) {\n  if (identityArn === undefined || identityArn === null) {\n    return null\n  }\n\n  // Regex for converting arn to base role\n  const captGroups = [\n    'arn:aws:sts:',\n    '(?<regionName>[^:]*)', // group 1\n    ':',\n    '(?<accountId>\\\\d{12})', // group 2\n    ':assumed-role\\\\/',\n    '(?<roleName>[A-z0-9\\\\-]+?)', // group 3\n    '\\\\/',\n    '(?<user>[^:]*)', // group 4\n    '$'\n  ]\n\n  const regex = new RegExp(captGroups.join(''))\n  const { regionName, accountId, roleName } = regex.exec(identityArn)?.groups ?? {}\n\n  if (regionName === undefined || accountId === undefined || roleName === undefined) {\n    return null\n  }\n\n  // Build base role arn\n  return `arn:aws:iam:${regionName}:${accountId}:role/${roleName}`\n}\n\nfunction getTagValueFromTags (tagKey: string, tags: Tag[]) {\n  for (const tag of tags) {\n    if (tag.TagKey === tagKey) {\n      return tag.TagValue\n    }\n  }\n\n  return null\n}\n"]}

package/dist/test/index.keyrotate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/index.keyrotate.test.js

@@ -0,0 +1,152 @@
+"use strict";
+// SPDX-FileCopyrightText: 2023 Alliander NV
+//
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_sdk_client_mock_1 = require("aws-sdk-client-mock");
+const client_kms_1 = require("@aws-sdk/client-kms");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const index_keyrotate_1 = require("../index.keyrotate");
+const kmsMock = (0, aws_sdk_client_mock_1.mockClient)(client_kms_1.KMSClient);
+const s3Mock = (0, aws_sdk_client_mock_1.mockClient)(client_s3_1.S3Client);
+const pubKeys = {
+    PREVIOUS: {
+        pem: 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt0O+biOuAYD5FrM2R6dAliN1v9HA5XpsuoAtXTn8OVKsLvvBFEhBFlghvSXPpu71vE/JYpUj0lL7J54o/RmCz9ZRDzojLU7aWEYM2sEC9nO2ITdu8it+rr3faa70+7PGW09o4iFD+mXYUgadYT8VWxrKQ3eV/LQrSM+6/KYl3BhlNZNxwjtbHGWAldOlzvy14I59GU5W/zDPgOIWSQBbpRvoJKT2rzOZYDtn7C62197hJYAU7QIZ4mOz/ia10ayFFI7p2Uogku3tY5cyYEtSWGzlTL3EiEzSvvsfQ0717bA5ybbDqCWtShg8+IoOxmby4K9X7XuGAQZYE/fgNAXg3wIDAQAB',
+        jwk_kid: 'reND9IAI5hj2pe8UfKm2X6r-SjW1v7s23oC3_N5WPiQ'
+    },
+    CURRENT: {
+        pem: 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/PC3f+8XOs6yway2FhPLdZrWU67RIqFACSPJ0A4q/eJ8GlGXDj8cxHcJBJyvTxEU/rttSe3f44ZfrvwlDUbgAmTi2zYEDrBRHr+LmR6qoyvczLNZkiMmJZygdeOMT87gPx1fb8hhFAXQkOL8dHKiBZ+s4Hls8yu5eMuBhjh+hUYxEQWw0ilDgaXCaGRjooHPSU6+I+Qbm73MuCbBAyzSIAGDKyyD50Kx9Z9Cc0i+6ZfXwWU/2Sda7u4U4R2B/PkhAy0fIjn7kMaw9sgpdQHHxygxQ8y7PduNgDBF/C1zOeKJuRa3QGoMXY9kn/OVBwnZG7bQ9Enz3RnTkM3q0nf9JQIDAQAB',
+        jwk_kid: '-NIJE4RQ8NYWrOOh5_JyGKFAobfY5_oCKo1MrNXoQOg'
+    },
+    PENDING: {
+        pem: 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzeWAt2aRiX57vDd78OwF+83IdEI0mWh05hXvAzQXMqt+QR49hiIWjJtYh1B3sYvbp9BWC8yo+BlWWtsI5fu5mCXsBBp/Q/sgfArEsji+dWEXc+xGRN3hptb9tT+sabIWmd6Qyw4dYCksrBzJvSLO+Hi10Otd2NtzYbAqjZ6soaaClSnrOiw9+J4/GFHuY5gOw8P0uaMclI5sDLGN+G/ayGpUK7xegfEAd9VB6mhdgWoYEAT6yEDnFt0BwvTOYT6TI/5v6scRE7Bywsq5V2Mz5VZe43POcSt1n7vIZ9cXXHSGW8JPv1KKcniHsxIc3Fc74OjcEbqWKw49kVGCE3ayfQIDAQAB',
+        jwk_kid: 'bHyjPYB3AfII8o_X3tGkOCVzThZzQN2UKwKVCO9E9gY'
+    }
+};
+describe('handlers/keyrotate/keyrotate.test.ts', () => {
+    const OLD_ENV = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        kmsMock.reset();
+        s3Mock.reset();
+        process.env = { ...OLD_ENV };
+    });
+    afterEach(() => {
+        kmsMock.reset();
+        s3Mock.reset();
+        process.env = OLD_ENV;
+    });
+    test('should generate & upload correct JWKS file to S3', async () => {
+        kmsMock
+            .on(client_kms_1.GetPublicKeyCommand, { KeyId: 'alias/sts/PREVIOUS' }).resolves({
+            PublicKey: base64ToArrayBuffer(pubKeys.PREVIOUS.pem)
+        })
+            .on(client_kms_1.GetPublicKeyCommand, { KeyId: 'alias/sts/CURRENT' }).resolves({
+            PublicKey: base64ToArrayBuffer(pubKeys.CURRENT.pem)
+        })
+            .on(client_kms_1.GetPublicKeyCommand, { KeyId: 'alias/sts/PENDING' }).resolves({
+            PublicKey: base64ToArrayBuffer(pubKeys.PENDING.pem)
+        })
+            .on(client_kms_1.DescribeKeyCommand, { KeyId: 'alias/sts/PREVIOUS' }).resolves({
+            KeyMetadata: {
+                KeyId: 'key-1'
+            }
+        })
+            .on(client_kms_1.DescribeKeyCommand, { KeyId: 'alias/sts/CURRENT' }).resolves({
+            KeyMetadata: {
+                KeyId: 'key-2'
+            }
+        })
+            .on(client_kms_1.DescribeKeyCommand, { KeyId: 'alias/sts/PENDING' }).resolves({
+            KeyMetadata: {
+                KeyId: 'key-3'
+            }
+        });
+        process.env.S3_BUCKET = 'test-bucket-name';
+        process.env.ISSUER = 'test-issuer.com';
+        await (0, index_keyrotate_1.handler)({ step: 'generateArtifacts' });
+        // @ts-ignore
+        const tagsPrevious = kmsMock.call(2).args[0].input.Tags;
+        expect(tagsPrevious[0].TagKey).toBe('jwk_kid');
+        expect(tagsPrevious[0].TagValue).toBe(pubKeys.PREVIOUS.jwk_kid);
+        // @ts-ignore
+        const tagsCurrent = kmsMock.call(5).args[0].input.Tags;
+        expect(tagsCurrent[0].TagKey).toBe('jwk_kid');
+        expect(tagsCurrent[0].TagValue).toBe(pubKeys.CURRENT.jwk_kid);
+        // @ts-ignore
+        const tagsPending = kmsMock.call(8).args[0].input.Tags;
+        expect(tagsPending[0].TagKey).toBe('jwk_kid');
+        expect(tagsPending[0].TagValue).toBe(pubKeys.PENDING.jwk_kid);
+        // @ts-ignore
+        const s3Key = s3Mock.call(0).args[0].input.Key;
+        expect(s3Key).toBe('discovery/keys');
+        // @ts-ignore
+        const s3Bucket = s3Mock.call(0).args[0].input.Bucket;
+        expect(s3Bucket).toBe('test-bucket-name');
+        // @ts-ignore
+        const s3Body = JSON.parse(s3Mock.call(0).args[0].input.Body.toString());
+        expect(s3Body).toEqual({
+            keys: [
+                {
+                    e: 'AQAB',
+                    kid: 'reND9IAI5hj2pe8UfKm2X6r-SjW1v7s23oC3_N5WPiQ',
+                    kty: 'RSA',
+                    n: 't0O-biOuAYD5FrM2R6dAliN1v9HA5XpsuoAtXTn8OVKsLvvBFEhBFlghvSXPpu71vE_JYpUj0lL7J54o_RmCz9ZRDzojLU7aWEYM2sEC9nO2ITdu8it-rr3faa70-7PGW09o4iFD-mXYUgadYT8VWxrKQ3eV_LQrSM-6_KYl3BhlNZNxwjtbHGWAldOlzvy14I59GU5W_zDPgOIWSQBbpRvoJKT2rzOZYDtn7C62197hJYAU7QIZ4mOz_ia10ayFFI7p2Uogku3tY5cyYEtSWGzlTL3EiEzSvvsfQ0717bA5ybbDqCWtShg8-IoOxmby4K9X7XuGAQZYE_fgNAXg3w',
+                    alg: 'RS256',
+                    use: 'sig'
+                }, {
+                    e: 'AQAB',
+                    kid: '-NIJE4RQ8NYWrOOh5_JyGKFAobfY5_oCKo1MrNXoQOg',
+                    kty: 'RSA',
+                    n: '_PC3f-8XOs6yway2FhPLdZrWU67RIqFACSPJ0A4q_eJ8GlGXDj8cxHcJBJyvTxEU_rttSe3f44ZfrvwlDUbgAmTi2zYEDrBRHr-LmR6qoyvczLNZkiMmJZygdeOMT87gPx1fb8hhFAXQkOL8dHKiBZ-s4Hls8yu5eMuBhjh-hUYxEQWw0ilDgaXCaGRjooHPSU6-I-Qbm73MuCbBAyzSIAGDKyyD50Kx9Z9Cc0i-6ZfXwWU_2Sda7u4U4R2B_PkhAy0fIjn7kMaw9sgpdQHHxygxQ8y7PduNgDBF_C1zOeKJuRa3QGoMXY9kn_OVBwnZG7bQ9Enz3RnTkM3q0nf9JQ',
+                    alg: 'RS256',
+                    use: 'sig'
+                }, {
+                    e: 'AQAB',
+                    kid: 'bHyjPYB3AfII8o_X3tGkOCVzThZzQN2UKwKVCO9E9gY',
+                    kty: 'RSA',
+                    n: 'zeWAt2aRiX57vDd78OwF-83IdEI0mWh05hXvAzQXMqt-QR49hiIWjJtYh1B3sYvbp9BWC8yo-BlWWtsI5fu5mCXsBBp_Q_sgfArEsji-dWEXc-xGRN3hptb9tT-sabIWmd6Qyw4dYCksrBzJvSLO-Hi10Otd2NtzYbAqjZ6soaaClSnrOiw9-J4_GFHuY5gOw8P0uaMclI5sDLGN-G_ayGpUK7xegfEAd9VB6mhdgWoYEAT6yEDnFt0BwvTOYT6TI_5v6scRE7Bywsq5V2Mz5VZe43POcSt1n7vIZ9cXXHSGW8JPv1KKcniHsxIc3Fc74OjcEbqWKw49kVGCE3ayfQ',
+                    alg: 'RS256',
+                    use: 'sig'
+                }
+            ]
+        });
+        // @ts-ignore
+        const s3KeyOpenidConfiguration = s3Mock.call(1).args[0].input.Key;
+        expect(s3KeyOpenidConfiguration).toBe('.well-known/openid-configuration');
+        // @ts-ignore
+        const s3BodyOpenidConfiguration = JSON.parse(s3Mock.call(1).args[0].input.Body.toString());
+        expect(s3BodyOpenidConfiguration).toEqual({
+            issuer: 'test-issuer.com',
+            jwks_uri: 'test-issuer.com/discovery/keys',
+            response_types_supported: [
+                'token'
+            ],
+            id_token_signing_alg_values_supported: [
+                'RS256'
+            ],
+            scopes_supported: [
+                'openid'
+            ],
+            token_endpoint_auth_methods_supported: [
+                'client_secret_basic'
+            ],
+            claims_supported: [
+                'aud',
+                'exp',
+                'iat',
+                'iss',
+                'sub'
+            ]
+        });
+    });
+});
+function base64ToArrayBuffer(b64) {
+    const byteString = atob(b64);
+    const byteArray = new Uint8Array(byteString.length);
+    for (let i = 0; i < byteString.length; i++) {
+        byteArray[i] = byteString.charCodeAt(i);
+    }
+    return byteArray;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.keyrotate.test.js","sourceRoot":"","sources":["../../src/test/index.keyrotate.test.ts"],"names":[],"mappings":"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","sourcesContent":["// SPDX-FileCopyrightText: 2023 Alliander NV\n//\n// SPDX-License-Identifier: Apache-2.0\n\nimport { mockClient } from 'aws-sdk-client-mock'\nimport { KMSClient, GetPublicKeyCommand, DescribeKeyCommand } from '@aws-sdk/client-kms'\nimport { S3Client } from '@aws-sdk/client-s3'\n\nimport { handler } from '../index.keyrotate'\n\nconst kmsMock = mockClient(KMSClient)\nconst s3Mock = mockClient(S3Client)\n\nconst pubKeys = {\n  PREVIOUS: {\n    pem: 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt0O+biOuAYD5FrM2R6dAliN1v9HA5XpsuoAtXTn8OVKsLvvBFEhBFlghvSXPpu71vE/JYpUj0lL7J54o/RmCz9ZRDzojLU7aWEYM2sEC9nO2ITdu8it+rr3faa70+7PGW09o4iFD+mXYUgadYT8VWxrKQ3eV/LQrSM+6/KYl3BhlNZNxwjtbHGWAldOlzvy14I59GU5W/zDPgOIWSQBbpRvoJKT2rzOZYDtn7C62197hJYAU7QIZ4mOz/ia10ayFFI7p2Uogku3tY5cyYEtSWGzlTL3EiEzSvvsfQ0717bA5ybbDqCWtShg8+IoOxmby4K9X7XuGAQZYE/fgNAXg3wIDAQAB',\n    jwk_kid: 'reND9IAI5hj2pe8UfKm2X6r-SjW1v7s23oC3_N5WPiQ'\n  },\n  CURRENT: {\n    pem: 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/PC3f+8XOs6yway2FhPLdZrWU67RIqFACSPJ0A4q/eJ8GlGXDj8cxHcJBJyvTxEU/rttSe3f44ZfrvwlDUbgAmTi2zYEDrBRHr+LmR6qoyvczLNZkiMmJZygdeOMT87gPx1fb8hhFAXQkOL8dHKiBZ+s4Hls8yu5eMuBhjh+hUYxEQWw0ilDgaXCaGRjooHPSU6+I+Qbm73MuCbBAyzSIAGDKyyD50Kx9Z9Cc0i+6ZfXwWU/2Sda7u4U4R2B/PkhAy0fIjn7kMaw9sgpdQHHxygxQ8y7PduNgDBF/C1zOeKJuRa3QGoMXY9kn/OVBwnZG7bQ9Enz3RnTkM3q0nf9JQIDAQAB',\n    jwk_kid: '-NIJE4RQ8NYWrOOh5_JyGKFAobfY5_oCKo1MrNXoQOg'\n  },\n  PENDING: {\n    pem: 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzeWAt2aRiX57vDd78OwF+83IdEI0mWh05hXvAzQXMqt+QR49hiIWjJtYh1B3sYvbp9BWC8yo+BlWWtsI5fu5mCXsBBp/Q/sgfArEsji+dWEXc+xGRN3hptb9tT+sabIWmd6Qyw4dYCksrBzJvSLO+Hi10Otd2NtzYbAqjZ6soaaClSnrOiw9+J4/GFHuY5gOw8P0uaMclI5sDLGN+G/ayGpUK7xegfEAd9VB6mhdgWoYEAT6yEDnFt0BwvTOYT6TI/5v6scRE7Bywsq5V2Mz5VZe43POcSt1n7vIZ9cXXHSGW8JPv1KKcniHsxIc3Fc74OjcEbqWKw49kVGCE3ayfQIDAQAB',\n    jwk_kid: 'bHyjPYB3AfII8o_X3tGkOCVzThZzQN2UKwKVCO9E9gY'\n  }\n}\n\ndescribe('handlers/keyrotate/keyrotate.test.ts', () => {\n  const OLD_ENV = process.env\n\n  beforeEach(() => {\n    jest.resetModules()\n    kmsMock.reset()\n    s3Mock.reset()\n    process.env = { ...OLD_ENV }\n  })\n\n  afterEach(() => {\n    kmsMock.reset()\n    s3Mock.reset()\n    process.env = OLD_ENV\n  })\n\n  test('should generate & upload correct JWKS file to S3', async () => {\n    kmsMock\n      .on(GetPublicKeyCommand, { KeyId: 'alias/sts/PREVIOUS' }).resolves({\n        PublicKey: base64ToArrayBuffer(pubKeys.PREVIOUS.pem)\n      })\n      .on(GetPublicKeyCommand, { KeyId: 'alias/sts/CURRENT' }).resolves({\n        PublicKey: base64ToArrayBuffer(pubKeys.CURRENT.pem)\n      })\n      .on(GetPublicKeyCommand, { KeyId: 'alias/sts/PENDING' }).resolves({\n        PublicKey: base64ToArrayBuffer(pubKeys.PENDING.pem)\n      })\n      .on(DescribeKeyCommand, { KeyId: 'alias/sts/PREVIOUS' }).resolves({\n        KeyMetadata: {\n          KeyId: 'key-1'\n        }\n      })\n      .on(DescribeKeyCommand, { KeyId: 'alias/sts/CURRENT' }).resolves({\n        KeyMetadata: {\n          KeyId: 'key-2'\n        }\n      })\n      .on(DescribeKeyCommand, { KeyId: 'alias/sts/PENDING' }).resolves({\n        KeyMetadata: {\n          KeyId: 'key-3'\n        }\n      })\n\n    process.env.S3_BUCKET = 'test-bucket-name'\n    process.env.ISSUER = 'test-issuer.com'\n\n    await handler({ step: 'generateArtifacts' })\n\n    // @ts-ignore\n    const tagsPrevious = kmsMock.call(2).args[0].input.Tags\n    expect(tagsPrevious[0].TagKey).toBe('jwk_kid')\n    expect(tagsPrevious[0].TagValue).toBe(pubKeys.PREVIOUS.jwk_kid)\n\n    // @ts-ignore\n    const tagsCurrent = kmsMock.call(5).args[0].input.Tags\n    expect(tagsCurrent[0].TagKey).toBe('jwk_kid')\n    expect(tagsCurrent[0].TagValue).toBe(pubKeys.CURRENT.jwk_kid)\n\n    // @ts-ignore\n    const tagsPending = kmsMock.call(8).args[0].input.Tags\n    expect(tagsPending[0].TagKey).toBe('jwk_kid')\n    expect(tagsPending[0].TagValue).toBe(pubKeys.PENDING.jwk_kid)\n\n    // @ts-ignore\n    const s3Key = s3Mock.call(0).args[0].input.Key\n    expect(s3Key).toBe('discovery/keys')\n\n    // @ts-ignore\n    const s3Bucket = s3Mock.call(0).args[0].input.Bucket\n    expect(s3Bucket).toBe('test-bucket-name')\n\n    // @ts-ignore\n    const s3Body = JSON.parse(s3Mock.call(0).args[0].input.Body.toString())\n    expect(s3Body).toEqual({\n      keys: [\n        {\n          e: 'AQAB',\n          kid: 'reND9IAI5hj2pe8UfKm2X6r-SjW1v7s23oC3_N5WPiQ',\n          kty: 'RSA',\n          n: 't0O-biOuAYD5FrM2R6dAliN1v9HA5XpsuoAtXTn8OVKsLvvBFEhBFlghvSXPpu71vE_JYpUj0lL7J54o_RmCz9ZRDzojLU7aWEYM2sEC9nO2ITdu8it-rr3faa70-7PGW09o4iFD-mXYUgadYT8VWxrKQ3eV_LQrSM-6_KYl3BhlNZNxwjtbHGWAldOlzvy14I59GU5W_zDPgOIWSQBbpRvoJKT2rzOZYDtn7C62197hJYAU7QIZ4mOz_ia10ayFFI7p2Uogku3tY5cyYEtSWGzlTL3EiEzSvvsfQ0717bA5ybbDqCWtShg8-IoOxmby4K9X7XuGAQZYE_fgNAXg3w',\n          alg: 'RS256',\n          use: 'sig'\n        }, {\n          e: 'AQAB',\n          kid: '-NIJE4RQ8NYWrOOh5_JyGKFAobfY5_oCKo1MrNXoQOg',\n          kty: 'RSA',\n          n: '_PC3f-8XOs6yway2FhPLdZrWU67RIqFACSPJ0A4q_eJ8GlGXDj8cxHcJBJyvTxEU_rttSe3f44ZfrvwlDUbgAmTi2zYEDrBRHr-LmR6qoyvczLNZkiMmJZygdeOMT87gPx1fb8hhFAXQkOL8dHKiBZ-s4Hls8yu5eMuBhjh-hUYxEQWw0ilDgaXCaGRjooHPSU6-I-Qbm73MuCbBAyzSIAGDKyyD50Kx9Z9Cc0i-6ZfXwWU_2Sda7u4U4R2B_PkhAy0fIjn7kMaw9sgpdQHHxygxQ8y7PduNgDBF_C1zOeKJuRa3QGoMXY9kn_OVBwnZG7bQ9Enz3RnTkM3q0nf9JQ',\n          alg: 'RS256',\n          use: 'sig'\n        }, {\n          e: 'AQAB',\n          kid: 'bHyjPYB3AfII8o_X3tGkOCVzThZzQN2UKwKVCO9E9gY',\n          kty: 'RSA',\n          n: 'zeWAt2aRiX57vDd78OwF-83IdEI0mWh05hXvAzQXMqt-QR49hiIWjJtYh1B3sYvbp9BWC8yo-BlWWtsI5fu5mCXsBBp_Q_sgfArEsji-dWEXc-xGRN3hptb9tT-sabIWmd6Qyw4dYCksrBzJvSLO-Hi10Otd2NtzYbAqjZ6soaaClSnrOiw9-J4_GFHuY5gOw8P0uaMclI5sDLGN-G_ayGpUK7xegfEAd9VB6mhdgWoYEAT6yEDnFt0BwvTOYT6TI_5v6scRE7Bywsq5V2Mz5VZe43POcSt1n7vIZ9cXXHSGW8JPv1KKcniHsxIc3Fc74OjcEbqWKw49kVGCE3ayfQ',\n          alg: 'RS256',\n          use: 'sig'\n        }]\n    })\n\n    // @ts-ignore\n    const s3KeyOpenidConfiguration = s3Mock.call(1).args[0].input.Key\n    expect(s3KeyOpenidConfiguration).toBe('.well-known/openid-configuration')\n\n    // @ts-ignore\n    const s3BodyOpenidConfiguration = JSON.parse(s3Mock.call(1).args[0].input.Body.toString())\n    expect(s3BodyOpenidConfiguration).toEqual({\n      issuer: 'test-issuer.com',\n      jwks_uri: 'test-issuer.com/discovery/keys',\n      response_types_supported: [\n        'token'\n      ],\n      id_token_signing_alg_values_supported: [\n        'RS256'\n      ],\n      scopes_supported: [\n        'openid'\n      ],\n      token_endpoint_auth_methods_supported: [\n        'client_secret_basic'\n      ],\n      claims_supported: [\n        'aud',\n        'exp',\n        'iat',\n        'iss',\n        'sub'\n      ]\n    })\n  })\n})\n\nfunction base64ToArrayBuffer (b64: string) {\n  const byteString = atob(b64)\n  const byteArray = new Uint8Array(byteString.length)\n  for (let i = 0; i < byteString.length; i++) {\n    byteArray[i] = byteString.charCodeAt(i)\n  }\n\n  return byteArray\n}\n"]}

package/dist/test/index.sign.test.d.ts

@@ -0,0 +1 @@
+export {};