adapt-auth-sdk
v1.0.20
Published
Provides all the functionality needed to easily integrate your Javascript web applications with Stanford SAML federated identity provider.
Downloads
363
Readme
Adapt Auth SDK
The AdaptAuth SDK provides all the functionality to easily integrate your Javascript web applications with our Stanford SAML federated identity provider.
Usage
The AdaptAuth SDK is intended to be used in node connect style http server middleware (e.g. express). To use it just configure your env, import the SDK client, and use the middlewares in your app.
import express from 'express';
import { auth } from 'AdaptAuth';
const app = express();
// Add AdaptAuth authorization middleware
app.use(auth.authorize());
app.get('/my-protected-endpoint', (req, res) => {
// Nothing to see here...
});
app.listen(3000);
Configuration
The easiest way to configure AdaptAuth is by setting environment variables
# adapt-sso-sp SAML service provider login url (REQUIRED)
ADAPT_AUTH_SAML_SP_URL="https://adapt-sso-uat.stanford.edu/api/sso/login"
# adapt-sso-sp SAML registry entity id (REQUIRED)
ADAPT_AUTH_SAML_ENTITY="my-saml-app-entity"
# SAML signing pem certificate (REQUIRED)
ADAPT_AUTH_SAML_CERT="PEM used for saml document signing"
# Private key used to decrypt encrypted SAML assertions (optional)
ADAPT_AUTH_SAML_DECRYPTION_KEY="private decryption key"
# Local app origin part for SAML returnTo POST back
ADAPT_AUTH_SAML_RETURN_ORIGIN="https://my-app.stanford.edu"
# Local app path part for SAML returnTo POST back
ADAPT_AUTH_SAML_RETURN_PATH="/auth/saml"
# Local app endpoint to handle SAML POST back (overrides host/path when set)
# ADAPT_AUTH_SAML_RETURN_URL="https://my-app.stanford.edu/auth/saml"
# Secret used for signing/verifying local session jwts (REQUIRED)
ADAPT_AUTH_SESSION_SECRET="some-signing-secret"
# Name for local session cookie (optional)
ADAPT_AUTH_SESSION_NAME="adapt-auth"
# expiresIn / maxAge for session tokens
ADAPT_AUTH_SESSION_EXPIRES_IN="24h"
# Local url to redirect to after logging out of session (optional) defaults to "/"
ADAPT_AUTH_SESSION_LOGOUT_URL="/login"
# Local url to redirect to after authorize middleware failure (optional) defaults to responding 401
ADAPT_AUTH_SESSION_UNAUTHORIZED_URL
You can optionally instantiate a new AdaptAuth instance and pass your own configuration values.
import { AdaptAuth } from 'AdaptAuth';
const myAuthInstance = new AdaptAuth({
saml: {
serviceProviderLoginUrl: 'https://adapt-sso.stanford.edu/api/sso/login',
entity: 'my-other-saml-entity',
returnToHost: process.env.APP_HOST,
returnToPath: '/auth/saml'
cert: 'MySamlCert',
},
session: {
name: 'my-auth-session',
secret: 'my-jwt-secret',
logoutRedirectUrl: '/login',
unauthorizedRedirectUrl: '/login?code=UNAUTHORIZED',
},
});
...
Basic Auth Flow Integration
A basic usage of this SDK would involve the following endpoints setup:
- Using
auth.initiate
to redirect users to the SAML service provider - Using
auth.authenticate
to handle the SAML document POST back from the IdP and create a local session - Using
auth.authorize
on protected endpoints/routes to verify valid local sessions - Using
auth.destroySession
to provide an additional way for a user to manually end their session
Here's an example express app:
import express from 'express';
import cookieParser from 'cookie-parser';
import { auth } from 'AdaptAuth';
import { service } from './service';
const app = express();
// Basic middlewares
app.use(express.json());
app.use(cookieParser());
// Initiate SAML SP redirect
app.get('/login', auth.initiate());
// Handle SAML document POST back. User redirected to '/dashboard' on successful authentication
app.post(
'/api/auth/callback',
authInstance.authenticate(),
(req, res, next) => {
res.redirect('/dashboard);
}
);
// Protect endpoints with local session authorization. Unauthorized users redirected to '/login' here
app.get(
'/dashboard',
auth.authorize({ redirectUrl: '/login' }),
async (req, res) => {
// Utilize SAML user properties in authorized session endpoints
const dashboardStuff = await service.getDashboardStuff(req.user.encodedSUID);
res.json({ data: dashboardStuff });
}
);
// Log users out of local session and redirect them to '/home'
app.get('/logout', auth.destroySession('/home'));
// A public homepage for completeness
app.get('/home', (req, res) => {
const homeStuff = await service.getHomeStuff();
res.json({ data: homeStuff });
})
app.listen(3000);
Required middlewares
It should be noted that these middleware expect certain other basic middlewares to be present.
Most notably, you should have express.json
and cookie-parser
middlewares
setup as there is an expectation that we will be able to access data at req.body
and req.cookies
.
Usage in Lambda functions
To use AdaptAuth middlewares in a lambda function all you need to do is create a simple express application for your handler that uses the middleware, then wrap it with serverless-http. Here's a link to a Netlify post that goes through the whole process :wink:.
Usage with Next.js API routes
If you're using Next.js api routes you can easily
integrate the AdaptAuth middlewares with the next-connect package.
It provides a simple connect interface that outputs a NextApiHandler
! Boom! :collision: done.
API
AdaptAuth.initiate()
Creates a middleware handler that simply redirects the request to the adapt-sso-sp servicer provider
with the confgiured paramters for entity and returnTo url. Note that this also handles passing along
a final_destination
if present in req.query.final_destination
to be added to the SAML RelayState.
app.get('/saml/login', auth.initiate());
AdaptAuth.initialize()
This is a simple pass-through of passports initialze middleware. It must be called prior to AdaptAuth.authenticateSaml
AdaptAuth.authenticateSaml
Simple pass-through of passport.authenticate
with confgired SamlStrategy. Required AdaptAuth.initialize
middleware to have run prior.
AdaptAuth.signToken(user: AuthUser)
Simple utility function to sign session jwts with the configured secrets and passed user as payload.
AdaptAuth.verifyToken(token: string)
Simple utility to verify and decode session jwts. Rejects on invalid token. Resolves decoded user payload.
AdaptAuth.createSession()
Simple middleware for saving the authenticated SAML user to a local jwt session. Creates an http only secure cookie
with SAML user payload as well as a basic http cookie signifying that the session exists.
NOTE: This middleware expects to find a valid SamlUser on the request object at req.user
. It will return a 401
otherwise.
AdaptAuth.destroySession(redirectUrl?: string)
Middleware that destroys local jwt session and redirects.
redirectUrl?: string
Local path to redirect to after session destroyed. Overridesconfig.logoutRedirectUrl
.
app.get('/logout', auth.destroySession('/public-homepage'));
AdaptAuth.authenticate()
This middleware is a wrapper for the entire authentication process intended to be used as the saml POST back endpoint. It handles passport initialization, SAML document verification, and local jwt session creation.
app.post('/handle/saml', auth.authenticate());
AdaptAuth.authorize(options?: AuthorizeOptions = {})
Middleware to validate incoming requests against the local jwt session.
AuthorizeOptions
options.allowUnauthorized?: boolean
- Allow unauthorized requests to go to next middleware (useful for auth optional endpoints)options.redirectUrl?: string
- URL to redirect to on unauthorized. Will overrideconfig.unauthorizedRedirectUrl
if set.
app.get(
'/user-details',
auth.authorize({ redirectUrl: '/login' }),
async (req, res) => {
const user = await getUser();
res.json(user);
}
)
AdaptAuth.getFinalDestination(req: any)
Helper function to extract possible finalDestination
url from SAML relay state on request object.
req: any
The request object to extract saml final destination from
Caveats when using on Netlify-hosted sites
If you are using https://github.com/bencao/netlify-plugin-inline-functions-env to inline your environment variables, be aware that it only replaces process.env.[variable_name] usages for files inside your functions directory.
Because of this, you should not rely on the singleton object or the defaults provided by the constructor. You'll need to initate an AdaptAuth instance inside a file in your functions directory, and pass in the full list of options. It's fine to copy-paste these from the constructor in src/AdaptAuth.ts as a starting point, as shown below:
const authInstance = new AdaptAuth({
saml: {
serviceProviderLoginUrl: process.env.ADAPT_AUTH_SAML_SP_URL || 'https://adapt-sso-uat.stanford.edu/api/sso/login',
entity: process.env.ADAPT_AUTH_SAML_ENTITY || 'adapt-sso-uat',
cert: process.env.ADAPT_AUTH_SAML_CERT,
decryptionKey: process.env.ADAPT_AUTH_SAML_DECRYPTION_KEY,
returnTo: process.env.ADAPT_AUTH_SAML_RETURN_URL,
returnToOrigin: siteUrl,
returnToPath: process.env.ADAPT_AUTH_SAML_RETURN_PATH,
},
session: {
secret: process.env.ADAPT_AUTH_SESSION_SECRET,
name: process.env.ADAPT_AUTH_SESSION_NAME || 'adapt-auth',
expiresIn: process.env.ADAPT_AUTH_SESSION_EXPIRES_IN || '12h',
loginRedirectUrl: process.env.ADAPT_AUTH_SESSION_LOGIN_URL || '/',
unauthorizedRedirectUrl: process.env.ADAPT_AUTH_SESSION_UNAUTHORIZED_URL,
},
});