Shibboleth Target Deployment Guide

Shibboleth Target Deployment Guide
Shibboleth Version 1.2
May 10, 2004

This version of the deploy guide is for Shibboleth v1.2. For documentation related to prior versions of Shibboleth, please consult the appropriate branch in the Shibboleth CVS.

The default configuration of Shibboleth is not secure and should not be used for protection of production content. The example private key bundled with the distribution is publically available, widely circulated, and well-known; also, the default federation and trust metadata is for testing purposes only. For information about securing a Shibboleth deployment, please refer to the production guide. Shibboleth should only be used to protect sensitive content when deployed carefully in conjunction with proper trust settings and policies.

The Shibboleth target implementation has been substantially redesigned for this release. Most of the configuration process has changed to accomodate more complex deployments but many of the defaults work fine for testing and simpler applications. For a list of new features, please refer to the NEWS.txt file in the doc/ folder of the distribution.

Before starting, please sign up for all applicable mailing lists. Announcements pertinent to Shibboleth deployments and developments and resources for deployment assistance can be found here.

Please send any questions, concerns, or eventual confusion to shibboleth-users@internet2.edu. This should include, but not be limited to, questions about the documentation, undocumented problems, installation or operational issues, and anything else that arises.

Shibboleth Target -- Table of Contents

Shibboleth Overview
1. Origin
2. Target
3. WAYF
4. Federations
5. Relying Parties
6. Applications
7. Sessions
Planning
Installation
Getting Running
Troubleshooting
1. Basic Testing
2. Common Problems

1. Shibboleth Overview

Shibboleth is a system designed to exchange attributes across realms for the primary purpose of authorization. It provides a secure framework for one organization to transmit attributes about a web-browsing individual across security domains to another institution. In the primary usage case, when a user attempts to access a resource at a remote domain, the user's own home security domain can send certain information about that user to the target site in a trusted exchange. These attributes can then be used by the resource to help determine whether to grant the user access to the resource. The user may have the ability to decide whether to release specific attributes to certain sites by specifying personal Attribute Release Policies (ARP's), effectively preserving privacy while still granting access based on trusted information.

When a user first tries to access a resource protected by Shibboleth, they are redirected to a service which asks the user to specify the organization from which they want to authenticate. If the user has not yet locally authenticated to a WebISO service, the user will then be redirected to their home institution's authentication system. After the user authenticates, the Shibboleth components at the local institution will generate a temporary reference to the user, known as a handle, for the individual and send this to the target site. The target site can then use the handle to ask for attributes about this individual. Based on these attributes, the target can decide whether or not to grant access to the resource. The user may then be allowed to access the requested materials.

There are several controls on privacy in Shibboleth, and mechanisms are provided to allow users to determine exactly which information about them is released. A user's actual identity isn't necessary for many access control decisions, so privacy often is needlessly compromised. Instead, the resource often utilizes other attributes such as faculty member or member of a certain class. While these are commonly determined using the identity of the user, Shibboleth provides a way to mutually refer to the same principal without revealing that principal's identity. Because the user is initially known to the target site only by a randomly generated temporary handle, if sufficient, the target site might know no more about the user than that the user is a member of the origin organization. This handle should never be used to decide whether or not to grant access, and is intended only as a temporary reference for requesting attributes.

1.a. Origin

There are four primary components to the origin side in Shibboleth: the Attribute Authority (AA), the Handle Service (HS), the directory service, and the local sign-on system (SSO). The AA and HS are provided with Shibboleth, and an open-source WebISO solution Pubcookie is also supplied; the directory is provided by the origin site. Shibboleth is able to interface with a directory exporting an LDAP interface or a SQL database containing user attributes, and is designed such that programming interfaces to other repositories should be readily implemented. Shibboleth relies on standard web server mechanisms to trigger local authentication. A .htaccess file can be easily used to trigger either the local WebISO system or the web server's own Basic Auth mechanism, which will likely utilize an enterprise authentication system, such as Kerberos.

From the origin site's point of view, the first contact will be the redirection of a user to the handle service, which will then consult the SSO system to determine whether the user has already been authenticated. If not, then the browser user will be asked to authenticate, and then sent back to the target URL with a handle bundled in an attribute assertion. Next, a request from the Shibboleth Attribute Requester (SHAR) will arrive at the AA which will include the previously mentioned handle. The AA then consults the ARP's for the directory entry corresponding to the handle, queries the directory for these attributes, and releases to the SHAR all attributes the SHAR is entitled to know about that user.

1.b. Target

There are three primary components to the target side in Shibboleth: the Shibboleth Indexical Reference Establisher (SHIRE), the Shibboleth Attribute Requester (SHAR), and the resource manager (RM). An implementation of each of these is included in the standard Shibboleth distribution. These components are intended to run on the same web server.

From the target's point of view, a browser will hit the RM with a request for a Shibboleth-protected resource. The RM then allows the SHIRE to step in, which will use the WAYF to acquire the name of a handle service to ask about the user. The handle service (HS) will then reply with a SAML authentication assertion containing a handle, which the SHIRE then hands off to the SHAR. The SHAR uses the handle and the supplied address of the corresponding attribute authority (AA) to request all attributes it is allowed to know about the handle. The SHAR performs some basic validation and analysis based on attribute acceptance policies (AAP's). These attributes are then handed off to the RM, which is responsible for using these attributes to decide whether to grant access.

1.c. Where are you from? (WAYF)

The WAYF service can be either outsourced and operated by a federation or deployed as part of the SHIRE. It is responsible for allowing a user to associate themself with an institution of their specification, then redirecting the user to the known address for the handle service of that institution.

1.d. Federations

A federation is one way to provide part of the underlying trust required for function of the Shibboleth architecture. A federation in the context of Shibboleth is a group of organizations(universities, corporations, content providers, etc.) who agree to exchange attributes using the SAML/Shibboleth protocols and abide by a common set of policies and practices. In so doing, they must implicitly or explicitly agree to a common set of guidelines. Joining a federation is not explicitly necessary for operation of Shibboleth, but it dramatically expands the number of targets and origins that can interact without defining bilateral agreements between all these parties.

A federation can be created in a variety of formats and trust models, but to support Shibboleth, it must provide a certain set of services to federation members. It needs to supply a registry to process applications to the federation and distribute membership information to the origin and target sites. This must include distribution of the PKI components necessary for trust between origins and targets. There also needs to be a set of agreements and best practices defined by the federation governing the exchange, use, and population of attributes before and after transit, and there should be a way to find information on local authentication and authorization practices for federation members.

1.e. Relying Parties

Some aspects of both origin and target configuration can vary and be expressed in terms of the "relying party". To an origin, a target is a relying party, while targets consider origins to be relying parties (it's a matter of perspective). Certificates, policies, and other aspects of an interaction are specified on the basis of the relying party, and may or may not vary between relying parties depending on the deployment's needs.

Each origin and target is assigned a URI, a unique identifier to enable control over configuration down to the level of an individual partner (a single relying party). By convention, this is termed a "providerId". More frequently, an entire federation will be viewed by an origin or target as a single relying party to simplify management. An individual origin or target with which this deployment exchanges information may sometimes be part of multiple relying parties if there are multiple trust agreements under which these transactions are performed. Care should be taken to avoid conflicting or inconsistent configuration in such cases.

1.f. Applications

Shibboleth "applications" are the primary unit of target configuration. Applications as viewed by the target implementation are not necessarily defined by the same metrics as in other contexts. An individual application represents a set of web resources that operates using the same attribute handling and trust configuration and shares a common session with the browser user. As a user navigates between resources on a server that cross an application boundary, a new session is established, though user interaction may not be required. As a consequence of the relationship between applications and sessions (which are tracked with a cookie), an application usually does not span more than one virtual host. Apart from cookie-based constraints, web resources can be aggregated into applications in arbitrary ways.

A single target deployment may support a large number of applications, but it need not register or publish information about each one with the origins it accepts information from. Instead it can communicate using a more limited set of distinct "providerId" values (often just a single one). This allows targets with a complex internal configuration to be treated as a single entity by origins for the purposes of attribute release.

1.g. Sessions

Much of the target implementation is concerned with establishing, and subsequently maintaining, sessions with the browser user on behalf of the applications at the target. A session consists of a cookie passed between the browser and web server, associated with a security context. The context contains the user's authentication information, and generally a set of attributes that make up the user's identity. Each application maintains distinct sessions with the browser by means of separate cookies. It is important to note that all such sessions are independent and distinct: any session can exist with or without any other session, and the expiration of any one session does not imply the expiration of any other session. Shibboleth also does not support any logout functionality beyond the termination of individual application sessions by deletion of respective cookies; also, there is no way for the target to cause origin-side sessions, such as a user's SSO login, to expire.

A browser user accessing a Shibboleth-protected resource may have two outcomes: standard session establishment, and lazy session establishment. The standard session establishment mechanism in which Shibboleth protects the resource in all circumstances results in the establishment of a cookie-based browser session and a set of attributes cached for that application. Shibboleth 1.2 also supports so-called lazy session establishment, in which the resource may be accessed without prior authentication. This means the application must be intelligent enough to determine whether authentication is necessary, and then construct the proper URL to initiate a browser redirect to request authentication; if the application determines none is necessary or uses other authorization mechanisms, then the request for authentication may not need to be triggered. This complex functionality is mostly useful to protect a single URL with different access mechanisms, or to require authenticated access only in instances where the application deems it necessary.

Independently of this, a web-based application protected by Shibboleth may have a need to establish its own session with the user. This session may persist well beyond the Shibboleth session, and logouts from this session, if supported, will not terminate a Shibboleth session initiated to access the resource. Application administrators should carefully evaluate the expiration of all sessions to limit vulnerability to attacks or user negligence. Logging out of the entire desktop session is usually the only (relatively) foolproof logout mechanism on the web.

2. Planning

There are several essential elements that must be present in the environment to ensure Shibboleth functions well, both political and technical. Shibboleth currently runs on a specific range of platforms and web server environments. The SHAR and SHIRE are implemented entirely in C/C++. These are the recommendations and requirements for a successful implementation of a Shibboleth target.

2.a. Requirements

Shibboleth currently supports Windows NT/2000/XP/2003, Linux, and Solaris. At present, Shibboleth consists of Apache (or IIS) plugins and a separate SHAR process. The plugins use the Sun/ONC RPC mechanism to communicate with the SHAR over Unix domain or TCP sockets. The target's web servers must be running Apache 1.3+, 2.0+, or Microsoft IIS 4.0+ More precise technical details are discussed in 3.a.

2.b. Join a Federation

While it is not necessary for a target or origin to join a federation, doing so greatly facilitates the implementation of multilateral trust relationships. Each federation will have a different application process.

For more information on federations, refer to 1.d or the Shibboleth v1.0 architectural document.

For testing in a private environment, Shibboleth comes with a default configuration that demonstrates how to implement a local peered agreement and supports testing both origin and target on the same box using localhost URLs. The sample key and certificate is for ease of testing only, and should always be replaced for real world use.

2.c. Security Considerations

Shibboleth's protocols and software have been extensively engineered to provide protection against many attacks. However, the most secure protocol can be compromised if it is placed in an insecure environment. To ensure Shibboleth is as secure as possible, there are several recommended security precautions which should be in place at local sites.

SSL use is optional for target sites, but should be used if at all possible, at least in the processing of incoming sessions (called the SHIRE URL or assertion consumer service). Federation guidelines should be considered when determining whether to implement SSL, and, in general, SSL should be used for interactions with client machines to provide the necessary authentication and encryption to ensure protection from man-in-the-middle attacks. It is strongly suggested that all password traffic or similarly sensitive data should be SSL-protected. Assessment of the risk tradeoff against possible performance degradation should be performed for all applications.

Many other attacks can be made on the several redirection steps that Shibboleth takes to complete attribute transfer. The best protection against this is safeguarding the WAYF service and ensuring that rogue targets and origins are not used, generally by development of the trust model underneath Shibboleth. Shibboleth also leverages DNS for security, which is not uncommon, but attacks concerning domain name lookups should be considered.

Information regarding origin users is generally provided by the authoritative enterprise directory, and the acceptance of requests from target applications can be carefully restricted to ensure that all requests the SHAR performs are authorized and all information the origin provides is accurate. Proper security measures should also be in place on directory access and population(see Access Control in the LDAP recipe for more information). Use of plaintext passwords is strongly advised against.

Server platforms should be properly secured, commensurate with the level that would be expected for an organization's other security services, and cookie stores on client machines should be well protected.

2.d. Server Certs

In the Shibboleth architecture, the origin and target software must all have various client and/or server certificates for use in signing assertions and creating SSL connections These should be issued by a commonly accepted CA, which may be stipulated by your federation. After understanding the CA's acceptible to your federations, consult chapter 4.c for information on certificate and key generation.

2.e. Attribute Release Policies

The Attribute Authority maintains a set of policies called Attribute Release Policies (or ARP's) that govern the sharing of user attributes with Shibboleth target sites. When a user attempts to access a Shibboleth-protected resource, that resource's SHAR queries the user's AA for all attributes to which it is entitled. The SHAR provides its own name and the URI of the requesting application. The AA finds the attributes associated with the browser user, determines an "Effective ARP" for this user, and then sends to the SHAR only the attribute-value pairs allowed in this policy.

An ARP may be thought of as a sort of filter for outbound attributes; it cannot create attributes or data that aren't originally present, but it can limit the attributes released and the values those attributes may have when released. It does not change the information in the data sources in any way.

Each ARP is comprised of one or more rules that specify which attributes and values may be released to a given application and that SHAR. The assignment of rules to various targets is quite flexible and includes mechanisms for specifying: that a rule should affect all targets (default rule), exact SHAR names for which a rule is applicable, regular expressions against which SHAR names should be matched to determine if a rule is applicable, and individual applications that may span hosts and URL's as necessary.

For each request, an Effective ARP is determined by locating all ARP's applicable to the designated user and extracting each rule that matches the querying SHAR and resource. Attributes and values that are specified for release are included in the effective ARP, while those specified for denial are blocked from release. See section 5.b.i for details on how ARP's are processed.

Various ARP's may be combined in forming the Effective ARP. For instance, the Site ARP is administratively maintained and applies to all users for which the AA is answerable. User ARP's apply to a specific user only, and can be maintained either administratively or by the users themselves. All ARP's are specified using the same syntax and semantics.

2.f. Attribute Acceptance Policies

When a target receives a set of attributes, it must evaluate them in the context of the Attribute Authority that is providing them, to assess their "reasonableness". For example, if the value of an attribute is expected to be from a small set of enumerated choices, the value should be compared against that list. If a particular attribute or value is only trusted when asserted by specific origins, that too should be checked.

Targets are configured to accept specific attributes that they understand and care about, and are also configured with the rules to apply before accepting the attributes for use by the RM or an application. Attributes and values that don't meet the target's requirements are filtered out. The set of configuration rules to make these decisions is called an Attribute Acceptance Policy (AAP).

2.g. Browser Requirements

A primary Shibboleth design consideration was to require very little or no modification to client machines. The only requirement is that a browser is used which supports cookies, redirection and SSL. Browser users will have to perform an additional click to submit the authentication assertion if JavaScript is not functional.

2.h. Clocks

NTP should be run on all web servers. Shibboleth employs a short assertion acceptance window to protect against replay attacks. Because of this, any significant degree of clock skew can hinder the ability of users to access sites successfully.

2.i. Other Considerations

Especially for higher education, there are a handful of laws enacted which may have important ramifications on the disclosure of personal information and attributes. Since Shibboleth does not necessarily need to transmit identity, it is an ideal solution for many higher education situations. Nevertheless, all parties within the United States of America are strongly advised to consult the Family Educational Rights and Privacy Act of 1974(FERPA), and all other relevant state and federal legislation before deploying Shibboleth.

3. Installation

3.a. Software Requirements

The Shibboleth project makes binary packages available only for Windows, that are precompiled against recent releases of various required libraries such as OpenSSL. Binaries for other platforms may be available on a limited or ad hoc basis. It is highly advisable to build from source when using Shibboleth in a production environment in order to permit patching or updating of packages as security holes and bugs are fixed. Building from source is necessary to give you complete control over your deployment platform. The binary packages represent a snapshot in time only. To build from source, see the INSTALL.txt files in the doc folder of the OpenSAML and Shibboleth source distributions.

The software requirements listed correspond to the binary distribution. In general, source builds should work against all recent versions of the operating systems and software dependencies listed below. For specific questions, inquire to the support mailing list, or give it a try. Note that OpenSSL releases frequent security updates; the version listed may not be the most current, but most minor "letter" updates should be usable.

General Requirements and Notes:

Apache 1.3.x

Apache 1.3.x must be compiled with mod_so for DSO module support, and should include SSL support (preferably using mod_ssl), and EAPI support (which mod_ssl requires and provides).

Portions of the libphp4 Apache module are written in C++, as is Shibboleth. There is a known conflict on Unix platforms between the PHP extensions libpspell.so and libsablot.so which will manifest itself as segmentation faults when starting Apache. If a site wants to use libphp4.so and Shibboleth at the same time, then one of the following may be done:

Remove the options --with-pspell and --with-xslt-sablot from PHP's configuration.

Rebuild these two modules using the same version of GCC that was used to compile Shibboleth.

Apache 2.0.x

Apache 2.0.x must be compiled with mod_so for DSO module support, and should include SSL support which is available but not included by default. See also the note about PHP above.

IIS 4.0+

When installing under Windows 2003, if the server is not in a domain before installing IIS 6, there may be issues surrounding permissions on directories because of new restrictions on IIS extensions accessing files.

OpenSSL

Verions 0.9.6 and 0.9.7 are both supported, but 0.9.7 should be used if possible, as support for 0.9.6 may be dropped in a future release. Support for threads and shared libraries must be included during configuration using the threads and shared options.

Most other required libraries are either easy to update or not found on typical systems. See the INSTALL.txt files in the OpenSAML and Shibboleth source distributions for specific requirements of a given release. The important requirements are for pthreads support and shared libraries on Unix platforms. Without both, building will be hard and stability unlikely.

Operating System Specific Notes:

Windows NT/2000/XP/2003

Any Apache modules used, and Apache itself, must be compiled with the Microsoft DLL-based runtime, selected by compiling with the /MD switch. The binary distribution was built against Apache versions 1.3.29 (with EAPI patches from mod_ssl 2.8.16) and 2.0.48. Forward compatibility is likely, but errors will result if an Apache implementation such as IBM's IHS product or any other non-EAPI version of 1.3 is used. In such cases, you must build the Shibboleth Apache modules from source.

The installer will prompt for an install path, change default configuration files as appropriate for Windows, and set various environment variables for you. A default SHAR service can also be installed, or you can install it manually using the instructions in this guide.

Note that debug/symbol versions of the libraries and software are included, and may be used by appending "debug" to the Shibboleth library path and using the corresponding modules and binaries. If you do so, be aware that Apache and other modules must also be compiled with Microsoft's debug runtime (via the /MDd compiler option). In most cases, you can safely ignore or even delete the debug versions.

RedHat Linux 7.2,7.3:

The most recent Red Hat RPM for Apache (1.3.27-2 as of this writing) is sufficient for use with Shibboleth. You can use the older version of OpenSSL included with the OS, for this release, but be advised this may change in the future.

The version of GCC that comes with this system is too old to build Shibboleth. Special update RPMs are available for GCC 3.04 that will work provided you configure packages with CC and CXX set to gcc3 and g++3 respectively. Newer GCC versions also work but may require a glibc upgrade and necessitate a lot of unrelated package updates.

RedHat Linux 9 / Fedora

Apache 2.0 is included as the default Apache version in this release.

RedHat Enterprise Linux

Apache 2.0 is included as the default Apache version in this release.

Debian Linux

Shibboleth requires that Apache and Apache-SSL be built with libpthread, or loading the mod_shib_13 or mod_shib_20 modules will cause Apache to fail. While RedHat's Apache is compatible, Debian's Apache must be rebuilt with libpthread:

$ export LDFLAGS=-lpthread
$ apt-build --rebuild --reinstall install \
apache-common apache apache-ssl

Solaris 2.6+:

The shared library version of OpenSSL is required by Shibboleth. The static libraries may be installed as well if necessary for other applications, but cannot be linked into mod_ssl or any other Apache modules. If mod_ssl's libssl.so module is linked against the static version, bus errors will result.

To check how mod_ssl was built, run the ldd command against libssl.so in the Apache libexec/ folder and check the output for references to libssl.so.0.9.7. If you see an earlier version mentioned, or no mention of it at all, then OpenSSL 0.9.7 must be built with shared libraries from source, and the Apache module rebuilt with it.

openssl-0.9.7d, the latest security fix release, has been tested, but any 0.9.7 version should work.

Solaris does not come with GCC 3, but various versions can be obtained from http://www.sunfreeware.com. If building your own, GCC must be configured to use Sun's linker. Note that you should use a consistent version of GCC across any other C++ libraries in use within Apache, but other C++ code on your server can freely use a different version as long as the necessary libstdc++.so for a given version is available

Use of GCC is recommended, but new releases of Sun's Forte compiler have been used successfully with some tinkering with configuration scripts.

3.b. Deploy the Shibboleth Package

For the sake of clarity, this deployment guide assumes that standard directories are used for all installations. These directories may be changed for local implementations, but must be done so consistently.

On Unix, the build documentation suggests building into /opt/shibboleth. If you use a different layout or location, most of the essential configuration files will be tweaked for you, but watch for any exceptions.

On Windows, use of the installer is recommended. Visual Studio 6.0 project files are included with the OpenSAML and Shibboleth source distributions for source builds if maximum flexibility to deal with security issues or Apache variants is desired.

3.c. Configure Apache

Shibboleth includes configuration directives in the files /opt/shibboleth/etc/shibboleth/apache.config and /opt/shibboleth/etc/shibboleth/apache2.config which must be added to the httpd.conf file used locally. It is recommended that these directives simply be added to the end of the existing httpd.conf file rather than trying to merge it in-line; step 2 describes the necessary modifications to the Apache startup script. The default configuration will often work, but if customization is necessary, these options may be modified:

LoadModule <module> <pathname>

Specifies the name and location of the module, installed by default at /opt/shibboleth/libexec/mod_shib_13.so or /opt/shibboleth/libexec/mod_shib_20.so

ShibConfig <pathname>

Specifies the pathname of the Shibboleth configuration file. Defaults to /opt/shibboleth/etc/shibboleth/shibboleth.xml.

ShibSchemaDir <path>

Specifies the path of the Shibboleth schema folder. Defaults to /opt/shibboleth/etc/shibboleth.

<Location url>
SetHandler <method>
</Location>

(Apache 1.3 only) Specifies the relative path and the handler the target uses to process incoming sessions and lazy session startup for Shibboleth-protected resources. This works in concert with the shireURL settings in the XML configuration file. Any virtual locations that are to be used for this purpose should be defined to Apache here.

Another option for some sites is to configure Shibboleth globally in "lazy" session mode for all content. This allows the module to detect session requests and pass them to the handler without the need to configure the handler itself.

If the OpenSSL libraries are not in the system's search path, they should be added to the LD_LIBRARY_PATH used by Apache. You will also usually need to add /opt/shibboleth/lib to LD_LIBRARY_PATH as well.

The SHAR must be started along with Apache. Among other methods on Unix, this can be done either by creating a separate SHAR startup script or by modifying Apache's RC script to start/stop the SHAR before httpd. It is suggested that Apache's script be modified by adding:

/opt/shibboleth/bin/shar -f &

In most cases, the build process insures that the SHAR can locate the configuration file and schemas, but the SHIBCONFIG and SHIBSCHEMAS environment variables may be used as well. Command line options can also be used to specify them.

On Windows, the SHAR is a service and is managed separately.

By default, the Shibboleth modules are configured to log information on behalf of Apache to the file /opt/shibboleth/var/log/shibboleth/shire.log, though this can be changed by modifying the .logger files pointed to by configuration elements. For this log to be created, Apache must have permission to write to this file, which may require that the file be manually created and permissions assigned to whatever user Apache is configured to run under. If the file does not appear when Apache runs with the modules loaded, check for permission problems.

The options in shibboleth.xml must be configured as documented in 4.a. Apache content may then need to be modified for Shibboleth authentication. This is discussed in 4.d. It is recommended that the target then be tested as detailed in section 5.a.

3.d. Configure Microsoft IIS

The package includes an ISAPI filter and bundled extension for session startup in a single library, libexec\isapi_shib.dll. This filter is configured using commands in C:\opt\shibboleth\etc\shibboleth\shibboleth.xml (or wherever you've installed the software). Make sure you or the installer has added the lib directory to the path as directed in section 3.b. You will generally need to restart the system after installation.
Installing the extension into IIS is a two step process:

First, add the filter using the Internet Services Manager MMC console. Right click on the machine icon on the left, and edit the WWW Service master properties. On the "ISAPI Filters" tab, add a new filter called Shibboleth and specify the DLL named above. The priority should be High, and once the filter is loaded, make sure it appears in the list below the "sspifilt" entry. Restart IIS and make sure the filter shows up with a green arrow. Check the Windows event log if it fails to load.

Secondly, map a special, distinct file extension, such as .shire, to the ISAPI library so that virtual URLs can be specified to invoke the extension handler for each web site. Right click on the machine icon on the left, and edit the WWW Service master properties. On the "Home Directory" tab, add a script mapping using the "Configuration" button. The "Executable" box should point to isapi_shib.dll, and the "Extension" can be set to anything unlikely to conflict, but .shire is assumed (and the dot must be included). You should NOT select the option to limit verbs, and you MUST uncheck the "Check that file exists" box. On newer versions of IIS, checking the "Script Engine" box is suggested, as it will permit the extension to handle requests in directories with only script permissions assigned.

(IIS 6 Only) A new Web Service Extension must be defined for Shibboleth; without this, the mapping from *.shire to isapi_shib.dll won't occur and a file error will appear Add this extension with an arbitrary name and associate it with isapi_shib.dll.

All other aspects of configuration are handled via the shibboleth.xml file and associated XML files described in subsequent sections. Particular use is made of the /SHIRE/Implementation/ISAPI element that allows IIS sites to be mapped to scheme, hostname, and port for proper request mapping and generation of redirects.

Instance IDs are used in the IIS metabase to identify web sites. In older versions, they are applied starting with 1(one) and number the web sites in order in the Internet Services Manager from top to bottom. Newer versions appear to assign some IID values with strange ASCII formulas applied to the site name. A simple ASP or CGI script can be run within a site to dump the INSTANCE_ID header.

See the following section for information on running the SHAR service on Windows.

The options in shibboleth.xml must be configured as documented in 4.a. It is recommended that the target then be tested as detailed in section 5.a.

3.e. Running the SHAR on Windows

The SHAR is a console application that is primarily designed to be installed as a Windows service. To run the process in console mode for testing or to diagnose major problems, the -console parameter is used. Otherwise, parameters are used to install (or remove) the SHAR from the service database and subsequent control is via the Service Control Manager applet. The following command line parameters can be used:

-console

Allows the process to be started from a command prompt. Since the console will exit if the desktop user logs out, this is not suitable for production use, but may be useful for testing.

-check

Validates the general correctness of the configuration. Not all problems can be detected this way, but the chance of successful startup is high if the checking process does not log any errors.

-config <pathname>

Specifies the pathname of the SHAR's configuration file. Defaults to \opt\shibboleth\etc\shibboleth\shibboleth.xml or the value of the SHIBCONFIG environment variable, if it is set.

-schemadir <path>

Specifies the path to the XML schema files. Defaults to \opt\shibboleth\etc\shibboleth or the value of the SHIBSCHEMAS environment variable, if it is set.

-install <servicename>

Installs the SHAR as a named service in the Windows service database. A name should be provided if multiple instances of the SHAR need to be run on different ports, and thus installed separately. The -config option can be provided to include a specific configuration file on the service's command line.

-remove <servicename>

Removes the named service instance of the SHAR from the Windows service database.

4. Getting Running

4.a. Configuring shibboleth.xml

The configuration for the target is mostly contained within shibboleth.xml, located by default at \opt\shibboleth\etc\shibboleth\shibboleth.xml. The target comes pre-configured with certificates and settings that will work against a test origin running on the same server; however, there are several values that must later be changed to interoperate with other sites securely and effectively.

The following is a hyperlinked version of a basic configuration file, followed by a list of elements and attributes that must be modified. The actual example shipped with Shibboleth includes many more options that are commented out and other elements necessary to support test functionality. Click on any attribute or element for more information on its population and definition.
<ShibbolethTargetConfig	xmlns="urn:mace:shibboleth:target:config:1.0"
    logger="/opt/shibboleth/etc/shibboleth/shibboleth.logger" clockSkew="180">

    <Extensions>
        <Library path="/opt/shibboleth/libexec/xmlproviders.so" fatal="true"/>
    </Extensions>

    <SHAR logger="/opt/shibboleth/etc/shibboleth/shar.logger">

        <Extensions>
            <Library path="/opt/shibboleth/libexec/shib-mysql-ccache.so" fatal="false"/>
        </Extensions>

        <UnixListener address="/tmp/shar-socket"/>

        

        
        
        <MySQLSessionCache cleanupInterval="300" cacheTimeout="3600" AATimeout="30" AAConnectTimeout="15"
                defaultLifetime="1800" retryInterval="300" strictValidity="true" propagateErrors="true"
                mysqlTimeout="14400">
            <Argument>--language=/opt/shibboleth/share/english</Argument>
            <Argument>datadir=/opt/shibboleth/data</Argument>
        </MySQLSessionCache>

    </SHAR>

    <SHIRE logger="/opt/shibboleth/etc/shibboleth/shire.logger">

        <RequestMapProvider type="edu.internet2.middleware.shibboleth.target.provider.XMLRequestMap">
            <RequestMap applicationId="default">
                <Host name="localhost" scheme="https">
                    <Path name="secure" requireSession="true" exportAssertion="true">
                            
                            <Path name="admin" applicationId="foo-admin"/>
                       </Path>
                </Host>
                <Host name="localhost" scheme="http">
                    <Path name="secure" requireSession="true" exportAssertion="true"/>
                </Host>
            </RequestMap>
        </RequestMapProvider>

        
    </SHIRE>

    <Applications xmlns:saml="urn:oasis:names:tc:SAML:1.0:assertion"
        applicationId="default" providerId="https://example.org/shibboleth/target"
        signRequest="false" signedResponse="false" signedAssertions="false">

        <Sessions lifetime="7200" timeout="3600" checkAddress="true"
            shireURL="/Shibboleth.shire" shireSSL="false" cookieName="_shibsession_default" cookieProps="; path=/"
            wayfURL="https://wayf.internet2.edu/InQueue/WAYF">

        <Errors shire="/opt/shibboleth/etc/shibboleth/shireError.html"
            rm="/opt/shibboleth/etc/shibboleth/rmError.html"
            access="/opt/shibboleth/etc/shibboleth/accessError.html"
            supportContact="root@localhost"
            logoLocation="/shibtarget/logo.jpg"
            styleSheet="/shibtarget/main.css"/>

        <CredentialUse TLS="defcreds" Signing="defcreds">
            <RelyingParty Name="urn:mace:inqueue" TLS="inqueuecreds" Signing="inqueuecreds"/>
        </CredentialUse>

        

        <AAPProvider type="edu.internet2.middleware.shibboleth.target.provider.XMLAAP"
            uri="/opt/shibboleth/etc/shibboleth/AAP.xml"/>

        <FederationProvider type="edu.internet2.middleware.shibboleth.common.provider.XMLMetadata"
            uri="/opt/shibboleth/etc/shibboleth/sites.xml"/>

        <TrustProvider type="edu.internet2.middleware.shibboleth.common.provider.XMLTrust"
            uri="/opt/shibboleth/etc/shibboleth/trust.xml"/>

        

        <saml:Audience>urn:mace:inqueue</saml:Audience>

        

    </Applications>

    <CredentialsProvider type="edu.internet2.middleware.shibboleth.common.Credentials">
        <Credentials xmlns="urn:mace:shibboleth:credentials:1.0">
            <FileResolver Id="defcreds">
                <Key format="PEM" password="secret">
                    <Path>/opt/shibboleth/etc/shibboleth/shar.key</Path>
                </Key>
                <Certificate format="PEM">
                    <Path>/opt/shibboleth/etc/shibboleth/shar.crt</Path>
                    <CAPath>/opt/shibboleth/etc/shibboleth/ca.crt</CAPath>
                </Certificate>
            </FileResolver>
        </Credentials>
    </CredentialsProvider>

</ShibbolethTargetConfig>
The following changes must be made to the default configuration before the target will interoperate in a federation.

The main Applications element's providerId attribute must be changed to reflect the URI this target will use to identify itself to origins by default. This will often be approved or supplied by a federation.

The supportContact and error templates for the target found in the Errors element should be changed to ensure that users have a proper support mechanism.

Proper credentials for this target signed by an authority that the federation recognizes must be referenced by the Credentials element. The default configuration points at files containing widely-available, insecure keys and certificates. Note that keys are supported in a variety of formats: DER, PEM, encrypted PEM, PKCS8, and encrypted PKCS8.

FederationProvider and TrustProvider elements must be added or changed as needed to reflect the arrangements required. This information is often provided by federations to their members.

For Apache (but not IIS), there is also information that must be configured in /usr/local/apache/conf/httpd.conf (or equivalent); for more information, refer to 3.c.

Information in the logging configuration files referenced by shibboleth.xml may require additional changes to meet local needs. The logging level can be raised to DEBUG if extremely detailed information is needed for testing. It is recommended that after initial installation is completed, the log level in both files be left at either INFO or WARN.

All elements are optional unless otherwise specified. All attributes of an element are optional unless designated mandatory by a purple background.

<AAPProvider type="edu.internet2.middleware.shibboleth.target.provider.XMLAAP" uri="pathname"/>

This element is used to specify individual attribute acceptance policies that will apply to an application and may appear zero or more times within the Applications or Application element. For information about these policies and their format, refer to section 4.e.

The default set of AAP providers in the Applications element can be replaced within individual Application elements.

<Application id="identifier" providerId="identifier" signRequest="true/false" signedResponse="true/false" signedAssertions="true/false">

Individual applications that require different attributes, session settings, metadata, etc. can be differentiated from the default configuration as specified in the Applications element. It must contain a Sessions element, but overriding other elements is optional.

id: This attribute defines an internal identifier allowing individual applicationId attributes as part of Host and Path elements to point to this Application to handle requests.

providerId: Distinct from the internal identifier, this is the unique identifier that will be used when communicating with origin sites to request authentication or attributes. This value is referenced by origins when creating rules for the release of attributes to targets and will often be provided to federations to facilitate origin configuration. If none is specified, the default Applications element's providerId applies.

signRequest: If true, the target will sign attribute requests that it sends to origins on behalf of this application. This is usually unnecessary, as the TLS/SSL transport can provide authentication more efficiently.

signedResponse: If true, the target will require that all SAML attribute responses it receives for this application be signed.

signedAssertions: If true, the target will require that individual SAML assertions it receives for this application be signed. This may be particularly useful if the application is forwarding the assertion, but requires a liberal (or no) AAP to avoid corrupting the signature.

<Applications id="default" providerId="identifier" signRequest="true/false" signedResponse="true/false" signedAssertions="true/false">

The Applications element must appear once and contains default settings for requests handled by the target. It must contain at least one each of the Sessions, and Errors elements, and may contain CredentialUse, saml:AttributeDesignator, saml:Audience, FederationProvider, TrustProvider, RevocationProvider, and Application elements.

id: This attribute has a fixed value of "default" and should not be changed.

providerId: Distinct from the internal identifier, the providerId is the unique identifier that will be used when communicating with origin sites to request authentication or attributes. This value is referenced by origins when creating rules for the release of attributes to targets and will often be provided to federations to facilitate origin configuration.

signRequest: If true, the target will sign attribute requests that it sends to origins by default. This is usually unnecessary, as the TLS/SSL transport can provide authentication more efficiently.

signedResponse: If true, the target will require that all SAML attribute responses it receives are signed by default.

signedAssertions: If true, the target will require that individual SAML assertions it receives are signed by default. This may be particularly useful if the application is forwarding the assertion, but requires a liberal (or no) AAP to avoid corrupting the signature.

Default settings can be overridden by using the RequestMap to assign a non-default applicationId to particular content in Host and Path elements. An Application element is then inserted containing a matching id attribute, and finally specific elements that override the defaults are placed within it. A fully specified Sessions element is always required for any new application created, because each application needs a distinct shireURL so that new sessions can be unambiguously mapped to a particular application.

<Argument>value</Argument>

The Argument element is used in the MySQLSessionCache element to specify one or more arguments to pass to the MySQL database engine.

<saml:AttributeDesignator AttributeName="name" AttributeNamespace="namespace">

The AttributeDesignator element is used in the Applications and Application elements to name an attribute to specifically request from origins on behalf of an application. If none are specified, the application will be given anything the origin allows it to receive.

AttributeName: Specifies the name of a SAML attribute, generally a URI.

AttributeNamespace: Specifies the attribute's SAML namespace, which Shibboleth by convention sets to "urn:mace:shibboleth:1.0:attributeNamespace:uri".

The default set of designators can be overridden within individual Application elements, but if default elements are specified, it isn't possible to "remove" them and revert to none within a particular application.

<saml:Audience>value</saml:Audience>

The Audience element is used in the Applications and Application elements element to specify one or more SAML audience URIs to designate while processing assertions. Audience values are used by origins to constrain the parties they issue assertions for. A target application always includes its own providerId as an audience value.

Within an Application element, this setting is not inherited from the Applications element. Any values desired must be specified. In most cases, this element can be omitted.

<CAPath>pathname</CAPath>

Paired with a Path element within a FileResolver element, it allows for the specification of additional certificates in a chain up to a trust anchor. As many CAPath elements as necessary to complete the chain may be specified. May be needed if the relying party does not possess the entire CA chain already.

<Certificate format="type">

This specifies the certificate corresponding to this set of credentials. The certificate itself must be specified by a Path element contained by this element. If the certificate isn't self-signed or signed by an authority familiar to the relying party, the files of certificates in the path to the root authority may be specified using one or more CAPath elements. Valid formats are PEM, DER, and PKCS12.

It's placed within the FileResolver element and must be paired with the corresponding private key using the Key element.

<Credentials xmlns="urn:mace:shibboleth:credentials:1.0">

This element is the container for credentials used by the XML-based credentials provider with type "edu.internet2.middleware.shibboleth.common.Credentials". These credentials are used by the target to authenticate itself in SSL sessions or sign attribute requests, depending on application configuration. It must contain one or more FileResolver elements.

<CredentialsProvider type="edu.internet2.middleware.shibboleth.common.Credentials">

This element is the container for providers of credentials used by the target and is placed inside the ShibbolethTargetConfig element. The supplied provider of type "edu.internet2.middleware.shibboleth.common.Credentials" must contain one Credentials element detailing the credentials to be used by the target. Other provider types might require different content.

<CredentialUse TLS="string" Signing="string">

Used in the Applications or Application elements to specify the credentials used by applications for signing and TLS/SSL. The TLS and Signing attribute values reference the identifiers of credential resolvers defined in the CredentialsProvider element. May also contain RelyingParty elements that specify the credentials to use for specific origins or federations.

<Errors shire="pathname" rm="pathname" access="pathname" supportContact="e-mail" logoLocation="URL"/>

Shibboleth is capable of displaying customized error pages based on templates and information provided by additional attributes in this element. These should all be customized to fit the requirements of the target application. For more information on configuration of error page generation, please see section 4.b.

shire: Specifies the location of the template for the error page generated when there is an error re-directing the user to the WAYF or processing a new session sign-on.

rm: Specifies the location of the template for the error page generated if internal errors occur when supplying attributes to the application.

accessError: Specifies the location of the template for the page displayed to users when access to a protected resource is denied based on access control. This is distinct from when errors occur during the evaluation process itself, and indicates a denial of authorization.

supportContact: Specifies a support e-mail address for the user to contact.

logoLocation: Specifies the location of the logo used in the generation of error pages. This logo can be in any format that the web browser will understand, and should be a URL (absolute or relative) that will return a valid logo.

The last two attributes are examples of tags that can be inserted at runtime into the templates. Arbitrary attributes may be specified in this element simply by adding them; no additional configuration is necessary. If there is a matching ShibMLP tag in the error page template as designed in 4.b, Shibboleth will insert the value of that attribute.

<Extensions>

Extension libraries for one of the Shibboleth components or the entire target can be specified using this element depending on where it's present. It may be contained by any of the SHAR, SHIRE, or ShibbolethTargetConfig elements. It must contain one or more Library elements.

<FederationProvider type="edu.internet2.middleware.shibboleth.common.provider.XMLMetadata" uri="pathname">

This element, when specified within an Applications or Application element, points to operational metadata either inline within the element or in a local XML file. Federations will often publish signed XML files for targets to download periodically. This should be refreshed regularly; see section 4.g for further details.

The default set of federation providers in the Applications element can be replaced within individual Application elements.

<FileResolver Id="string">

This element defines files used to store a private key, certificate, and certificate authorities and associates the set with an identifier. Placed inside the Credentials element. CredentialUse and RelyingParty elements will refer to these identifiers in their TLS and Signing attributes, allowing different credentials to be used for different applications and relying parties.

Must contain one Key element and should contain one Certificate element.

<Host scheme="protocol" name="fqdn" port="integer" applicationId="id" requireSession="true/false" exportAssertion="true/false">

Individual (real or virtual) hosts that this target protects are enumerated by Host elements inside the RequestMap element. If a request is processed by Shibboleth for a URL on this host, these parameters will be applied to it. If there are Path elements within this element that match the URL and contain the applicationId, requireSession, or exportAssertion attributes, they will override values in this element; similarly, values within this element will override those in the containing RequestMap element.

scheme: This specifies the protocol on which this host responds. Valid choices are http, https, ftp, ldap, and ldaps.

name: This is the fully-qualified domain name of the host. This appended to the scheme must match what is contained in the URL for the element's settings to apply to the request.

port: This is the port the host is listening on, if not the standard port for the scheme.

requireSession: This attribute controls whether Shibboleth will forcibly establish an authenticated session with the user before handing off the request to the web server or application. If true, Shibboleth will force session establishment. If false (the default), applications are responsible for ensuring that a session exists if necessary, so-called lazy session establishment. Most deployments should not specify false for protected content without a full understanding of the implications.

exportAssertion: When true, the entire SAML attribute assertion received from the origin is exported to a CGI request header called Shib-Attributes, encoded in base64. This requires an application to be able to parse the raw XML. Defaults to false, which most deployments should use.

<Implementation>

A container element placed inside the SHIRE element, the contents of this element will vary depending on the web server or environment that this Shibboleth deployment serves. Multiple configurations may be specified, but only one per implementation type. This element may contain the ISAPI element.

<ISAPI normalizeRequest="true/false">

The configuration information for Shibboleth targets deployed on Microsoft IIS is stored inside this container element. This element must contain one or more Site elements, each of which maps an INSTANCE ID value to a hostname. If normalizeRequest is true (the default), all redirects and computed request URLs generated by Shibboleth will be created using the hostname assigned to the site instance handling the request. If false, the browser's supplied URL is sometimes used to compute the information. Placed inside the Implementation element.

<Key format="type">

Specifies a file containing a private key to be used within a set of credentials. Valid formats are PEM (the default), DER, and PKCS12. Placed within a FileResolver element, it should be paired with a Certificate element, and contain a Path element.

<Library path="pathname" fatal="true/false"/>

This element defines an extension library for one of Shibboleth's components and is placed within an Extensions element.

path: This designates the complete pathname of the library.

fatal: If true and the library is not located or fails to load properly, the target will not successfully initialize. The default is false.

<Listener type="string">

Specifies a pluggable implementation of a mechanism for communication between the web server and SHAR, specified in the type attribute. This element is placed within the SHAR element and is mutually exclusive with the TCPListener and UnixListener elements.

<MemorySessionCache AAConnectTimeout="seconds" AATimeout="seconds" cacheTimeout="seconds" cleanupInterval="seconds" defaultLifetime="seconds" propagateErrors="true/false" retryInterval="seconds" strictValidity="true/false"/>

Shibboleth will cache sessions and received attributes in memory if this element is found in the SHAR element. This element is mutually exclusive with the MySQLSessionCache and SessionCache elements.

AAConnectTimeout: Time in seconds the target will wait before timing out on the initial connection to an origin to request attributes. Defaults to 15.

AATimeout: Time in seconds the target will wait before timing out while waiting for attributes from an origin once the initial connection is established. Defaults to 30.

cacheTimeout: Time in seconds to permit a session to stay in the cache before being purged. Defaults to 28800.

cleanupInterval: Seconds between runs of the background thread that purges expired sessions. Defaults to 300.

defaultLifetime: If the attribute assertion doesn't carry an explicit expiration time, the assertion will expire after this time in seconds has elapsed. Defaults to 1800.

propagateErrors: If true, then any errors that occur during the attribute query stage are fatal and will be presented to the user as an error, terminating their session. If false, any errors that occur during the query are non-fatal, and the application will be given older, expired attributes based on the strictValidity setting.
This should generally only be left to false (the default) by deployments that are using real principal names as subjects because attribute retrieval is treated as an optional process.

retryInterval: Time in seconds between attempts to obtain fresh attributes. If a query fails, a timer is set, and once the interval elapses, the next user request causes another query. This prevents pointless repeated attempts to query a failed origin. Defaults to 300.

strictValidity: If true, expired attributes will never be made available to the Shibboleth application; if no valid attributes can be obtained, then an empty set is provided. When false, if a fresh set of attributes cannot be retrieved due to failures, any cached, expired attributes are made available. Defaults to true.

<MySQLSessionCache mysqlTimeout="seconds"/>

Shibboleth will back the memory cache of sessions using an embedded MySQL database if this element is found in the SHAR element. Arguments may be passed directly to MySQL by populating this element with Argument elements. The element may also specify any of the attributes defined for the MemorySessionCache element. Mutually exclusive with the MemorySessionCache and SessionCache elements.

mysqlTimeout: Time in seconds to permit a session to stay in the persistent cache before being purged. Defaults to 28800.

(RequestMap) <Path name="pathname" applicationId="id" requireSession="true/false" exportAssertion="true/false">

This element allows for different application identifiers and session handling to be defined iteratively for subdirectories or documents within a host. Requests are processed on a best-match basis, with the innermost element taking precedence. Path elements may be contained by Host elements or other Path elements.

name: This is the name of the path component or filename to match against the request. Only exact matching is supported by the supplied request mapping provider.

requireSession: This attribute controls whether Shibboleth will forcibly establish an authenticated session with the user before handing off the request to the web server or application. If true, Shibboleth will force session establishment. If false (the default), applications are responsible for ensuring that a session exists if necessary, so-called lazy session establishment. Most deployments should not specify false for protected content without a full understanding of the implications.

exportAssertion: When true, the entire SAML attribute assertion received from the origin is exported to a CGI request header called Shib-Attributes, encoded in base64. This requires an application to be able to parse the raw XML. Defaults to false, which most deployments should use.

(Credential) <Path>pathname</Path>

Placed inside the Key and Certificate elements to specify the pathname of the file containing the credential.

<RelyingParty name="string" TLS="string" Signing="string">

One or more RelyingParty elements may be contained by a CredentialUse element to enumerate relying parties for which a distinct set of credentials should be used. The TLS and Signing attribute values reference the identifiers of credential resolvers defined in CredentialsProvider elements.

name: Identifies the origin site or group of sites to which the credentials specified in the element apply. This is used to match the providerId sent within attribute assertions from origin sites against a set of "groups" based on metadata.

<RequestMap applicationId="default" requireSession="true/false" exportAssertion="true/false">

The RequestMap element is a container holding Host and Path elements. Request URLs processed by Shibboleth are parsed and matched against this set of elements in order to determine how to process the request. Attributes on the RequestMap, Host, and Path elements specify whether to require an authenticated session, and how to locate the associated Application element and settings.

applicationId: Contains a fixed value of "default" to reference the default Applications element.

requireSession: This attribute controls whether Shibboleth will forcibly establish an authenticated session with the user before handing off the request to the web server or application. If true, Shibboleth will force session establishment. If false (the default), web applications are responsible for ensuring that a session exists if necessary, so-called lazy session establishment. Most deployments should not specify false for protected content without a full understanding of the implications.

exportAssertion: When true, the entire SAML attribute assertion received from the origin is exported to a CGI request header called Shib-Attributes, encoded in base64. This requires an application to be able to parse the raw XML. Defaults to false, which most deployments should use.

<RequestMapProvider type="edu.internet2.middleware.shibboleth.target.provider.XMLRequestMap" uri="pathname">

This element specifies a request mapper that defines how Shibboleth will handle sessions and other behavior for a given request. For the built-in type "edu.internet2.middleware.shibboleth.target.provider.XMLRequestMap", there must be a RequestMap element within this element, or the uri attribute must contain the local pathname of an XML file containing one.

<RevocationProvider type="edu.internet2.middleware.shibboleth.common.provider.XMLRevocation" uri="pathname">

This element, when specified within an Applications or Application element, points to revocation information either inline within the element or in a local XML file. Federations will often publish signed XML files for targets to download periodically. This should be refreshed regularly; see section 4.g for further details.

The default set of revocation providers in the Applications element can be replaced within individual Application elements.

<SessionCache type="string">

Specifies a pluggable session cache implementation of the specified type. This element is placed within the SHAR element and is mutually exclusive with the MemorySessionCache and MySQLSessionCache elements.

Any plugin should support the basic attributes defined by the MemorySessionCache element.

<Sessions wayfURL="URL" shireURL="URL" shireSSL="true/false" lifetime="seconds" timeout="seconds" checkAddress="true/false" cookieName="URL" cookieProps="URL">

Configuration parameters that affect the way Shibboleth handles sessions for an individual application are bundled in this element, which must be included in each Application and the default Applications element. Note that these parameters only apply to Shibboleth sessions, and not any sessions applications manage on their own behalf.

wayfURL: The URL of the WAYF service responsible for redirecting users accessing this application to their identity provider (origin).

shireURL: Specifies the SHIRE URL, or assertion consumer service, at which new sessions are initiated or lazy sessions are triggered. This can be an absolute URL, or a relative path to be prefixed by the base URL of the virtual host. Using an absolute URL allows a virtual server to funnel requests to a fixed location, to force use of SSL, for example.

Note that this URL issues the session cookie set on behalf of the application, and this cookie must be returned in subsequent requests, so the virtual host's domain name and port must be consistent with this domain name and port for some browsers to properly return the cookie. If default ports are used (and thus left unspecified), browsers will generally return cookies set via SSL to a non-SSL port. If non-default ports are used, it is recommended that this be a relative URL so that each virtual host handles its own cookie operations.

For Shibboleth to function properly in IIS, the file extension at the end of this URL must match the value configured into IIS and mapped to the ISAPI extension. This causes the request to be serviced properly, even though no file by that name actually exists.

shireSSL: If true (the default), the application will only accept new session requests over SSL, as is strongly recommended; see section 2.c for more details.

cookieName: Optionally specifies the name given to in-memory session cookies that are associated with this application. If omitted, Shibboleth will generate a cookie name for you of the form _shibsession_<Application ID>

cookieProps: A string of additional Set-Cookie properties can be specified using this element which give the browser further instructions about cookie processing and use. Always begin with a semicolon to delineate from the session ID value.

lifetime: Duration in seconds of the Shibboleth session; this does not affect the lifetime of application sessions initiated independently of Shibboleth. Defaults to 3600. If 0 is specified, sessions are infinite, subject to purging by the cache.

timeout: If the value in seconds elapses following the last request in a session, the session will be expired for inactivity and a new session must be initiated upon the next request. Defaults to 1800. If 0 is specified, there is no inactivity timeout

checkAddress: If true (the default), Shibboleth will check the browser's client address to insure that session cookies are issued and used by a consistent client address. In most circumstances, this should be enabled to help prevent attacks using stolen cookies, but this can cause problems for users behind proxies or NAT devices.

<SHAR logger="pathname">

This is the container element for configuration information pertaining to the SHAR, the target component responsible for most attribute and session processing. Its single attribute, logger, points to a Log4J-format property configuration file that controls SHAR logging behavior. It is placed within the ShibbolethTargetConfig element and may contain an Extensions element specifying additional libraries.

It must contain either a UnixListener element to listen to the server module on a UNIX domain socket or a TCPListener element to listen on a TCP port. Session caching must also be specified using a MemorySessionCache element to use in-memory session caching or a MySQLSessionCache element to backup session information into a MySQL database.

<ShibbolethTargetConfig clockSkew="integer">

This is the root element for target configuration and must be present once and only once. It must always contain a SHAR element, a SHIRE element, an Applications element, one or more CredentialsProvider elements, and optionally an Extensions element.

clockSkew: Controls allowed clock skew in seconds between target and origin servers when evaluating times sent in messages. Defaults to 180, and should be as small as practical.

<SHIRE logger="pathname">

This is the container element for configuration information pertaining to the SHIRE, the part of the target that integrates into the web server environment. Its single attribute, logger, points to a Log4J-format property configuration file that controls SHIRE logging behavior. It is placed within the ShibbolethTargetConfig element and may contain an Extensions element specifying additional libraries.

It may contain an Implementation element, within which configuration for the SHIRE which varies by platform will be specified.

It may contain a RequestMapProvider element, which provides fine-grained control over aspects of target behavior at a host, path, or document level.

<Site id="INSTANCE_ID" name="fqdn" scheme="http/https" port="integer">

This element is placed in the ISAPI element to specify a mapping from individual instance ID's to the corresponding hostname, port, and scheme.

<TCPListener address="pathname" port="integer" acl="ip">

This element is placed within the SHAR element and is mutually exclusive with the UnixListener and Listener elements. It allows the SHAR to communicate with the web server component using TCP.

address: Specifies the IP address of the listener.

port: Specifies the TCP port on which the SHAR will listen.

acl: By default, the SHAR will only listen to requests from 127.0.0.1 (localhost). This should generally not be specified except in test environments.

<TrustProvider type="edu.internet2.middleware.shibboleth.common.provider.XMLTrust" uri="pathname">

This element, when specified within an Applications or Application element, points to trust metadata either inline within the element or in a local XML file. Federations will often publish signed XML files for targets to download periodically. This should be refreshed regularly; see section 4.g for further details.

The default set of trust providers in the Applications element can be replaced within individual Application elements.

<UnixListener address="pathname">

Use this element to specify a UNIX domain socket located at the pathname specified in the address attribute at which the SHAR should listen for requests. This element must be contained by the SHAR element and is mutually exclusive with the TCPListener and Listener elements. UnixListener cannot be specified for Windows-based installations.

4.b. Dynamic Error Page Generation

Shibboleth supports the dynamic generation of information in error pages referenced by the Errors element in shibboleth.xml. The target implementation employs a simply template language to insert special tags into the generated HTML. The parser will read the error template looking for any tag that looks like:

<shibmlp tag-name />

Shibboleth will replace tag-name with the appropriate markup tag either from the table below or by looking for a matching XML attribute in the Errors element:

requestURL

The user's requested URL.

errorType

The type of error.

errorText

The actual error message.

errorDesc

A textual description of the error intended for human consumption.

originContactName

The contact name for the origin site provided by that site's metadata.

originContactEmail

The contact email address for the origin site provided by that site's metadata.

originErrorURL

The URL of an error handling page for the origin site provided by that site's metadata.

To improve the appearance of error messages, a simple, limited form of conditional checking is supported so that the presence of absence of data to substitute into a particular tag-name can trigger the inclusion or exclusion of markup. Conditionals look like:

<shibmlpif tag-name> arbitrary markup </shibmlpif>
<shibmlpifnot tag-name> arbitrary markup </shibmlpifnot>

Respectively, these special tags include or skip the markup between the tags if the specified tag-name has an associated value available to be substituted for it. Note that you cannot nest these conditionals; a shibmlpif tag cannot appear inside another shibmlpif tag, due to the simplicity of the substitution engine.

Sample error templates for different kinds of errors are included in the Shibboleth distribution, and can be triggered by anything that will cause Shibboleth to be unable to accept an incoming session, obtain attributes, make an authorization decision, etc., including bad configuration settings, signature verification or certificate validation failures, or a skewed clock between sites.

You should edit these templates, provide or remove style sheets and images, and otherwise customize these templates to suit the user experience you want your users to have when errors occur. The defaults are not likely to meet the needs of any site.

4.c. Key Generation and Certificate Installation

The only target component that must have a private key and certificate is the SHAR. While the target server itself should support SSL in most cases for users, it is mandatory for the SHAR to authenticate when contacting an AA, and it must therefore be given a key and an SSL client certificate. It is permissible for the SHAR to use the same keypair and certificate used by the target web server itself, provided the certificate is signed by a CA accepted by the origin sites that will be queried for attributes.

On Unix, we require that OpenSSL be installed to use Shibboleth. On Windows, OpenSSL libraries and the command line tool are included in the package and can be used directly, if not otherwise available. Certain commands require the openssl.cnf configuration file, an example of which is included with the Windows installation in C:\opt\shibboleth\etc\shibboleth\openssl.cnf. To locate this file for a command that requires it, add the -config C:\opt\shibboleth\etc\shibboleth\openssl.cnf parameter to the command.

The certificate and key file location should be based on whether they will also be used for Apache. If they will be used as a server key pair as well, they should probably be in the Apache tree in the usual mod_ssl-defined locations inside the Apache configuration folder, and the SHAR can read them from there. If the SHAR is not running as root, permissions might need to be changed to allow this access. If the certificate and key will only be used for the SHAR, they can be put in the same folder with the shibboleth.xml file and protected appropriately.

Other web servers like IIS do not use the file formats that Apache and Shibboleth can share, and therefore the components must generally use separate copies of the key and certificate if they are to be shared. Most other servers can export and/or import keys to and from PEM or DER format. Refer to your server's documentation or ask for assistance from others who use it.

The SHAR is assigned a key and a certificate using shibboleth.xml's FileResolver element described in section 4.a. Various formats are supported and OpenSSL can generate and convert among them. OpenSSL commands to generate a new keypair and a certificate request are shown here, assuming 2048 bit RSA keys are to be used:

$ openssl genrsa -out ssl.key 2048
$ openssl req -new -key ssl.key -out ssl.csr

The signed certificate file returned by the CA should be usable directly.

If the key is to be shared with Apache, the web server's child processes, often running as nobody or a similar uid, must be able to read them while the server is running, which may require permission changes.

This particularly applies when sharing the key and certificate used by mod_ssl, which are only readable by root by default. The password, if any, must be placed in the shibboleth.xml file, since the Apache module cannot prompt for it during initial startup as mod_ssl can. The issues surrounding how to securely obtain a key while running as nobody may be addressed in a later release. Since the password will be stored in clear text in a frequently examined file, it is suggested to use a password not used elsewhere, or preferably not to use a password at all.

4.d. Protecting Web Pages

Protection of web pages is primarily achieved through "mapping" attributes provided by an AA to a localized vocabulary for authorization rules. This is accomplished using features in the AAP syntax, described in section 4.e. This applies to both Apache and IIS.

IIS

The IIS filter module supports the mapping of attributes into HTTP headers via AAP files, but it does not yet support rule-based access control and therefore cannot protect static content at this time. In addition, all of the configuration settings, such as control over whether to prompt for new sessions automatically, are managed via the RequestMap element, so there are no additional commands to document at this time.

Apache

The Apache module provided can also interpret AAP settings to map attributes to HTTP request headers and to Require rules, permitting protection of both static and dynamic content. Any of the typical ways of protecting content may be used (.htaccess, Directory, Location, Files, etc.). They define what content is to be protected and static access control rules.

There are two ways to require Shibboleth authentication, but both also require enabling the module to activate by specifying an AuthType of shibboleth and supplying at least one Require rule in httpd.conf or .htaccess files. The Require rule can enforce a specific access control policy based on attributes, can specify valid-user to require any authenticated session, or it can support so-called lazy sessions by using the place-holder rule name of Shibboleth. In such cases, the module is activated, but in a passive mode that does not automatically force a session, but will process and validate a session if one exists, leaving the authorization decision to the application. Using a static access control rule that will fail in the absence of a session is only sensible if one of the two approaches below that force a session are used.

To require a session, either the Apache command, ShibRequireSession On, or the requireSession boolean XML attribute on the RequestMap, Host, or Path elements in shibboleth.xml can be used. Both approaches are equivalent, and using either one to require a session will supersede a false or absent setting of the other type.

As an example, the following commands will require Shibboleth authentication for a resource:

AuthType shibboleth
ShibRequireSession On
Require valid-user

A complete list of Apache directives and their values is below:

ShibURLScheme <http/https>

Used in advanced virtual hosting environments which need to generate SSL redirects from virtual servers that use only HTTP. Supplements the Apache ServerName and Port commands with this missing option. Defaults to a null value in which the scheme for redirects is based on the physical connection to the server. This is a server-level command, while the rest of the commands listed are content commands that can appear anywhere.

AuthType <string>

Use shibboleth for direct invocation, or Basic plus the ShibBasicHijack option described below.

ShibBasicHijack <on/off>

Controls whether Shibboleth should or should not ignore requests with AuthType Basic. Defaults to off.

ShibRequireSession <on/off>

Controls whether to require an authenticated session before passing control to the authorization phase or the actual resource. Defaults to off.

ShibExportAssertion <on/off>

Controls whether the SAML attribute assertion provided by the AA is exported in a base64-encoded HTTP header, HTTP_SHIB_ATTRIBUTES. Defaults to off.

ShibRequireAll <on/off>

Controls whether all Require rules specified must be satisfied before access to the resource is granted. Defaults to off, which means any single rule can be satisfied, the usual Apache behavior.

AuthGroupFile <pathname>

Same as mod_auth; collects values found in REMOTE_USER into a named group for access control. An attribute must be mapped to REMOTE_USER for this to work. Note that mod_auth will not support group files when the Shibboleth module is loaded, since they share the same command.
This is implemented by placing a .htaccess file that references a group file stored at /pathname:

AuthGroupFile /pathname
require group workgroup

An AuthGroupFile used by Shibboleth might resemble:
workgroup: joe@example.edu, jane@demo.edu, jim@sample.edu

Require <string>

Enforce authorization using one of the following methods.

valid-user

Any Shibboleth user from a trusted origin site is accepted, even if no actual attributes are received. This is a very minimal kind of policy, but is useful for testing or for deferring real policy to an application.

user

A space-delimited list of values, such as from the urn:mace:dir:attribute-def:eduPersonPrincipalName attribute. Actually, any attribute can be mapped to REMOTE_USER, even if this doesn't always make sense.

group

A space-delimited list of group names defined within AuthGroupFile files, again provided that a mapping to REMOTE_USER exists.

alias

An arbitrary rule name that matches an Alias defined in an AAP file. The rule value is a space-delimited list of attribute values, whose format depends on the attribute in question (e.g. an affiliation rule might look like:

require affiliation staff@osu.edu faculty@mit.edu

shibboleth

If a session cookie of the expected name exists, the corresponding session will be validated and any cached attributes exported as otherwise specified. Authorization will be controlled by the resource, unless additional rules are specified. If however a session does not already exist, or if the current session expires or times out, no session will be requested and control will pass to the resource.

Additionally, for user and <alias>-based rules, if a tilde character is placed immediately following user or <alias>, the expressions that follow are treated as regular expressions. The syntax supported is generally based on the one defined by XML Schema. This specification borders on unreadable, but the syntax is generally Perl-like. Expressions should generally be "anchored" with the ^ and $ symbols to insure mid-string matches don't cause false positives.

For example, the rule:
require affiliation ~ ^member@.+\.edu$
would evaluate to allowing anyone with an affiliation of member from a .edu domain.

4.e. Defining Attributes and Acceptance Policies

Shibboleth allows a user and a site to release a varying set of attributes to a destination site, and does not impose restrictions on the kinds of attribute information provided by an AA. Target implementations must be prepared to examine the attributes they receive and filter them based on policies about what information to permit an origin site to assert about its users.

Attribute acceptance is the process of defining acceptable attributes and filtering attribute values before passing them on to a resource manager, such as the Shibboleth module or a web application. Data blocked by AAP filters will not be passed to the CGI environment or used when enforcing .htaccess rules in Apache. Note that the attribute assertion exported to the HTTP_SHIB_ATTRIBUTES header is now also filtered. This is a change from previous versions. To compensate, either no AAP can be specified, or a rule can be applied to permit all attributes to pass through while also exporting specific attributes.

The Shibboleth implementation supports Scoped and Simple attributes and filtering policies for different kinds of attributes, and is potentially extensible to more complex attributes in the future. An attribute is considered Scoped if the XML representation of its values contains a "Scope" attribute. As of 1.1+, this is detected at runtime and requires no configuration in advance.

An essential part of the Shibboleth trust fabric is ensuring that sites only assert attributes for domains for which they are considered authoritative by the target. Typically, this means that Brown University will be trusted to assert attributes only scoped to brown.edu. Unless there are very specific circumstances requiring this restriction be removed, it is strongly encouraged that such policies be left in place.

Scoped:

Scoped attributes are a special kind of attribute whose values are a combination of a value and a scope, or context for the value. An example is eduPersonScopedAffiliation, which adds a scope to the defined set of eduPersonAffiliation values, such as student, member, or faculty. Scopes are expressed as DNS domains and subdomains as a convention.

Any scoped attribute can be scoped only to the origin site's permitted domains. These domains are listed in the operational metadata that provides policy information to the system and can be overridden or supplemented using the AAP. Domains can be explicit or regular expressions, and can be changed by a target to meet its needs. Thus, attribute acceptance processing for scoped attributes is based on site metadata and target-specified overrides in addition to the mechanism described below for simple attributes.

Scope rules specified in an AAP are additive with any domains permitted by site metadata, and the rules are applied by first looking for an applicable denial rule, and then looking at site metadata and any applicable site rules for an accept rule.

Simple:

Simple attributes are attributes whose value is expressed in XML as a Text node; that is, the value is just a string. Multiple values are permitted. eduPersonEntitlement, in which the values are URIs, is one example of a simple attribute.

Both Simple and Scoped attribute acceptance is controlled with an external (or in 1.2, optionally inline) policy file written in XML. The schema for the file is described by the shibboleth.xsd schema, and an example file is included, AAP.xml. It is now optional to supply such a policy, but in the absence of one, no attributes will be exported into request headers, and the option to export the assertion as a whole must be used instead.

The policy is a default-deny algorithm that requires permissible attributes and values be listed explicitly. That is, an empty (as opposed to no) policy permits nothing. Each attribute to be supported must be listed in the policy by name in an <AttributeRule>. Each such rule is a collection of <SiteRule> elements along with an optional <AnySite> default rule. In turn each site rule is a set of <Value> rules that specify matches to permit, either literal or regular expressions, or a wildcarded <AnyValue> default rule, which is equivalent to a single regular expression rule allowing anything.

With 1.2, a new <AnyAttribute> element can be used before or in place of the <AttributeRule> elements to allow all attributes and values to pass muster. The purpose of this is to then supply rules to specify the export of particular attributes, without using those rules to control acceptance.

A syntax summary follows:

<AttributeAcceptancePolicy>

The top level element in the file.

<AnyAttribute>

Disables acceptance filtering and leaves the assertion intact.

<AttributeRule>
Name="urn:mace:dir:attribute-def:eduPersonScopedAffiliation"
Header="Shib-EP-Affiliation" Alias="affiliation">

Specifies a rule for an attribute, named by its URI. The following XML attributes can be supplied:

Name The name of the Shibboleth attribute, usually a URI. This is the only required XML attribute.

Namespace If the attribute's name includes a SAML namespace, supply it here. Normally this is unused.

Header The HTTP request header to map the attribute's values into.

Alias A short name for the attribute, determines the name of the Apache Require rule.

<AnySite>

Specifies a rule that always applies to the attribute, regardless of the asserting origin site.

<SiteRule Name="providerId">

A rule that applies to the origin site corresponding to the supplied identifier

<Scope Accept="true|false" Type="type">

Specifies a value to accept or deny, either directly using type literal, or using a set of matching expressions as type regexp. literal is the default if Type is not specified. Accept defaults to "true">.

<AnyValue>

Specifies a rule that always applies to the attribute and site, regardless of the value(s).

<Value Type="type">

Specifies a value to permit, either directly using type literal, or using a set of matching expressions as type regexp. literal is the default if Type is not specified.

The regular expression syntax is a subset of the usual Perl and Unix syntaxes that is described in the XML Schema specification by the W3C. Most typical expressions should work. Be sure to anchor them using ^ and $ to avoid unintentional matches midstring.

4.f. Using Attributes and Session Data in Applications

Apart from the simple RM functionality provided, attribute information may be made available directly to applications via the standard practice of creating custom HTTP request headers before passing control to the resource. Web applications should make no assumption about the presence of specific attributes for their use unless they have intimate knowledge of the attribute release policies in place.

The AAP rules control this interface, and map Shibboleth attributes to header names, such as Shib-EP-Affiliation. Using that example, any values of the mapped attribute will be placed in that header, delimited by semicolons. An application that uses a CGI-like syntax to access the header will find the values in the HTTP_SHIB_EP_AFFILIATION variable. Any attribute can be placed in any header, to drive legacy applications that expect information in a particular location.

The REMOTE_USER variable is a special case that is generally populated automatically by the web server based on an internal piece of data that represents the current username. Unlike many authentication modules, Shibboleth does not guarantee that REMOTE_USER will have any value, because users may remain anonymous in many cases. If it does have a value, it is set solely because of an AAP file that maps an attribute to that header name. For many purposes, the urn:mace:dir:attribute-def:eduPersonPrincipalName attribute should be mapped to REMOTE_USER. Even so, EPPN may not be provided by the AA, and REMOTE_USER might still be empty.

In addition to general attribute information, the following special HTTP headers are created for any authenticated request:

HTTP_SHIB_ORIGIN_SITE

Contains the unique identifier (providerId) of the origin site of the user. Some applications may use this to lookup additional policy or application data. It normally takes the form of a URI but could be any string in some deployments.

HTTP_SHIB-AUTHENTICATION-METHOD

Contains the SAML AuthenticationMethod URI that documents some aspect of the user's authentication to the origin site's web authentication service.

HTTP_SHIB_APPLICATION_ID

Contains the XML applicationId attribute in shibboleth.xml that corresponds to the request based on the RequestMap and associated elements.

HTTP_SHIB_ATTRIBUTES

Contains the assertion in XML containing the SAML attribute information from the AA in base64-encoded format. This is a raw interface that provides an application with the entire assertion in, but is still a filtered view based on any attribute acceptance rules.

Finally, special support exists to obtain the value of the SAML <NameIdentifier> element, which identifies the subject of the session, the user. Many Shibboleth deployments use opaque handles that have no application value, however newer deployments may choose to support alternative identifiers, including formats defined by SAML. Targets can use these origins and obtain the primary subject name by using a special AAP <AttributeRule> with a Name corresponding to the SAML Format identifier that describes the kind of identifier used to represent the subject. The rule specifies in what header to export the identifier value (such as REMOTE_USER), while the Format identifier will be placed in the HTTP_SHIB_NAMEIDENTIFIER_FORMAT header.

4.g. siterefresh

Shibboleth provides a simple tool called siterefresh in the /opt/shibboleth/bin folder of the distribution to maintain metadata files referenced by shibboleth.xml. It will return 0 only on success and a negative number on failure and log errors to stderr. If the data in the new metadata file is unusable or schema invalid, or the signature is invalid, the existing copy is kept and not overwritten. The SHAR and SHIRE stat all metadata files each time the data is used, allowing them to detect and utilize updates in real-time during system operation.

siterefresh takes the following command-line parameters:

--url <URL>

Specifies the URL of the remote metadata file with which to update the local file. HTTPS is not supported at this time.

--out <pathname>

Specifies the local file to which to write the new metadata.

--noverify

Explicitly disables the requirement for the file to be signed and allows the certificate parameter to be ommitted. If the file is signed, the signature will be verified using whatever key is supplied inside it, and an invalid signature will still result in an error, but if the file is unsigned or has a valid signature, only a warning will be logged, and the result will be success.

--cert <pathname>

Specifies the location of a certificate stored in PEM format used to validate the signature of the metadata file. Since much of Shibboleth's security flows from metadata files, this option is highly recommended, and the certificate used should be verified independently in some out of band fashion.

--schema <pathname>

Optionally defines a base path for schemas to use when validating the file. Defaults to a location based on the installation path on Unix, or \opt\shibboleth\etc\shibboleth on Windows.

--rootns <XML namespace>

Optionally defines the XML namespace of the root element expected in the new file. Normally unused, provided to support alternative metadata formats that may be backported to older releases.

--rootname <XML element name>

Optionally defines the name of the root element expected in the new file. Normally unused, provided to support alternative metadata formats that may be backported to older releases.

If a zero is returned, the command will copy the retrieved file to the output location. Otherwise one of the following error values will be returned:

-100 an invalid combination of parameters was specified

-10 the OpenSAML library failed to initialize

-1 the file's XML digital signature was invalid

-2 a SAML exception was trapped

-3 an XML library exception was trapped

-4 a general XML security library exception was trapped

-5 an XML security library crypto exception was trapped

-6 an unknown exception was trapped

A complete command issued to siterefresh might take the form:

/opt/shibboleth/bin/siterefresh --out IQ-sites.xml --cert internet2.pem \
--url http://wayf.internet2.edu/InQueue/IQ-sites.xml

It is recommended that such commands be added to a crontab to keep the site and trust files refreshed. AAP files tend to be site-specific, but could be maintained and distributed centrally. If the command is invoked in a script that writes the file to a new location and compares it with the old contents before overwriting the original, the command could be run very often without impacting target operations, providing a high degree of currency in case sites become compromised.

4.h. MySQL Session Cache

Shibboleth includes a useful plugin that extends the default memory cache for storing session data in the SHAR with a backing cache using an embedded MySQL database. It is now disabled by default. The plugin can be found in the /opt/shibboleth/libexec folder, and is loaded as an extension library using the Extensions element of shibboleth.xml. The extension and the MySQLSessionCache element are commented out by default.

Important Argument elements you'll find by default include:

--language=/opt/shibboleth/share/english
--datadir=/opt/shibboleth/data

which set the message file path and the location of the cache's database files respectively. Make sure the data directory exists before starting the SHAR if you change this path.

4.i. Using Lazy Sessions

For a background on sessions in Shibboleth, and a description of what a lazy session is and why it would be useful, consult section 1.g.

This section describes how an application can trigger the establishment of a Shibboleth session and optionally receive attributes once its internal logic decides this is necessary. It assumes the application is protected using lazy sessions because the RequireSession attribute of the Path or Host element protecting it is set to false. This application must be aware of two pieces of information:

The URL that should be accessed after the session is established; frequently, this will be the application's own URL; and

The URL of the SHIRE associated with the Application containing the URL to be accessed(contained within the corresponding Sessions element).

These two pieces of information must be combined by the application to an appropriately formed URL to trigger session initiation as follows. To request a session, the application returns an HTTP redirect that sends the browser to the SHIRE URL with a parameter, target, containing the URL of the resource to return to with a session. This will often be the URL that's triggering the redirect. The SHIRE will generate the redirect to the WAYF and the rest proceeds as a standard Shibboleth flow. This combined URL takes the form: https://shireURL?target=applicationURL.

For example, if an application located at https://foo.com/portal presents a page with an option to login, it could respond to the login button by redirecting the browser to https://foo.com/Shibboleth.shire?target=https%3A%2F%2Ffoo.com%2Fportal.

5. Troubleshooting

This section provides basic information about testing Shibboleth targets. This information is not intended to be comprehensive, but instead rudimentary guidelines for basic configuration tests and problems. For more detailed information or answers to specific problems not addressed in this section, please mail shibboleth-users@internet2.edu with a thorough description of errors and configurations used.

5.a. Basic Testing

The target may be tested by generating a folder with very basic access controls on it, and accessing it using a web browser. Place a simple webpage such as index.html in /secure/. Then, add the following lines to httpd.conf, which should be removed when testing is over:

# Configure a test directory
<Location /secure>
  AuthType shibboleth
  ShibRequireSession On
  require valid-user
</Location>

For information regarding specific error messages that may be generated if the target does not work successfully, please refer to section 5.b., or write shibboleth-users@internet2.edu.

5.b. Common Problems

A knowledge base is being developed in the Shibboleth Deployer's FAQ. Please mail shibboleth-users@internet2.edu with any additional questions or problems encountered that are not answered by this basic guide.

Name	The name of the Shibboleth attribute, usually a URI. This is the only required XML attribute.
Namespace	If the attribute's name includes a SAML namespace, supply it here. Normally this is unused.
Header	The HTTP request header to map the attribute's values into.
Alias	A short name for the attribute, determines the name of the Apache Require rule.

-100	an invalid combination of parameters was specified
-10	the OpenSAML library failed to initialize
-1	the file's XML digital signature was invalid
-2	a SAML exception was trapped
-3	an XML library exception was trapped
-4	a general XML security library exception was trapped
-5	an XML security library crypto exception was trapped
-6	an unknown exception was trapped