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 }