diff --git a/.circleci/config.yml b/.circleci/config.yml index 6cda4ef5..e92f487c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -104,6 +104,9 @@ jobs: - set_aws_prefix - checkout - node/install-packages + - run: + name: Run unit tests + command: npm run unit-test - run: name: Run infra tests command: npm run infra-test diff --git a/examples/simple-authenticated-api/.gitignore b/examples/simple-authenticated-api/.gitignore index 1807d587..aec09340 100644 --- a/examples/simple-authenticated-api/.gitignore +++ b/examples/simple-authenticated-api/.gitignore @@ -10,3 +10,5 @@ cdk.context.json !src/lambda/route1.js !src/lambda/route2.js +!src/lambda/route3.js +!src/lambda/route4.js diff --git a/examples/simple-authenticated-api/lib/simple-authenticated-api-stack.ts b/examples/simple-authenticated-api/lib/simple-authenticated-api-stack.ts index 75c94099..70c12685 100644 --- a/examples/simple-authenticated-api/lib/simple-authenticated-api-stack.ts +++ b/examples/simple-authenticated-api/lib/simple-authenticated-api-stack.ts @@ -85,6 +85,32 @@ export class SimpleAuthenticatedApiStack extends cdk.Stack { } ); + const route3Handler = new AuthenticatedApiFunction( + this, + `${prefix}simple-authenticated-api-route3-handler`, + { + name: `${prefix}route3-handler`, + entry: "src/lambda/route3.js", + environment: {}, + handler: "route", + timeout: cdk.Duration.seconds(30), + securityGroups: lambdaSecurityGroups, + } + ); + + const route4Handler = new AuthenticatedApiFunction( + this, + `${prefix}simple-authenticated-api-route4-handler`, + { + name: `${prefix}route4-handler`, + entry: "src/lambda/route4.js", + environment: {}, + handler: "route", + timeout: cdk.Duration.seconds(30), + securityGroups: lambdaSecurityGroups, + } + ); + const api = new AuthenticatedApi( this, `${prefix}simple-authenticated-api`, @@ -127,6 +153,20 @@ export class SimpleAuthenticatedApiStack extends cdk.Stack { lambda: route2Handler, isPublic: true, }, + { + name: "route3", + path: "/1/route3/{id}", + method: apigatewayv2.HttpMethod.GET, + lambda: route3Handler, + requiredScope: "analytics:admin", + }, + { + name: "route4", + path: "/1/route4/{id}/route4", + method: apigatewayv2.HttpMethod.GET, + lambda: route4Handler, + requiredScope: "analytics:admin", + }, ], } ); diff --git a/examples/simple-authenticated-api/src/lambda/route3.js b/examples/simple-authenticated-api/src/lambda/route3.js new file mode 100644 index 00000000..b61f7647 --- /dev/null +++ b/examples/simple-authenticated-api/src/lambda/route3.js @@ -0,0 +1,20 @@ +class Route { + constructor(event) { + this.event = event; + } + + async handle() { + console.log("Route 3 processing event."); + + return { + statusCode: 200, + headers: {}, + body: "route 3", + }; + } +} + +module.exports.route = async (event) => { + const route = new Route(event); + return await route.handle(); +}; diff --git a/examples/simple-authenticated-api/src/lambda/route4.js b/examples/simple-authenticated-api/src/lambda/route4.js new file mode 100644 index 00000000..70d35d38 --- /dev/null +++ b/examples/simple-authenticated-api/src/lambda/route4.js @@ -0,0 +1,20 @@ +class Route { + constructor(event) { + this.event = event; + } + + async handle() { + console.log("Route 4 processing event."); + + return { + statusCode: 200, + headers: {}, + body: "route 4", + }; + } +} + +module.exports.route = async (event) => { + const route = new Route(event); + return await route.handle(); +}; diff --git a/lib/authenticated-api/authenticated-api.ts b/lib/authenticated-api/authenticated-api.ts index 46678879..c36c5a16 100644 --- a/lib/authenticated-api/authenticated-api.ts +++ b/lib/authenticated-api/authenticated-api.ts @@ -80,7 +80,7 @@ export class AuthenticatedApi extends cdk.Construct { if (props.lambdaRoutes) { for (const routeProps of props.lambdaRoutes) { if (routeProps.requiredScope) { - scopeConfig[`^${routeProps.path}$`] = routeProps.requiredScope; + scopeConfig[routeProps.path] = routeProps.requiredScope; } } } diff --git a/package.json b/package.json index d447f1e6..b7f4bea9 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,7 @@ "scripts": { "build": "tsc", "watch": "tsc -w", + "unit-test": "npm run build && jest test/unit", "infra-test": "npm run build && jest test/infra", "integration-test": "npm run build && npm run jest-integration-test", "jest-integration-test": "jest test/integration/", diff --git a/src/lambda/api/authorizer.d.ts b/src/lambda/api/authorizer.d.ts index cb0ff5c3..e3b5ba76 100644 --- a/src/lambda/api/authorizer.d.ts +++ b/src/lambda/api/authorizer.d.ts @@ -1 +1,46 @@ +import { PersonaClient } from "talis-node"; +declare type ParsedArn = { + method: string; + resourcePath: string; + apiOptions: { + region: string; + restApiId: string; + stage: string; + }; + awsAccountId: string; +}; +export declare class PersonaAuthorizer { + event: any; + context: any; + personaClient: PersonaClient | undefined; + constructor(event: any, context: any); + handle(): Promise; + validateToken(validationOpts: any): Promise>; + /** + * Break down an API gateway method ARN into it's constituent parts. + * Method ARNs take the following format: + * + * arn:aws:execute-api:::/// + * + * e.g: + * + * arn:aws:execute-api:eu-west-1:123:abc/development/GET/2/works + * + * @param methodArn {string} The method ARN provided by the event handed to a Lambda function + * @returns {{ + * method: string, + * resourcePath: string, + * apiOptions: { + * region: string, + * restApiId: string, + * stage: string + * }, + * awsAccountId: string + * }} + */ + parseMethodArn(methodArn: string): ParsedArn; + getScope(parsedMethodArn: ParsedArn): any; + getPersonaClient(): PersonaClient; + pathMatch(pathDefinition: string, path: string): boolean; +} export {}; diff --git a/src/lambda/api/authorizer.js b/src/lambda/api/authorizer.js index 01563891..2976de3e 100644 --- a/src/lambda/api/authorizer.js +++ b/src/lambda/api/authorizer.js @@ -1,5 +1,6 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); +exports.PersonaAuthorizer = void 0; const _ = require("lodash"); const talis_node_1 = require("talis-node"); // Constants used by parseMethodArn: @@ -164,9 +165,9 @@ class PersonaAuthorizer { const scopeConfig = process.env["SCOPE_CONFIG"]; if (scopeConfig != undefined) { const conf = JSON.parse(scopeConfig); - for (const pathRegEx of Object.keys(conf)) { - if (parsedMethodArn.resourcePath.match(pathRegEx)) { - return conf[pathRegEx]; + for (const path of Object.keys(conf)) { + if (this.pathMatch(path, parsedMethodArn.resourcePath)) { + return conf[path]; } } } @@ -184,9 +185,32 @@ class PersonaAuthorizer { } return this.personaClient; } + pathMatch(pathDefinition, path) { + const pathDefinitionParts = pathDefinition.split("/"); + const pathParts = path.split("/"); + if (pathDefinitionParts.length !== pathParts.length) { + return false; + } + for (let i = 0; i < pathDefinitionParts.length; i++) { + const pathDefinitionSegment = pathDefinitionParts[i]; + const pathSegment = pathParts[i]; + if (pathDefinitionSegment.startsWith("{") && + pathDefinitionSegment.endsWith("}")) { + // Matches path argument + } + else { + // Should match directly + if (pathDefinitionSegment !== pathSegment) { + return false; + } + } + } + return true; + } } +exports.PersonaAuthorizer = PersonaAuthorizer; module.exports.validateToken = async (event, context) => { const route = new PersonaAuthorizer(event, context); return await route.handle(); }; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorizer.js","sourceRoot":"","sources":["authorizer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _ from \"lodash\";\nimport { persona, PersonaClient } from \"talis-node\";\n\ntype ParsedArn = {\n  method: string;\n  resourcePath: string;\n  apiOptions: {\n    region: string;\n    restApiId: string;\n    stage: string;\n  };\n  awsAccountId: string;\n};\n\n// Constants used by parseMethodArn:\n//\n// Example MethodARN:\n//   \"arn:aws:execute-api:<Region id>:<Account id>:<API id>/<Stage>/<Method>/<Resource path>\"\n// Method ARN Index:  0   1   2           3           4            5\n// API Gateway ARN Index:                                          0        1       2        3\n//\n//\nconst ARN_INDEX = 0;\nconst AWS_INDEX = 1;\nconst EXECUTE_INDEX = 2;\nconst REGION_INDEX = 3;\nconst ACCOUNT_ID_INDEX = 4;\nconst API_GATEWAY_ARN_INDEX = 5;\n\nconst METHOD_ARN_INDEXES = [\n  ARN_INDEX,\n  AWS_INDEX,\n  EXECUTE_INDEX,\n  REGION_INDEX,\n  ACCOUNT_ID_INDEX,\n  API_GATEWAY_ARN_INDEX,\n];\n\nconst API_ID_INDEX = 0;\nconst STAGE_INDEX = 1;\nconst METHOD_INDEX = 2;\nconst RESOURCE_PATH_INDEX = 3;\n\nconst API_GATEWAY_ARN_INDEXES = [\n  API_ID_INDEX,\n  STAGE_INDEX,\n  METHOD_INDEX,\n  RESOURCE_PATH_INDEX,\n];\n\nclass PersonaAuthorizer {\n  event: any;\n  context: any;\n  personaClient: PersonaClient | undefined;\n\n  constructor(event: any, context: any) {\n    this.event = event;\n    this.context = context;\n\n    this.personaClient = undefined;\n  }\n\n  async handle() {\n    console.log(\"Received event\", this.event);\n\n    if (!this.event?.headers || this.event.headers[\"authorization\"] == null) {\n      console.log(\"Missing auth token\");\n      return this.context.fail(\"Unauthorized\");\n    }\n\n    const parsedMethodArn = this.parseMethodArn(this.event.routeArn);\n    console.log(`Parsed Method Arn: ${JSON.stringify(parsedMethodArn)}`);\n\n    const scope = this.getScope(parsedMethodArn);\n    console.log(`Method has scope: ${scope}`);\n\n    let validationOpts = {\n      token: _.replace(\n        this.event.headers[\"authorization\"],\n        \"Bearer\",\n        \"\"\n      ).trim(),\n    };\n    if (scope != null) {\n      validationOpts = _.merge(validationOpts, { scope });\n    }\n    console.log(`Validation ops: ${JSON.stringify(validationOpts)}`);\n\n    console.log(\n      \"validating token against request\",\n      `${parsedMethodArn.resourcePath}`\n    );\n\n    if (!validationOpts.token || validationOpts.token.length === 0) {\n      console.log(\"token missing\");\n      return this.context.fail(\"Unauthorized\");\n    }\n\n    try {\n      const token = await this.validateToken(validationOpts);\n      const success = {\n        isAuthorized: true,\n        context: {\n          clientId: token[\"sub\"],\n        },\n      };\n      return this.context.succeed(success);\n    } catch (err) {\n      console.log(\"token validation failed\", err);\n\n      const error = err as { error: any; token: Record<string, any> };\n\n      if (error.error === persona.errorTypes.INSUFFICIENT_SCOPE) {\n        const insufficientScope = {\n          isAuthorized: false,\n          context: {\n            description: \"Insufficient Scope\",\n            clientId: error?.token ? error.token[\"sub\"] : \"\",\n          },\n        };\n        return this.context.succeed(insufficientScope);\n      }\n\n      const failure = {\n        isAuthorized: false,\n        context: {\n          clientId: error?.token ? error.token[\"sub\"] : \"\",\n        },\n      };\n      return this.context.succeed(failure);\n    }\n  }\n\n  validateToken(validationOpts: any): Promise<Record<string, any>> {\n    const client = this.getPersonaClient();\n    return new Promise(function (resolve, reject) {\n      client.validateToken(\n        validationOpts,\n        (error: any, ok: any, decodedToken: any) => {\n          if (error) {\n            reject({\n              error: error,\n              token: decodedToken,\n            });\n          }\n          resolve(decodedToken);\n        }\n      );\n    });\n  }\n\n  /**\n   * Break down an API gateway method ARN into it's constituent parts.\n   * Method ARNs take the following format:\n   *\n   *   arn:aws:execute-api:<Region id>:<Account id>:<API id>/<Stage>/<Method>/<Resource path>\n   *\n   * e.g:\n   *\n   *   arn:aws:execute-api:eu-west-1:123:abc/development/GET/2/works\n   *\n   * @param methodArn {string} The method ARN provided by the event handed to a Lambda function\n   * @returns {{\n   *   method: string,\n   *   resourcePath: string,\n   *   apiOptions: {\n   *     region: string,\n   *     restApiId: string,\n   *     stage: string\n   *   },\n   *   awsAccountId: string\n   *   }}\n   */\n  parseMethodArn(methodArn: string): ParsedArn {\n    const methodArnParts = methodArn.split(\":\");\n    console.log(`Method ARN Parts: ${JSON.stringify(methodArnParts)}`);\n    let apiGatewayArn = methodArnParts[API_GATEWAY_ARN_INDEX];\n    // If the split created more than the expected number of parts, then the\n    // apiGatewayArn must have had one or more :'s in it. Recreate the apiGateway arn.\n    for (\n      let index = METHOD_ARN_INDEXES.length;\n      index < methodArnParts.length;\n      index += 1\n    ) {\n      apiGatewayArn += `:${methodArnParts[index]}`;\n    }\n\n    const apiGatewayArnParts = apiGatewayArn.split(\"/\");\n    console.log(`api gateway arn parts: ${JSON.stringify(apiGatewayArnParts)}`);\n\n    // If the split created more than the expected number of parts, then the\n    // resource path must have had one or more /'s in it. Recreate the resource path.\n    let resourcePath = \"\";\n    for (\n      let i = API_GATEWAY_ARN_INDEXES.length - 1;\n      i < apiGatewayArnParts.length;\n      i += 1\n    ) {\n      resourcePath += `/${apiGatewayArnParts[i]}`;\n    }\n    console.log(`resource path: ${JSON.stringify(resourcePath)}`);\n    return {\n      method: apiGatewayArnParts[METHOD_INDEX],\n      resourcePath,\n      apiOptions: {\n        region: methodArnParts[REGION_INDEX],\n        restApiId: apiGatewayArnParts[API_ID_INDEX],\n        stage: apiGatewayArnParts[STAGE_INDEX],\n      },\n      awsAccountId: methodArnParts[ACCOUNT_ID_INDEX],\n    };\n  }\n\n  getScope(parsedMethodArn: ParsedArn) {\n    const scopeConfig = process.env[\"SCOPE_CONFIG\"];\n    if (scopeConfig != undefined) {\n      const conf = JSON.parse(scopeConfig);\n      for (const pathRegEx of Object.keys(conf)) {\n        if (parsedMethodArn.resourcePath.match(pathRegEx)) {\n          return conf[pathRegEx];\n        }\n      }\n    }\n    return null;\n  }\n\n  getPersonaClient() {\n    if (this.personaClient == null) {\n      const personaConfig = {\n        persona_host: process.env[\"PERSONA_HOST\"],\n        persona_scheme: process.env[\"PERSONA_SCHEME\"],\n        persona_port: process.env[\"PERSONA_PORT\"],\n        persona_oauth_route: process.env[\"PERSONA_OAUTH_ROUTE\"],\n      };\n\n      this.personaClient = persona.createClient(\n        `${process.env[\"PERSONA_CLIENT_NAME\"]} (lambda; NODE_ENV=${process.env[\"NODE_ENV\"]})`,\n        _.merge(personaConfig, {})\n      );\n    }\n\n    return this.personaClient;\n  }\n}\n\nmodule.exports.validateToken = async (event: any, context: any) => {\n  const route = new PersonaAuthorizer(event, context);\n  return await route.handle();\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorizer.js","sourceRoot":"","sources":["authorizer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as _ from \"lodash\";\nimport { persona, PersonaClient } from \"talis-node\";\n\ntype ParsedArn = {\n  method: string;\n  resourcePath: string;\n  apiOptions: {\n    region: string;\n    restApiId: string;\n    stage: string;\n  };\n  awsAccountId: string;\n};\n\n// Constants used by parseMethodArn:\n//\n// Example MethodARN:\n//   \"arn:aws:execute-api:<Region id>:<Account id>:<API id>/<Stage>/<Method>/<Resource path>\"\n// Method ARN Index:  0   1   2           3           4            5\n// API Gateway ARN Index:                                          0        1       2        3\n//\n//\nconst ARN_INDEX = 0;\nconst AWS_INDEX = 1;\nconst EXECUTE_INDEX = 2;\nconst REGION_INDEX = 3;\nconst ACCOUNT_ID_INDEX = 4;\nconst API_GATEWAY_ARN_INDEX = 5;\n\nconst METHOD_ARN_INDEXES = [\n  ARN_INDEX,\n  AWS_INDEX,\n  EXECUTE_INDEX,\n  REGION_INDEX,\n  ACCOUNT_ID_INDEX,\n  API_GATEWAY_ARN_INDEX,\n];\n\nconst API_ID_INDEX = 0;\nconst STAGE_INDEX = 1;\nconst METHOD_INDEX = 2;\nconst RESOURCE_PATH_INDEX = 3;\n\nconst API_GATEWAY_ARN_INDEXES = [\n  API_ID_INDEX,\n  STAGE_INDEX,\n  METHOD_INDEX,\n  RESOURCE_PATH_INDEX,\n];\n\nexport class PersonaAuthorizer {\n  event: any;\n  context: any;\n  personaClient: PersonaClient | undefined;\n\n  constructor(event: any, context: any) {\n    this.event = event;\n    this.context = context;\n\n    this.personaClient = undefined;\n  }\n\n  async handle() {\n    console.log(\"Received event\", this.event);\n\n    if (!this.event?.headers || this.event.headers[\"authorization\"] == null) {\n      console.log(\"Missing auth token\");\n      return this.context.fail(\"Unauthorized\");\n    }\n\n    const parsedMethodArn = this.parseMethodArn(this.event.routeArn);\n    console.log(`Parsed Method Arn: ${JSON.stringify(parsedMethodArn)}`);\n\n    const scope = this.getScope(parsedMethodArn);\n    console.log(`Method has scope: ${scope}`);\n\n    let validationOpts = {\n      token: _.replace(\n        this.event.headers[\"authorization\"],\n        \"Bearer\",\n        \"\"\n      ).trim(),\n    };\n    if (scope != null) {\n      validationOpts = _.merge(validationOpts, { scope });\n    }\n    console.log(`Validation ops: ${JSON.stringify(validationOpts)}`);\n\n    console.log(\n      \"validating token against request\",\n      `${parsedMethodArn.resourcePath}`\n    );\n\n    if (!validationOpts.token || validationOpts.token.length === 0) {\n      console.log(\"token missing\");\n      return this.context.fail(\"Unauthorized\");\n    }\n\n    try {\n      const token = await this.validateToken(validationOpts);\n      const success = {\n        isAuthorized: true,\n        context: {\n          clientId: token[\"sub\"],\n        },\n      };\n      return this.context.succeed(success);\n    } catch (err) {\n      console.log(\"token validation failed\", err);\n\n      const error = err as { error: any; token: Record<string, any> };\n\n      if (error.error === persona.errorTypes.INSUFFICIENT_SCOPE) {\n        const insufficientScope = {\n          isAuthorized: false,\n          context: {\n            description: \"Insufficient Scope\",\n            clientId: error?.token ? error.token[\"sub\"] : \"\",\n          },\n        };\n        return this.context.succeed(insufficientScope);\n      }\n\n      const failure = {\n        isAuthorized: false,\n        context: {\n          clientId: error?.token ? error.token[\"sub\"] : \"\",\n        },\n      };\n      return this.context.succeed(failure);\n    }\n  }\n\n  validateToken(validationOpts: any): Promise<Record<string, any>> {\n    const client = this.getPersonaClient();\n    return new Promise(function (resolve, reject) {\n      client.validateToken(\n        validationOpts,\n        (error: any, ok: any, decodedToken: any) => {\n          if (error) {\n            reject({\n              error: error,\n              token: decodedToken,\n            });\n          }\n          resolve(decodedToken);\n        }\n      );\n    });\n  }\n\n  /**\n   * Break down an API gateway method ARN into it's constituent parts.\n   * Method ARNs take the following format:\n   *\n   *   arn:aws:execute-api:<Region id>:<Account id>:<API id>/<Stage>/<Method>/<Resource path>\n   *\n   * e.g:\n   *\n   *   arn:aws:execute-api:eu-west-1:123:abc/development/GET/2/works\n   *\n   * @param methodArn {string} The method ARN provided by the event handed to a Lambda function\n   * @returns {{\n   *   method: string,\n   *   resourcePath: string,\n   *   apiOptions: {\n   *     region: string,\n   *     restApiId: string,\n   *     stage: string\n   *   },\n   *   awsAccountId: string\n   *   }}\n   */\n  parseMethodArn(methodArn: string): ParsedArn {\n    const methodArnParts = methodArn.split(\":\");\n    console.log(`Method ARN Parts: ${JSON.stringify(methodArnParts)}`);\n    let apiGatewayArn = methodArnParts[API_GATEWAY_ARN_INDEX];\n    // If the split created more than the expected number of parts, then the\n    // apiGatewayArn must have had one or more :'s in it. Recreate the apiGateway arn.\n    for (\n      let index = METHOD_ARN_INDEXES.length;\n      index < methodArnParts.length;\n      index += 1\n    ) {\n      apiGatewayArn += `:${methodArnParts[index]}`;\n    }\n\n    const apiGatewayArnParts = apiGatewayArn.split(\"/\");\n    console.log(`api gateway arn parts: ${JSON.stringify(apiGatewayArnParts)}`);\n\n    // If the split created more than the expected number of parts, then the\n    // resource path must have had one or more /'s in it. Recreate the resource path.\n    let resourcePath = \"\";\n    for (\n      let i = API_GATEWAY_ARN_INDEXES.length - 1;\n      i < apiGatewayArnParts.length;\n      i += 1\n    ) {\n      resourcePath += `/${apiGatewayArnParts[i]}`;\n    }\n    console.log(`resource path: ${JSON.stringify(resourcePath)}`);\n    return {\n      method: apiGatewayArnParts[METHOD_INDEX],\n      resourcePath,\n      apiOptions: {\n        region: methodArnParts[REGION_INDEX],\n        restApiId: apiGatewayArnParts[API_ID_INDEX],\n        stage: apiGatewayArnParts[STAGE_INDEX],\n      },\n      awsAccountId: methodArnParts[ACCOUNT_ID_INDEX],\n    };\n  }\n\n  getScope(parsedMethodArn: ParsedArn) {\n    const scopeConfig = process.env[\"SCOPE_CONFIG\"];\n    if (scopeConfig != undefined) {\n      const conf = JSON.parse(scopeConfig);\n      for (const path of Object.keys(conf)) {\n        if (this.pathMatch(path, parsedMethodArn.resourcePath)) {\n          return conf[path];\n        }\n      }\n    }\n    return null;\n  }\n\n  getPersonaClient() {\n    if (this.personaClient == null) {\n      const personaConfig = {\n        persona_host: process.env[\"PERSONA_HOST\"],\n        persona_scheme: process.env[\"PERSONA_SCHEME\"],\n        persona_port: process.env[\"PERSONA_PORT\"],\n        persona_oauth_route: process.env[\"PERSONA_OAUTH_ROUTE\"],\n      };\n\n      this.personaClient = persona.createClient(\n        `${process.env[\"PERSONA_CLIENT_NAME\"]} (lambda; NODE_ENV=${process.env[\"NODE_ENV\"]})`,\n        _.merge(personaConfig, {})\n      );\n    }\n\n    return this.personaClient;\n  }\n\n  pathMatch(pathDefinition: string, path: string): boolean {\n    const pathDefinitionParts = pathDefinition.split(\"/\");\n    const pathParts = path.split(\"/\");\n\n    if (pathDefinitionParts.length !== pathParts.length) {\n      return false;\n    }\n\n    for (let i = 0; i < pathDefinitionParts.length; i++) {\n      const pathDefinitionSegment = pathDefinitionParts[i];\n      const pathSegment = pathParts[i];\n\n      if (\n        pathDefinitionSegment.startsWith(\"{\") &&\n        pathDefinitionSegment.endsWith(\"}\")\n      ) {\n        // Matches path argument\n      } else {\n        // Should match directly\n        if (pathDefinitionSegment !== pathSegment) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n}\n\nmodule.exports.validateToken = async (event: any, context: any) => {\n  const route = new PersonaAuthorizer(event, context);\n  return await route.handle();\n};\n"]} \ No newline at end of file diff --git a/src/lambda/api/authorizer.ts b/src/lambda/api/authorizer.ts index 31d7260f..83e1b2d3 100644 --- a/src/lambda/api/authorizer.ts +++ b/src/lambda/api/authorizer.ts @@ -48,7 +48,7 @@ const API_GATEWAY_ARN_INDEXES = [ RESOURCE_PATH_INDEX, ]; -class PersonaAuthorizer { +export class PersonaAuthorizer { event: any; context: any; personaClient: PersonaClient | undefined; @@ -215,9 +215,9 @@ class PersonaAuthorizer { const scopeConfig = process.env["SCOPE_CONFIG"]; if (scopeConfig != undefined) { const conf = JSON.parse(scopeConfig); - for (const pathRegEx of Object.keys(conf)) { - if (parsedMethodArn.resourcePath.match(pathRegEx)) { - return conf[pathRegEx]; + for (const path of Object.keys(conf)) { + if (this.pathMatch(path, parsedMethodArn.resourcePath)) { + return conf[path]; } } } @@ -241,6 +241,34 @@ class PersonaAuthorizer { return this.personaClient; } + + pathMatch(pathDefinition: string, path: string): boolean { + const pathDefinitionParts = pathDefinition.split("/"); + const pathParts = path.split("/"); + + if (pathDefinitionParts.length !== pathParts.length) { + return false; + } + + for (let i = 0; i < pathDefinitionParts.length; i++) { + const pathDefinitionSegment = pathDefinitionParts[i]; + const pathSegment = pathParts[i]; + + if ( + pathDefinitionSegment.startsWith("{") && + pathDefinitionSegment.endsWith("}") + ) { + // Matches path argument + } else { + // Should match directly + if (pathDefinitionSegment !== pathSegment) { + return false; + } + } + } + + return true; + } } module.exports.validateToken = async (event: any, context: any) => { diff --git a/test/integration/authenticated-api/authenticated-api.test.ts b/test/integration/authenticated-api/authenticated-api.test.ts index 384587b8..f1242b90 100644 --- a/test/integration/authenticated-api/authenticated-api.test.ts +++ b/test/integration/authenticated-api/authenticated-api.test.ts @@ -156,4 +156,66 @@ describe("AuthenticatedApi", () => { expect(response.status).toBe(200); expect(response.data).toBe("Simple Authenticated Api Documentation"); }); + + test("returns 200 when routing to a url ending in a path argument", async () => { + const token = await getOAuthToken( + TALIS_CDK_AUTH_API_VALID_CLIENT, + TALIS_CDK_AUTH_API_VALID_SECRET + ); + const axiosAuthInstance = axios.create({ + headers: { Authorization: `Bearer ${token}` }, + baseURL: `https://${apiGatewayId}.execute-api.eu-west-1.amazonaws.com/1/`, + }); + const response = await axiosAuthInstance.get("route3/1234"); + expect(response.status).toBe(200); + expect(response.data).toBe("route 3"); + }); + + test("returns 403 when routing to a url ending in a path argument", async () => { + const token = await getOAuthToken( + TALIS_CDK_AUTH_API_MISSING_SCOPE_CLIENT, + TALIS_CDK_AUTH_API_MISSING_SCOPE_SECRET + ); + try { + const axiosBadAuthInstance = axios.create({ + headers: { Authorization: `Bearer ${token}` }, + baseURL: `https://${apiGatewayId}.execute-api.eu-west-1.amazonaws.com/1/`, + }); + await axiosBadAuthInstance.get("route3/1234"); + throw Error("Expected a 403 response"); + } catch (err) { + expect(err.message).toBe("Request failed with status code 403"); + } + }); + + test("returns 200 when routing to a url containing a path argument", async () => { + const token = await getOAuthToken( + TALIS_CDK_AUTH_API_VALID_CLIENT, + TALIS_CDK_AUTH_API_VALID_SECRET + ); + const axiosAuthInstance = axios.create({ + headers: { Authorization: `Bearer ${token}` }, + baseURL: `https://${apiGatewayId}.execute-api.eu-west-1.amazonaws.com/1/`, + }); + const response = await axiosAuthInstance.get("route4/1234/route4"); + expect(response.status).toBe(200); + expect(response.data).toBe("route 4"); + }); + + test("returns 403 when routing to a url containing a path argument", async () => { + const token = await getOAuthToken( + TALIS_CDK_AUTH_API_MISSING_SCOPE_CLIENT, + TALIS_CDK_AUTH_API_MISSING_SCOPE_SECRET + ); + try { + const axiosBadAuthInstance = axios.create({ + headers: { Authorization: `Bearer ${token}` }, + baseURL: `https://${apiGatewayId}.execute-api.eu-west-1.amazonaws.com/1/`, + }); + await axiosBadAuthInstance.get("route4/1234/route4"); + throw Error("Expected a 403 response"); + } catch (err) { + expect(err.message).toBe("Request failed with status code 403"); + } + }); }); diff --git a/test/unit/lambda/api/authorizer.test.ts b/test/unit/lambda/api/authorizer.test.ts new file mode 100644 index 00000000..bfed901e --- /dev/null +++ b/test/unit/lambda/api/authorizer.test.ts @@ -0,0 +1,58 @@ +import { PersonaAuthorizer } from "../../../../src/lambda/api/authorizer"; + +describe("authorizer", () => { + describe("pathMatch", () => { + const pathMatchTests = [ + { + title: "matches simple paths", + pathDefinition: "/1/route1", + path: "/1/route1", + expectedResult: true, + }, + { + title: "does not match different simple paths", + pathDefinition: "/1/route1", + path: "/1/route2", + expectedResult: false, + }, + { + title: "matches long paths", + pathDefinition: "/1/a/b/route1", + path: "/1/a/b/route1", + expectedResult: true, + }, + { + title: "matches paths terminated by argument", + pathDefinition: "/1/route1/{id}", + path: "/1/route1/test_id", + expectedResult: true, + }, + { + title: "does not matche paths when argument incorrect syntax", + pathDefinition: "/1/route1/:id", + path: "/1/route1/test_id", + expectedResult: false, + }, + { + title: "matches paths containing an argument", + pathDefinition: "/1/a/{id}/route1", + path: "/1/a/test_id/route1", + expectedResult: true, + }, + { + title: "does not match when number of segments don't match", + pathDefinition: "/a/b/route1", + path: "/a/b/c/route1", + expectedResult: false, + }, + ]; + pathMatchTests.forEach((testSpec) => { + test(`${testSpec.title}`, async () => { + const authorizer = new PersonaAuthorizer(null, null); + expect( + authorizer.pathMatch(testSpec.pathDefinition, testSpec.path) + ).toBe(testSpec.expectedResult); + }); + }); + }); +});