4c75e1d60fd7bae23c3fb37ac5d4d7ac357e7b7e
[java-idp.git] / 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 java.util.List;
20 import java.util.Map;
21
22 import javax.servlet.http.HttpServletRequest;
23
24 import org.opensaml.common.IdentifierGenerator;
25 import org.opensaml.common.binding.decoding.SAMLMessageDecoder;
26 import org.opensaml.common.binding.encoding.SAMLMessageEncoder;
27 import org.opensaml.saml2.metadata.Endpoint;
28 import org.opensaml.saml2.metadata.provider.MetadataProvider;
29 import org.opensaml.ws.message.encoder.MessageEncodingException;
30 import org.opensaml.ws.security.SecurityPolicyResolver;
31 import org.opensaml.ws.transport.InTransport;
32 import org.opensaml.ws.transport.http.HttpServletRequestAdapter;
33 import org.opensaml.xml.security.credential.Credential;
34 import org.slf4j.Logger;
35 import org.slf4j.LoggerFactory;
36
37 import edu.internet2.middleware.shibboleth.common.log.AuditLogEntry;
38 import edu.internet2.middleware.shibboleth.common.profile.ProfileException;
39 import edu.internet2.middleware.shibboleth.common.profile.provider.AbstractShibbolethProfileHandler;
40 import edu.internet2.middleware.shibboleth.common.profile.provider.BaseSAMLProfileRequestContext;
41 import edu.internet2.middleware.shibboleth.common.relyingparty.RelyingPartySecurityPolicyResolver;
42 import edu.internet2.middleware.shibboleth.common.relyingparty.provider.AbstractSAMLProfileConfiguration;
43 import edu.internet2.middleware.shibboleth.common.relyingparty.provider.CryptoOperationRequirementLevel;
44 import edu.internet2.middleware.shibboleth.common.relyingparty.provider.SAMLMDRelyingPartyConfigurationManager;
45 import edu.internet2.middleware.shibboleth.idp.session.Session;
46
47 /**
48  * Base class for SAML profile handlers.
49  */
50 public abstract class AbstractSAMLProfileHandler extends
51         AbstractShibbolethProfileHandler<SAMLMDRelyingPartyConfigurationManager, Session> {
52
53     /** SAML message audit log. */
54     private final Logger auditLog = LoggerFactory.getLogger(AuditLogEntry.AUDIT_LOGGER_NAME);
55
56     /** Class logger. */
57     private final Logger log = LoggerFactory.getLogger(AbstractSAMLProfileHandler.class);
58
59     /** Generator of IDs which may be used for SAML assertions, requests, etc. */
60     private IdentifierGenerator idGenerator;
61
62     /** All the SAML message decoders configured for the IdP. */
63     private Map<String, SAMLMessageDecoder> messageDecoders;
64
65     /** All the SAML message encoders configured for the IdP. */
66     private Map<String, SAMLMessageEncoder> messageEncoders;
67
68     /** SAML message binding used by inbound messages. */
69     private String inboundBinding;
70
71     /** SAML message bindings that may be used by outbound messages. */
72     private List<String> supportedOutboundBindings;
73
74     /** Resolver used to determine active security policy for an incoming request. */
75     private SecurityPolicyResolver securityPolicyResolver;
76
77     /** Constructor. */
78     protected AbstractSAMLProfileHandler() {
79         super();
80     }
81
82     /**
83      * Gets the resolver used to determine active security policy for an incoming request.
84      * 
85      * @return resolver used to determine active security policy for an incoming request
86      */
87     public SecurityPolicyResolver getSecurityPolicyResolver() {
88         if (securityPolicyResolver == null) {
89             setSecurityPolicyResolver(new RelyingPartySecurityPolicyResolver(getRelyingPartyConfigurationManager()));
90         }
91
92         return securityPolicyResolver;
93     }
94
95     /**
96      * Sets the resolver used to determine active security policy for an incoming request.
97      * 
98      * @param resolver resolver used to determine active security policy for an incoming request
99      */
100     public void setSecurityPolicyResolver(SecurityPolicyResolver resolver) {
101         securityPolicyResolver = resolver;
102     }
103
104     /**
105      * Gets the audit log for this handler.
106      * 
107      * @return audit log for this handler
108      */
109     protected Logger getAduitLog() {
110         return auditLog;
111     }
112
113     /**
114      * Gets an ID generator which may be used for SAML assertions, requests, etc.
115      * 
116      * @return ID generator
117      */
118     public IdentifierGenerator getIdGenerator() {
119         return idGenerator;
120     }
121
122     /**
123      * Gets the SAML message binding used by inbound messages.
124      * 
125      * @return SAML message binding used by inbound messages
126      */
127     public String getInboundBinding() {
128         return inboundBinding;
129     }
130
131     /**
132      * Gets all the SAML message decoders configured for the IdP indexed by SAML binding URI.
133      * 
134      * @return SAML message decoders configured for the IdP indexed by SAML binding URI
135      */
136     public Map<String, SAMLMessageDecoder> getMessageDecoders() {
137         return messageDecoders;
138     }
139
140     /**
141      * Gets all the SAML message encoders configured for the IdP indexed by SAML binding URI.
142      * 
143      * @return SAML message encoders configured for the IdP indexed by SAML binding URI
144      */
145     public Map<String, SAMLMessageEncoder> getMessageEncoders() {
146         return messageEncoders;
147     }
148
149     /**
150      * A convenience method for retrieving the SAML metadata provider from the relying party manager.
151      * 
152      * @return the metadata provider or null
153      */
154     public MetadataProvider getMetadataProvider() {
155         SAMLMDRelyingPartyConfigurationManager rpcManager = getRelyingPartyConfigurationManager();
156         if (rpcManager != null) {
157             return rpcManager.getMetadataProvider();
158         }
159
160         return null;
161     }
162
163     /**
164      * Gets the SAML message bindings that may be used by outbound messages.
165      * 
166      * @return SAML message bindings that may be used by outbound messages
167      */
168     public List<String> getSupportedOutboundBindings() {
169         return supportedOutboundBindings;
170     }
171
172     /**
173      * Gets the user's session, if there is one.
174      * 
175      * @param inTransport current inbound transport
176      * 
177      * @return user's session
178      */
179     protected Session getUserSession(InTransport inTransport) {
180         HttpServletRequest rawRequest = ((HttpServletRequestAdapter) inTransport).getWrappedRequest();
181         return (Session) rawRequest.getAttribute(Session.HTTP_SESSION_BINDING_ATTRIBUTE);
182     }
183
184     /**
185      * Gets an ID generator which may be used for SAML assertions, requests, etc.
186      * 
187      * @param generator an ID generator which may be used for SAML assertions, requests, etc
188      */
189     public void setIdGenerator(IdentifierGenerator generator) {
190         idGenerator = generator;
191     }
192
193     /**
194      * Sets the SAML message binding used by inbound messages.
195      * 
196      * @param binding SAML message binding used by inbound messages
197      */
198     public void setInboundBinding(String binding) {
199         inboundBinding = binding;
200     }
201
202     /**
203      * Sets all the SAML message decoders configured for the IdP indexed by SAML binding URI.
204      * 
205      * @param decoders SAML message decoders configured for the IdP indexed by SAML binding URI
206      */
207     public void setMessageDecoders(Map<String, SAMLMessageDecoder> decoders) {
208         messageDecoders = decoders;
209     }
210
211     /**
212      * Sets all the SAML message encoders configured for the IdP indexed by SAML binding URI.
213      * 
214      * @param encoders SAML message encoders configured for the IdP indexed by SAML binding URI
215      */
216     public void setMessageEncoders(Map<String, SAMLMessageEncoder> encoders) {
217         messageEncoders = encoders;
218     }
219
220     /**
221      * Sets the SAML message bindings that may be used by outbound messages.
222      * 
223      * @param bindings SAML message bindings that may be used by outbound messages
224      */
225     public void setSupportedOutboundBindings(List<String> bindings) {
226         supportedOutboundBindings = bindings;
227     }
228
229     /**
230      * Encodes the request's SAML response and writes it to the servlet response.
231      * 
232      * @param requestContext current request context
233      * 
234      * @throws ProfileException thrown if no message encoder is registered for this profiles binding
235      */
236     protected void encodeResponse(BaseSAMLProfileRequestContext requestContext) throws ProfileException {
237         try {
238
239             Endpoint peerEndpoint = requestContext.getPeerEntityEndpoint();
240             if (peerEndpoint == null) {
241                 log
242                         .error("No return endpoint available for relying party {}", requestContext
243                                 .getInboundMessageIssuer());
244                 throw new ProfileException("No peer endpoint available to which to send SAML response");
245             }
246
247             SAMLMessageEncoder encoder = getMessageEncoders().get(requestContext.getPeerEntityEndpoint().getBinding());
248             if (encoder == null) {
249                 log.error("No outbound message encoder configured for binding {}", requestContext
250                         .getPeerEntityEndpoint().getBinding());
251                 throw new ProfileException("No outbound message encoder configured for binding "
252                         + requestContext.getPeerEntityEndpoint().getBinding());
253             }
254
255             AbstractSAMLProfileConfiguration profileConfig = (AbstractSAMLProfileConfiguration) requestContext
256                     .getProfileConfiguration();
257             if (profileConfig.getSignResponses() == CryptoOperationRequirementLevel.always
258                     || (profileConfig.getSignResponses() == CryptoOperationRequirementLevel.conditional && !encoder
259                             .providesMessageIntegrity(requestContext))) {
260                 Credential signingCredential = null;
261                 if (profileConfig.getSigningCredential() != null) {
262                     signingCredential = profileConfig.getSigningCredential();
263                 } else if (requestContext.getRelyingPartyConfiguration().getDefaultSigningCredential() != null) {
264                     signingCredential = requestContext.getRelyingPartyConfiguration().getDefaultSigningCredential();
265                 }
266
267                 if (signingCredential == null) {
268                     throw new ProfileException(
269                             "Signing of responses is required but no signing credential is available");
270                 }
271
272                 requestContext.setOutboundSAMLMessageSigningCredential(signingCredential);
273             }
274
275             log.debug("Encoding response to SAML request {} from relying party {}", requestContext
276                     .getInboundSAMLMessageId(), requestContext.getInboundMessageIssuer());
277
278             requestContext.setMessageEncoder(encoder);
279             encoder.encode(requestContext);
280         } catch (MessageEncodingException e) {
281             throw new ProfileException("Unable to encode response to relying party: "
282                     + requestContext.getInboundMessageIssuer(), e);
283         }
284     }
285
286     /**
287      * Writes an aduit log entry indicating the successful response to the attribute request.
288      * 
289      * @param context current request context
290      */
291     protected void writeAuditLogEntry(BaseSAMLProfileRequestContext context) {
292         AuditLogEntry auditLogEntry = new AuditLogEntry();
293         auditLogEntry.setMessageProfile(getProfileId());
294         auditLogEntry.setPrincipalAuthenticationMethod(context.getPrincipalAuthenticationMethod());
295         auditLogEntry.setPrincipalName(context.getPrincipalName());
296         auditLogEntry.setAssertingPartyId(context.getLocalEntityId());
297         auditLogEntry.setRelyingPartyId(context.getInboundMessageIssuer());
298         auditLogEntry.setRequestBinding(context.getMessageDecoder().getBindingURI());
299         auditLogEntry.setRequestId(context.getInboundSAMLMessageId());
300         auditLogEntry.setResponseBinding(context.getMessageEncoder().getBindingURI());
301         auditLogEntry.setResponseId(context.getOutboundSAMLMessageId());
302         if (context.getReleasedAttributes() != null) {
303             auditLogEntry.getReleasedAttributes().addAll(context.getReleasedAttributes());
304         }
305
306         getAduitLog().info(auditLogEntry.toString());
307     }
308 }