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