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
- Authorization callback URL:
(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
awsandsamCLIs from AWS:aws(install instructions) and configuredsam(install instructions)
-
Run
aws configureand 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 installandnpm 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 startto 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 or localtunnel 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}orhttps://<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
- Authorization endpoint:
- 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
buildandbuild-dist: create packages in thedist-lambdafolder (for the lambda deployment) and thedist-webfolder (for the node web server).test: Run unit tests with Jestlint: Runeslintto check code styletest-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 beforenpm installscripts/deploy.sh: This is the deploy part ofnpm 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:
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
The wrapper can be run entirely in Docker with buildkit enabled. Make sure to copy .env.example to .env before you build and run the image. Using buildx is optional. The port mapping should correspond to the port configured in .env.
cp .env.example .env
docker [buildx] build my-image .
docker run -p 8080:8080 --env-file .env docker.io/my-imageExample using localtunnel in a separate terminal. Make sure https://some-random-subdomain.loca.lt is also set as the Cognito callback url.
lt -s some-random-subdomain -p 8080
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).
If you'd like to support the work that I have done (and will do) maintaining this project, you can consider sponsoring me on github
Although I've done most of the work on this project, I wasn't the only person who has contributed. Here is a list of everyone who has contributed to this project (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!
Generate keys
./scripts/create-key.sh