src/edu/internet2/middleware/shibboleth/idp/profile/AbstractSAMLProfileHandler.java

   1 /*
   2  * Copyright [2007] [University Corporation for Advanced Internet Development, Inc.]
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package edu.internet2.middleware.shibboleth.idp.profile;
  18
  19 import javax.servlet.ServletRequest;
  20 import javax.servlet.ServletResponse;
  21 import javax.servlet.http.HttpServletRequest;
  22
  23 import org.apache.log4j.Logger;
  24 import org.opensaml.common.IdentifierGenerator;
  25 import org.opensaml.common.SAMLObject;
  26 import org.opensaml.common.binding.decoding.MessageDecoderFactory;
  27 import org.opensaml.common.binding.encoding.MessageEncoderFactory;
  28 import org.opensaml.saml2.metadata.Endpoint;
  29 import org.opensaml.saml2.metadata.EntityDescriptor;
  30 import org.opensaml.saml2.metadata.RoleDescriptor;
  31 import org.opensaml.saml2.metadata.provider.MetadataProvider;
  32
  33 import edu.internet2.middleware.shibboleth.common.log.AuditLogEntry;
  34 import edu.internet2.middleware.shibboleth.common.profile.ProfileRequest;
  35 import edu.internet2.middleware.shibboleth.common.profile.ProfileResponse;
  36 import edu.internet2.middleware.shibboleth.common.profile.provider.AbstractShibbolethProfileHandler;
  37 import edu.internet2.middleware.shibboleth.common.relyingparty.provider.SAMLMDRelyingPartyConfigurationManager;
  38 import edu.internet2.middleware.shibboleth.idp.session.Session;
  39
  40 /**
  41  * Base class for SAML profile handlers.
  42  */
  43 public abstract class AbstractSAMLProfileHandler extends
  44         AbstractShibbolethProfileHandler<SAMLMDRelyingPartyConfigurationManager, Session> {
  45
  46     /** SAML message audit log. */
  47     private final Logger auditLog = Logger.getLogger(AuditLogEntry.AUDIT_LOGGER_NAME);
  48
  49     /** Generator of IDs which may be used for SAML assertions, requests, etc. */
  50     private IdentifierGenerator idGenerator;
  51
  52     /** Factory of message decoders. */
  53     private MessageDecoderFactory decoderFactory;
  54
  55     /** Factory of message encoders. */
  56     private MessageEncoderFactory encoderFactory;
  57
  58     /** Constructor. */
  59     protected AbstractSAMLProfileHandler() {
  60         super();
  61     }
  62
  63     /**
  64      * Gets an ID generator which may be used for SAML assertions, requests, etc.
  65      *
  66      * @return ID generator
  67      */
  68     public IdentifierGenerator getIdGenerator() {
  69         return idGenerator;
  70     }
  71
  72     /**
  73      * Gets an ID generator which may be used for SAML assertions, requests, etc.
  74      *
  75      * @param generator an ID generator which may be used for SAML assertions, requests, etc
  76      */
  77     public void setIdGenerator(IdentifierGenerator generator) {
  78         idGenerator = generator;
  79     }
  80
  81     /**
  82      * Gets the factory used to build new message decoders.
  83      *
  84      * @return factory used to build new message decoders
  85      */
  86     public MessageDecoderFactory getMessageDecoderFactory() {
  87         return decoderFactory;
  88     }
  89
  90     /**
  91      * Sets the factory used to build new message decoders.
  92      *
  93      * @param factory factory used to build new message decoders
  94      */
  95     public void setMessageDecoderFactory(MessageDecoderFactory factory) {
  96         decoderFactory = factory;
  97     }
  98
  99     /**
 100      * Gets the factory used to build message encoders.
 101      *
 102      * @return factory used to build message encoders
 103      */
 104     public MessageEncoderFactory getMessageEncoderFactory() {
 105         return encoderFactory;
 106     }
 107
 108     /**
 109      * Sets the factory used to build message encoders.
 110      *
 111      * @param factory factory used to build message encoders
 112      */
 113     public void setMessageEncoderFactory(MessageEncoderFactory factory) {
 114         encoderFactory = factory;
 115     }
 116
 117     /**
 118      * A convenience method for retrieving the SAML metadata provider from the relying party manager.
 119      *
 120      * @return the metadata provider or null
 121      */
 122     public MetadataProvider getMetadataProvider() {
 123         SAMLMDRelyingPartyConfigurationManager rpcManager = getRelyingPartyConfigurationManager();
 124         if (rpcManager != null) {
 125             return rpcManager.getMetadataProvider();
 126         }
 127
 128         return null;
 129     }
 130
 131     /**
 132      * Gets the audit log for this handler.
 133      *
 134      * @return audit log for this handler
 135      */
 136     protected Logger getAduitLog() {
 137         return auditLog;
 138     }
 139
 140     /**
 141      * Gets the user's session ID from the current request.
 142      *
 143      * @param request current request
 144      *
 145      * @return user's session ID
 146      */
 147     protected String getUserSessionId(ProfileRequest<ServletRequest> request) {
 148         HttpServletRequest rawRequest = (HttpServletRequest) request.getRawRequest();
 149         if (rawRequest != null) {
 150             return (String) rawRequest.getSession().getAttribute(Session.HTTP_SESSION_BINDING_ATTRIBUTE);
 151         }
 152
 153         return null;
 154     }
 155
 156     /**
 157      * Contextual object used to accumlate information as profile requests are being processed.
 158      *
 159      * @param <StatusType> type of Status object
 160      */
 161     protected class SAMLProfileRequestContext<StatusType extends SAMLObject> extends ShibbolethProfileRequestContext {
 162
 163         /** Entity descriptor for the asserting party. */
 164         private EntityDescriptor assertingPartyMetadata;
 165
 166         /** Role descriptor meatadata for the asserting party. */
 167         private RoleDescriptor assertingPartyRoleMetadata;
 168
 169         /** Message decoder URI. */
 170         private String messageDecoder;
 171
 172         /** Message encoder URI. */
 173         private String messageEncoder;
 174
 175         /** Request relay state. */
 176         private String relayState;
 177
 178         /** Endpoint of relying party. */
 179         private Endpoint relyingPartyEndpoint;
 180
 181         /** Entity descriptor for the relying party. */
 182         private EntityDescriptor relyingPartyMetadata;
 183
 184         /** Role descriptor meatadata for the relying party. */
 185         private RoleDescriptor relyingPartyRoleMetadata;
 186
 187         /**
 188          * Constructor.
 189          *
 190          * @param request current profile request
 191          * @param response current profile response
 192          */
 193         public SAMLProfileRequestContext(ProfileRequest<ServletRequest> request,
 194                 ProfileResponse<ServletResponse> response) {
 195             super(request, response);
 196         }
 197
 198         /**
 199          * Gets the metadata for the asserting party.
 200          *
 201          * @return metadata for the asserting party
 202          */
 203         public EntityDescriptor getAssertingPartyMetadata() {
 204             return assertingPartyMetadata;
 205         }
 206
 207         /**
 208          * Sets the metadata for the asserting party.
 209          *
 210          * @param metadata metadata for the asserting party
 211          */
 212         public void setAssertingPartyMetadata(EntityDescriptor metadata) {
 213             assertingPartyMetadata = metadata;
 214         }
 215
 216         /**
 217          * Gets the role descriptor for the asserting party.
 218          *
 219          * @return role descriptor for the asserting party
 220          */
 221         public RoleDescriptor getAssertingPartyRoleMetadata() {
 222             return assertingPartyRoleMetadata;
 223         }
 224
 225         /**
 226          * Sets the role descriptor for the asserting party.
 227          *
 228          * @param descriptor role descriptor for the asserting party
 229          */
 230         public void setAssertingPartyRoleMetadata(RoleDescriptor descriptor) {
 231             assertingPartyRoleMetadata = descriptor;
 232         }
 233
 234         /**
 235          * Gets the URI of the message decoder used to decode the incoming request.
 236          *
 237          * @return URI of the message decoder used to decode the incoming request
 238          */
 239         public String getMessageDecoder(){
 240             return messageDecoder;
 241         }
 242
 243         /**
 244          * Sets the URI of the message decoder used to decode the incoming request.
 245          *
 246          * @param decoderURI URI of the message decoder used to decode the incoming request
 247          */
 248         public void setMessageDecoder(String decoderURI){
 249             messageDecoder = decoderURI;
 250         }
 251
 252         /**
 253          * Gets the URI of the message encoder used to encode the outgoing response.
 254          *
 255          * @return URI of the message encoder used to encode the outgoing response
 256          */
 257         public String getMessageEncoder(){
 258             return messageEncoder;
 259         }
 260
 261         /**
 262          * Sets the URI of the message encoder used to encode the outgoing response.
 263          *
 264          * @param encoderURI URI of the message encoder used to encode the outgoing response
 265          */
 266         public void setMessageEncoder(String encoderURI){
 267             messageEncoder = encoderURI;
 268         }
 269
 270         /**
 271          * Gets the relay state of the current request.
 272          *
 273          * @return relay state of the current request
 274          */
 275         public String getRelayState(){
 276             return relayState;
 277         }
 278
 279         /**
 280          * Sets the relay state of the current request.
 281          *
 282          * @param state relay state of the current request
 283          */
 284         public void setRelayState(String state){
 285             relayState = state;
 286         }
 287
 288         /**
 289          * Gets the endpoint for the relying party.
 290          *
 291          * @return endpoint for the relying party
 292          */
 293         public Endpoint getRelyingPartyEndpoint(){
 294             return relyingPartyEndpoint;
 295         }
 296
 297         /**
 298          * Sets the endpoint for the relying party.
 299          *
 300          * @param endpoint endpoint for the relying party
 301          */
 302         public void setRelyingPartyEndpoint(Endpoint endpoint){
 303             relyingPartyEndpoint = endpoint;
 304         }
 305
 306         /**
 307          * Gets the metadata for the relying party.
 308          *
 309          * @return metadata for the relying party
 310          */
 311         public EntityDescriptor getRelyingPartyMetadata() {
 312             return relyingPartyMetadata;
 313         }
 314
 315         /**
 316          * Sets the metadata for the relying party.
 317          *
 318          * @param metadata metadata for the relying party
 319          */
 320         public void setRelyingPartyMetadata(EntityDescriptor metadata) {
 321             relyingPartyMetadata = metadata;
 322         }
 323
 324         /**
 325          * Gets the role descriptor for the relying party.
 326          *
 327          * @return role descriptor for the relying party
 328          */
 329         public RoleDescriptor getRelyingPartyRoleMetadata() {
 330             return relyingPartyRoleMetadata;
 331         }
 332
 333         /**
 334          * Sets the role descriptor for the relying party.
 335          *
 336          * @param descriptor role descriptor for the relying party
 337          */
 338         public void setRelyingPartyRoleMetadata(RoleDescriptor descriptor) {
 339             relyingPartyRoleMetadata = descriptor;
 340         }
 341     }
 342 }