Do you want to add GitHub as an OIDC (OpenID Connect) provider to an AWS Cognito User Pool? Have you run in to trouble because GitHub only provides OAuth2.0 endpoints, and doesn't support OpenID Connect?

This project allows you to wrap your GitHub OAuth App in an OpenID Connect layer, allowing you to use it with AWS Cognito.

Here are some questions you may immediately have:

• Why does Cognito not support federation with OAuth? Because OAuth provides no standard way of requesting user identity data. (see the background section below for more details).

• Why has no one written a shim to wrap general OAuth implementations with an OpenID Connect layer? Because OAuth provides no standard way of requesting user identity data, any shim must be custom written for the particular OAuth implementation that's wrapped.

• GitHub is very popular, has someone written this specific custom wrapper before? As far as I can tell, if it has been written, it has not been open sourced. Until now!

When deployed, this project sits between Cognito and GitHub:

This allows you to use GitHub as an OpenID Identity Provider (IdP) for federation with a Cognito User Pool.

The project implements everything needed by the OIDC User Pool IdP authentication flow used by Cognito.

It implements the following endpoints from the OpenID Connect Core Spec:

• Authorization - used to start the authorisation process (spec)
• Token - used to exchange an authorisation code for an access and ID token (spec)
• UserInfo - used to exchange an access token for information about the user (spec)
• jwks - used to describe the keys used to sign ID tokens (implied by spec)

It also implements the following OpenID Connect Discovery endpoint:

• Configuration - used to discover configuration of this OpenID implementation's endpoints and capabilities. (spec)

Out of the box, you can deploy it as a CloudFormation stack, or run it as a web server with node.

An attempt to deploy with CDK is available in the following archived construct: cdk-user-pool-identity-provider-github.

This project is intended to be deployed as a series of lambda functions alongside an API Gateway. This means it's easy to use in conjunction with Cognito, and should be cheap to host and run.

You can also deploy it as a http server running as a node app. This is useful for testing, exposing it to Cognito using something like ngrok.

You will need to:

• Create a Cognito User Pool (instructions).
• Configure App Integration for your User Pool (instructions). Note down the domain name.
• Create a GitHub OAuth App (instructions, with the following settings:
  • Authorization callback URL: https://<Your Cognito Domain>/oauth2/idpresponse
  • Note down the Client ID and secret

(If you use GitHub Enterprise, you need the API & Login URL. This is usually https://<GitHub Enterprise Host>/api/v3 and https://<GitHub Enterprise Host>.)

Next you need to decide if you'd like to deploy with lambda/API Gateway (follow Step 2a), or as a node server (follow Step 2b)

• Install the aws and sam CLIs from AWS:

  • aws (install instructions) and configured
  • sam (install instructions)

• Run aws configure and set appropriate access keys etc

• Set environment variables for the OAuth App client/secret, callback url, stack name, etc:

   cp example-config.sh config.sh
   vim config.sh # Or whatever your favourite editor is
  

• Run npm install and npm run deploy

• Note down the DNS of the deployed API Gateway (available in the AWS console).

• Set environment variables for the OAuth App client/secret, callback url, and port to run the server on:

   cp example-config.sh config.sh
   vim config.sh # Or whatever your favourite editor is
  

• Source the config file:

  source config.sh

• Run npm run start to fire up an auto-refreshing development build of the server (production deployment is out of scope for this repository, but you can expose it using something like ngrok for easy development and testing with Cognito).

• Configure the OIDC integration in AWS console for Cognito (described below, but following these instructions). The following settings are required:
  • Client ID: The GitHub Client ID above
  • Authorize scope: openid read:user user:email
  • Issuer: https://<Your API Gateway DNS name>/${Stage_Name} or https://<your webserver>/ (for the node server).
  • If you have deployed the web app: Run discovery (big blue button next to Issuer).
  • If you have deployed the lambda/Gateway: For some reason, Cognito is unable to do OpenID Discovery. You will need to configure the endpoints manually. They are:
    • Authorization endpoint: https://<Your API Gateway DNS name>/${Stage_Name}/authorize
    • Token endpoint: https://<Your API Gateway DNS name>/${Stage_Name}/token
    • Userinfo endpoint: https://<Your API Gateway DNS name>/${Stage_Name}/userinfo
    • JWKS uri: https://<Your API Gateway DNS name>/${Stage_Name}/.well-known/jwks.json
• Configure the Attribute Mapping in the AWS console:

• Ensure that your new provider is enabled under Enabled Identity Providers on the App Client Settings screen under App Integration.

That's it! If you need to redeploy the lambda/API gateway solution, all you need to do is run npm run deploy again.

This shim also supports logging with Winston. By default, all logging goes to STDOUT. Beware that if you set the log level to DEBUG, then sensitive user information may be logged.

If you're using the node server, you can also use Splunk for logging. Environment variables configuring splunk are commented in example-config.sh. The Splunk HEC URL and access token are required, and you can also set the source, sourcetype & index for all logged events.

There are two important concepts for identity federation:

• Authentication: Is this user who they say they are?
• Authorisation: Is the user allowed to use a particular resource?

OAuth2.0 is an authorisation framework, used for determining whether a user is allowed to access a resource (like private user profile data). In order to do this, it's usually necessary for authentication of the user to happen before authorisation.

This means that most OAuth2.0 implementations (including GitHub) include authentication in a step of the authorisation process. For all practical purposes, most OAuth2.0 implementations (including GitHub)can be thought of as providing both authorisation and authentication.

Below is a diagram of the authentication code flow for OAuth:

(The solid lines are http requests from the browser, and then dashed lines are back-channel requests).

As you can see in the diagram, a drawback of OAuth is that it provides no standard way of finding out user data such as name, avatar picture, email address(es), etc. This is one of the problems that is solved by OpenID.

To provide a standard way of learning about users, OpenID Connect is an identity layer built on top of OAuth2.0. It extends the token endpoint from OAuth to include an ID Token alongside the access token, and provides a userinfo endpoint, where information describing the authenticated user can be accessed.

OpenID Connect describes a standard way to get user data, and is therefore a good choice for identity federation.

This project provides the OpenID shim to wrap GitHub's OAuth implementation, by combining the two diagrams:

The userinfo request is handled by joining two GitHub API requests: /user and /user/emails.

You can compare this workflow to the documented Cognito workflow here

├── scripts             # Bash scripts for deployment and key generation
├── src                 # Source code
│    ├── __mocks__      # Mock private key data for tests
│    └── connectors     # Common code for both lambda and web handlers
│         ├── lambda    # AWS lambda handlers
│         │    └── util # Helper functions for lambdas
│         └── web       # Express.js webserver (useful for local deployment)
├── docs                # Documentation images
├── config              # Configuration for tests
├── dist-web            # Dist folder for web server deployment
└-- dist-lambda         # Dist folder for lambda deployment

• build and build-dist: create packages in the dist-lambda folder (for the lambda deployment) and the dist-web folder (for the node web server).
• test: Run unit tests with Jest
• lint: Run eslint to check code style
• test-dev: Run unit tests continuously, watching the file system for changes (useful for development)
• deploy: This script builds the project, then creates and deploys the cloudformation stack with the API gateway and the endpoints as lambdas

• scripts/create-key.sh: If the private key is missing, generate a new one. This is run as a preinstall script before npm install
• scripts/deploy.sh: This is the deploy part of npm run deploy. It uploads the dist folder to S3, and then creates the cloudformation stack that contains the API gateway and lambdas

Tests are provided with Jest using chai's expect, included by a shim based on this blog post.

Pact consumer tests for the GitHub API connection are provided in src/github.pact.test.js. There is currently no provider validation performed.

The private key used to make ID tokens is stored in ./jwtRS256.key once scripts/create-key.sh is run (either manually, or as part of npm install). You may optionally replace it with your own key - if you do this, you will need to redeploy.

This is a near-complete implementation of OpenID Connect Core. However, since the focus was on enabling Cognito's authentication flow, you may run in to some missing features if you wish to use it with a different client.

Missing Connect Core Features:

• Private key rotation (spec)
• Refresh tokens (spec)
• Passing request parameters as JWTs (spec)

If you don't know what these things are, you are probably ok to use this project.

Missing non-core features:

A full OpenID implementation would also include:

• The Dynamic client registration spec
• The OpenID Connect Discovery endpoints beyond openid-configuration

Known issues

See the issue tracker for an up to date list.

This section contains pointers if you would like to extend this shim.

If you want to use a provider other than GitHub, you'll need to change the contents of userinfo in src/openid.js.

If you're using an on-site GitHub install, you will need to change the API endpoints used when the github object is initialised.

If you want to include custom claims based on other GitHub data, you can extend userinfo in src/openid.js. You may need to add extra API client calls in src/github.js

Contributions are welcome, especially for the missing features! Pull requests and issues are very welcome.

Login requests from your app go directly to Cognito, rather than this shim. This is because the shim sits only between Cognito and GitHub, not between your app and GitHub. See the Cognito app integration instructions for more details.

Yes. This implementation isn't complete, as it focusses exclusively on Cognito's requirements. However, it does follow the OpenID spec, and is complete enough to be able to use it as an OpenID connect provider. See the missing features section above for one or two caveats.

If you build anything cool, ping me @JonesTim on twitter (or open an issue if you have any problems).

BSD 3-Clause License

Thanks goes to these wonderful people (emoji key):

Timothy Jones 💻 📖 🚧 💬 🚇	Beth Skurrie 🤔	Sebastian J. 💻 🚇	Danny Douglass 💻	Livnoni 💻	Benjamin Follis 🚇	Carl Youngblood 🚇
c.p. 🚇	David Lee 🚇	Christophe Bougère 💻 📖	Mike Fogel 📖

This project follows the all-contributors specification. Contributions of any kind welcome!