racker/passport-saml

Name: passport-saml

Owner: racker

Description: Rollover Certificate Enabled Fork of SAML 2.0 authentication with Passport

Forked from: austburn/passport-saml

Created: 2017-08-07 22:00:09.0

Updated: 2017-08-08 16:02:31.0

Pushed: 2017-04-21 19:59:40.0

Homepage:

Size: 545

Language: JavaScript

GitHub Committers

UserMost Recent Commit# Commits

Other Committers

UserEmailMost Recent Commit# Commits

README

Passport-SAML

This is a SAML 2.0 authentication provider for Passport, the Node.js authentication library.

The code was originally based on Michael Bosworth's express-saml library.

Passport-SAML has been tested to work with Onelogin, Okta, Shibboleth, SimpleSAMLphp based Identity Providers, and with Active Directory Federation Services.

Installation
$ npm install passport-saml
Usage
Configure strategy

This example utilizes the Feide OpenIdp identity provider. You need an account there to log in with this. You also need to register your site as a service provider.

The SAML identity provider will redirect you to the URL provided by the path configuration.

SamlStrategy = require('passport-saml').Strategy;
]

port.use(new SamlStrategy(

path: '/login/callback',
entryPoint: 'https://openidp.feide.no/simplesaml/saml2/idp/SSOService.php',
issuer: 'passport-saml'

nction(profile, done) {
findByEmail(profile.email, function(err, user) {
  if (err) {
    return done(err);
  }
  return done(null, user);
});

Config parameter details:

Provide the authentication callback

You need to provide a route corresponding to the path configuration parameter given to the strategy:

post('/login/callback',
ssport.authenticate('saml', { failureRedirect: '/', failureFlash: true }),
nction(req, res) {
res.redirect('/');
Authenticate requests

Use passport.authenticate(), specifying saml as the strategy:

get('/login',
ssport.authenticate('saml', { failureRedirect: '/', failureFlash: true }),
nction(req, res) {
res.redirect('/');
generateServiceProviderMetadata( decryptionCert )

As a convenience, the strategy object exposes a generateServiceProviderMetadata method which will generate a service provider metadata document suitable for supplying to an identity provider. This method will only work on strategies which are configured with a callbackUrl (since the relative path for the callback is not sufficient information to generate a complete metadata document).

The decryptionCert argument should be a certificate matching the decryptionPvk and is required if the strategy is configured with a decryptionPvk.

Security and signatures

Passport-SAML uses the HTTP Redirect Binding for its AuthnRequests (unless overridden with the authnRequestBinding parameter), and expects to receive the messages back via the HTTP POST binding.

Authentication requests sent by Passport-SAML can be signed using RSA-SHA1. To sign them you need to provide a private key in the PEM format via the privateCert configuration key. For example:

privateCert: fs.readFileSync('./cert.pem', 'utf-8')

It is a good idea to validate the incoming SAML Responses. For this, you can provide the Identity Provider's public signing certificate using the cert configuration key:

cert: 'MIICizCCAfQCCQCY8tKaMc0BMjANBgkqh ... W=='
Usage with Active Directory Federation Services

Here is a configuration that has been proven to work with ADFS:


entryPoint: 'https://ad.example.net/adfs/ls/',
issuer: 'https://your-app.example.net/login/callback',
callbackUrl: 'https://your-app.example.net/login/callback',
cert: 'MIICizCCAfQCCQCY8tKaMc0BMjANBgkqh ... W==',
authnContext: 'http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/windows',
identifierFormat: null

Please note that ADFS needs to have a trust established to your service in order for this to work.

For more detailed instructions, see this document from Tim Brody.

SAML Response Validation - NotBefore and NotOnOrAfter

If the NotBefore or the NotOnOrAfter attributes are returned in the SAML response, Passport-SAML will validate them against the current time +/- a configurable clock skew value. The default for the skew is 0s. This is to account for differences between the clock time on the client (Node server with Passport-SAML) and the server (Identity provider).

NotBefore and NotOnOrAfter can be part of either the SubjectConfirmation element, or within in the Assertion/Conditions element in the SAML response.

Subject confirmation validation

When configured (turn validateInResponseTo to true in the Passport-SAML config), the InResponseTo attribute will be validated. Validation will succeed if Passport-SAML previously generated a SAML request with an id that matches the value of InResponseTo.

Also note that InResponseTo is validated as an attribute of the top level Response element in the SAML response, as well as part of the SubjectConfirmation element.

Previous request id's generated for SAML requests will eventually expire. This is controlled with the requestIdExpirationPeriodMs option passed into the Passport-SAML config. The default is 28,800,000 ms (8 hours). Once expired, a subsequent SAML response received with an InResponseTo equal to the expired id will not validate and an error will be returned.

Cache Provider

When InResponseTo validation is turned on, Passport-SAML will store generated request ids used in SAML requests to the IdP. The implementation of how things are stored, checked to see if they exist, and eventually removed is from the Cache Provider used by Passport-SAML.

The default implementation is a simple in-memory cache provider. For multiple server/process scenarios, this will not be sufficient as the server/process that generated the request id and stored in memory could be different than the server/process handling the SAML response. The InResponseTo could fail in this case erroneously.

To support this scenario you can provide an implementation for a cache provider by providing an object with following functions:


save: function(key, value, callback) {
  // save the key with the optional value, invokes the callback with the value saves
},
get: function(key, callback) {
  // invokes 'callback' and passes the value if found, null otherwise
},
remove: function(key, callback) {
  // removes the key from the cache, invokes `callback` with the
  // key removed, null if no key is removed
}

The callback argument is a function in the style of normal Node callbacks:

tion callback(err, result)

Provide an instance of an object which has these functions passed to the cacheProvider config option when using Passport-SAML.

FAQ
What if I have multiple SAML providers that my users may be connecting to?

A single instance of passport-saml will only authenticate users against a single identity provider. If you have a use case where different logins need to be routed to different identity providers, you can create multiple instances of passport-saml, and either dispatch to them with your own routing code, or use a library like https://www.npmjs.org/package/passports.

Is there an example I can look at?

Gerard Braad has provided an example app at https://github.com/gbraad/passport-saml-example/

This work is supported by the National Institutes of Health's National Center for Advancing Translational Sciences, Grant Number U24TR002306. This work is solely the responsibility of the creators and does not necessarily represent the official views of the National Institutes of Health.