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