first pass at authnmgr
[java-idp.git] / src / edu / internet2 / middleware / shibboleth / idp / authn / LoginContext.java
1 /*
2  * Copyright [2006] [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.authn;
18
19
20 import java.util.Map;
21 import javolution.util.FastMap;
22
23 import org.joda.time.DateTime;
24
25
26 /**
27  * Login context created by a profile handler and interpreted
28  * by the authentication package.
29  * 
30  * Two properties are tracked by default:
31  * 
32  * <code>forceAuth</code> - Should user authentiation be forced.
33  * <code>passiveAuth</code> - Should user authentication not control the UI.
34  * 
35  * A Map&lt;String, Object&gt; is provided to store other properties.
36  * Alternatively, a profile handler may create a subclass of LoginContext with
37  * extra fields.
38  *
39  * LoginContexts should be created by a profile handler when authentication is needed.
40  * Once control has returned to the profile handler, it should remove the LoginContext
41  * from the HttpSession.
42  *
43  * The {@link AuthenticationManager} or an {@link AuthenticationHandler} should set the
44  * {@link LoginContext#setAuthenticationAttempted()}, {@link LoginContext#setAuthnOK(boolean)},
45  * {@link LoginContext#setAuthnFailure(String)} appropriately.
46  *
47  */
48 public class LoginContext {
49     
50     /** the key in a HttpSession where login contexts are stored */
51     public static final String LOGIN_CONTEXT_KEY = "shib2.logincontext";
52     
53     
54     /** Should user authentication be forced */
55     private boolean forceAuth = false;
56     
57     /** Must authentication not interact with the UI */
58     private boolean passiveAuth = false;
59     
60     /** a catch-all map for other properties */
61     private Map<String, Object> propsMap = new FastMap<String, Object>();
62     
63     /** The ProfileHandler URL */
64     private String profileHandlerURL;
65     
66     /** The AuthenticationManager's URL */
67     private String authnManagerURL;
68     
69     /** has authentication been attempted yet */
70     private boolean authnAttempted = false;
71     
72     /** The id of the authenticated user */ 
73     private String userID;
74
75     /** Did authentication succceed? */
76     private boolean authenticationOK;
77     
78     /** Optional failure message  */
79     private String authnFailureMessage;
80
81     /** The instant of authentication */
82     private DateTime authnInstant;
83     
84     /** The duration of authentication */
85     private long authnDuration;
86     
87     /** The method used to authenticate the user */
88     private String authnMethod;        
89     
90     /** The session id */
91     private String sessionID;
92     
93     
94     /** Creates a new instance of LoginContext */
95     public LoginContext() {
96     }
97     
98     
99     /**
100      * Creates a new instance of LoginContext
101      *
102      * @param forceAuth if the authentication manager must reauth the user.
103      * @param passiveAuth if the authentication manager must not interact with the users UI. 
104      */
105     public LoginContext(boolean forceAuth, boolean passiveAuth) {
106         
107         this.forceAuth = forceAuth;
108         this.passiveAuth = passiveAuth;
109     }    
110     
111     
112     /**
113      * Returns if authentication must be forced.
114      *
115      * @return <code>true</code> if the authentication manager must reauth the user.
116      */
117     public boolean getForceAuth() {
118         return this.forceAuth;
119     }
120     
121     
122     /**
123      * Returns if authentication must be passive.
124      * 
125      * @return <code>true</code> if the authentication manager must not interact with the users UI.
126      */
127     public boolean getPassiveAuth() {
128         return this.passiveAuth;
129     }
130     
131     
132     /**
133      * Sets if authentication must be forced.
134      *
135      * @param forceAuth if the authentication manager must reauth the user.
136      */
137     public void setForceAuth(boolean forceAuth) {
138         this.forceAuth = forceAuth;
139     }
140     
141     
142     /**
143      * Sets if authentication must be passive.
144      * 
145      * @param passiveAuth if the authentication manager must not interact with the users UI.
146      */
147     public void setPassiveAuth(boolean passiveAuth) {
148         this.passiveAuth = passiveAuth;
149     }
150     
151     
152     /**
153      * Get an optional property object.
154      * 
155      * @param key The key in the properites Map.
156      * 
157      * @return The object, or <code>null</code> is no object exists for the key.
158      */
159     public Object getProperty(String key) {
160         return this.propsMap.get(key);
161     }
162     
163     
164     /**
165      * Sets an optional property object.
166      * 
167      * If an object is already associated with key, it will be overwritten.
168      * 
169      * @param key The key to set.
170      * @param obj The object to associate with key.
171      */
172     public void setProperty(String key, final Object obj) {
173         this.propsMap.put(key, obj);
174     }
175  
176     
177     /**
178      * Sets if authentication succeeded.
179      * 
180      * @param authnOK if authentication succeeded;
181      */
182     public void setAuthnOK(boolean authnOK) {
183         this.authenticationOK = authnOK;
184     }
185     
186     
187     /**
188      * Returns if authentication succeeded.
189      * 
190      * @return <code>true</code> is the user was successfully authenticated.
191      */
192     public boolean getAuthnOK() {
193         return this.authenticationOK;
194     }
195     
196     
197     /** Sets the optional authentication failure message.
198      * 
199      * @param failureMessage A description of why authN failed.
200      */ 
201     public void setAuthnFailureMessage(String failureMessage) {
202         this.authnFailureMessage = failureMessage;
203     }
204     
205     
206     /**
207      * Returns the optional authentication failure message.
208      * 
209      * @return The failure message, or <code>null</code> is none was set.
210      */
211     public String getAuthnFailureMessage() {
212         return this.authnFailureMessage;
213     }
214     
215     
216     /**
217      * Set if authentication has been attempted.
218      *
219      * This method should be called by an {@link AuthenticationHandler} 
220      * while processing a request.
221      */
222     public void setAuthenticationAttempted() {
223         this.authnAttempted = true;
224     }
225     
226     
227     /**
228      * Returns if authentication has been attempted for this user.
229      */
230     public boolean getAuthenticationAttempted() {
231         return this.authnAttempted;
232     }
233     
234     
235     /**
236      * Sets the ID of the authenticated user.
237      * 
238      * @param userID The userid.
239      */
240     public void setUserID(String userID) {
241         this.userID = userID;
242     }
243     
244     
245     /**
246      * Returns the ID of the authenticated user.
247      * 
248      * @return the ID of the user, or <code>null</code> if authentication failed.
249      */
250     public String getUserID() {
251         return this.userID;
252     }
253     
254     
255     /**
256      * Gets the ProfileHandler URL.
257      *
258      * @return the URL of the profile handler that is invoking the Authentication Manager.
259      */
260     public String getProfileHandlerURL() {
261         return this.profileHandlerURL;
262     }
263     
264     
265     /**
266      * Sets the ProfileHandler URL.
267      *
268      * @param profileHandlerURL The URL of the profile handler that invoked the AuthenticationManager/
269      */
270     public void setProfileHandlerURL(String profileHandlerURL) {
271         this.profileHandlerURL = profileHandlerURL;
272     }
273     
274     
275     /**
276      * Gets the AuthenticationManager URL.
277      *
278      * @return the URL of the AuthenticationManager.
279      */
280     public String getAuthnManagerURL() {
281         return this.authnManagerURL;
282     }
283     
284     
285     /**
286      * Sets the AuthenticationManager's URL.
287      *
288      * @param authnManagerURL the URL of the AuthenticationManager.
289      */
290     public void setAuthnManagerURL(String authnManagerURL) {
291         this.authnManagerURL = authnManagerURL;
292     }
293     
294     
295     /**
296      * Gets the authentication instant.
297      *
298      * @return The instant of authentication, or <code>null</code> if none was set.
299      */
300     public DateTime getAuthenticationInstant() {
301             return this.authnInstant;
302     }
303     
304     
305     /**
306      * Sets the authentication instant.
307      *
308      * @param authnInstant The instant of authentication.
309      */
310     public void setAuthenticationInstant(final DateTime authnInstant) {
311         this.authnInstant = authnInstant;
312     }
313     
314     
315     /**
316      * Gets the duration of authentication.
317      *
318      * @return The duration of authentication, or zero if none was set.
319      */
320     public long getAuthenticationDuration() {
321         return this.authnDuration;
322     }
323     
324     
325     /**
326      * Sets the duration of authentication.
327      *
328      * @param authnDuration The duration of authentication.
329      */
330     public void setAuthenticationDuration(long authnDuration) {
331         this.authnDuration = authnDuration;
332     }
333     
334     
335     /**
336      * Gets the method used to authenticate the user.
337      *
338      * @return The method used to authenticate the user.
339      */
340     public String getAuthenticationMethod() {
341         return this.authnMethod;
342     }
343     
344     
345     /**
346      * Sets the method used to authenticate the user.
347      *
348      * @param authnMethod The method used to authenticate the user.
349      */
350     public void setAuthenticationMethod(String authnMethod) {
351         this.authnMethod = authnMethod;
352     }
353     
354     
355     /**
356      * Gets the {@link Session} ID
357      *
358      * @return the Session id.
359      */
360     public String getSessionID() {
361         return this.sessionID;
362     }
363     
364     
365     /**
366      * Sets the {@link Session} ID
367      *
368      * @param sessionID the Session ID
369      */
370     public void setSessionID(String sessionID) {
371         this.sessionID = sessionID;
372     }
373 }