.NET Authenticator with Single Sign-On Support

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using com.atlassian.crowd.integration.http;

/// <summary>
/// Class containing functionality to check authentication status and retrieve principal data
/// Engineered from BaseAction.Java in Demo Crowd Application
/// </summary>
public class BaseAction
{
    #region Private Properties

    private static bool? _authenticated = null;
    private static SOAPPrincipal _principal = null;

    #endregion

    #region Constants

    // Principal attributes - these are currently hard-coded
    private const string FIRSTNAME = "givenName";
    private const string LASTNAME = "sn";
    private const string LASTAUTHENTICATED = "lastAuthenticated";

    #endregion

    #region Constructors

    static BaseAction()
	{
		//
		// TODO: Add constructor logic here
		//
    }

    #endregion

    #region Accessors

    /// <summary>
    /// Accessor which determines if the last call to IsAuthenticated succeeded
    /// </summary>
    public static bool Authenticated
    {
        get
        {
            return Convert.ToBoolean(_authenticated);
        }
    }

    /// <summary>
    ///  Accessor for HttpRequest
    /// </summary>
    private static HttpRequest Request
    {
        get
        {
            return HttpContext.Current.Request;
        }
    }

    /// <summary>
    /// Accessor for HttpResponse
    /// </summary>
    private static HttpResponse Response
    {
        get
        {
            return HttpContext.Current.Response;
        }
    }

    #endregion

    /// <summary>
    /// Checks if a principal is currently authenticated versus the Crowd Security Server.
    /// </summary>
    /// <returns>TRUE if the principal is authenticated, FALSE otherwise</returns>
    public static bool isAuthenticated()
    {
        try
        {
            _authenticated = HttpAuthenticator.isAuthenticated(Request, Response);
        }
        catch (Exception)
        {
            _authenticated = false;
        }

        return Convert.ToBoolean(_authenticated);
    }

    /// <summary>
    /// Retrieves the full name of the authenticated principal
    /// </summary>
    /// <returns>Full name of the authenticated principal</returns>
    /// <remarks>Throws InvalidPrincipalException</remarks>
    public static string getPrincipalName()
    {
        if (!isAuthenticated())
            return null;

        string principalName = String.Empty;

        if (getPrincipal() != null)
        {
            // Get first and last name of the principal
            string firstName = getFirstAttribute(FIRSTNAME);
            string lastName = getFirstAttribute(LASTNAME);

            if (!String.IsNullOrEmpty(firstName))
            {
                principalName = firstName;
            }

            if (!String.IsNullOrEmpty(lastName))
            {
                if (!String.IsNullOrEmpty(principalName) && principalName.Length > 0)
                    principalName += " ";

                principalName += lastName;
            }

            if (String.IsNullOrEmpty(principalName))
                principalName = getPrincipal().name;
        }

        return principalName;
    }

    /// <summary>
    /// Retrieves the Date and Time of the last authentication of the currently authenticated user
    /// </summary>
    /// <returns>DateTime of the authentication</returns>
    /// <remarks>Throws InvalidPrincipalException</remarks>
    public static DateTime getLastAuthenticated()
    {
        DateTime lastAuthenticated = DateTime.MinValue;

        if (isAuthenticated() && (getPrincipal() != null))
        {
            // Get the number of milliseconds since 1970
            string millis = getFirstAttribute(LASTAUTHENTICATED);

            if (!String.IsNullOrEmpty(millis))
            {
                // Convert from Java milliseconds
                DateTime javaEpoch = new DateTime(1970, 1, 1);
                lastAuthenticated = javaEpoch.AddMilliseconds(Convert.ToInt64(millis));
            }
        }

        return lastAuthenticated;
    }

    /// <summary>
    /// Retrieve the attribute with the given name
    /// </summary>
    /// <param name="name">Name of the attribute</param>
    /// <returns>Value of the principal attribute, of String.Empty if not found</returns>
    /// <remarks>Throws InvalidPrincipalException</remarks>
    public static string getFirstAttribute(string name)
    {
        string attributeValue = String.Empty;

        try
        {
            SOAPAttribute attribute = getAttribute(name);

            if ((attribute != null) &&
                (attribute.name != null) &&
                (attribute.values.Length > 0))
                attributeValue = attribute.values[0];
        }
        catch (Exception)
        {
            // Attribute cannot be found
        }

        return attributeValue;
    }

    /// <summary>
    /// Gets the currently authenticated principal
    /// </summary>
    /// <returns>SOAPPrincipal of the currently authenticated principal</returns>
    /// <remarks>Throws InvalidPrincipalException</remarks>
    public static SOAPPrincipal getPrincipal()
    {
        if (!isAuthenticated())
            return null;

        if (_principal == null)
        {

            try
            {
                // find the authenticated principal from the token
                _principal = HttpAuthenticator.getPrincipal(Request);
            }
            catch (Exception)
            {
                throw;
            }
        }

        return _principal;
    }

    /// <summary>
    /// Gets a principal attribute by name
    /// </summary>
    /// <param name="name">Name of the attribute</param>
    /// <returns>Value of the attribute</returns>
    /// <remarks>Throws InvalidPrincipalException</remarks>
    public static SOAPAttribute getAttribute(string name)
    {
        if (!isAuthenticated())
        {
            return null;
        }

        SOAPPrincipal remotePrincipal = getPrincipal();

        SOAPAttribute[] attributes = _principal.attributes;

        for (int i = 0; i < attributes.Length; i++)
        {
            if (attributes[i].name.Equals(name))
            {
                // Retrieve the value
                return attributes[i];
            }
        }

        // unable to find the attribute, return a new empty one.
        SOAPAttribute soapAttribute = new SOAPAttribute();
        soapAttribute.name = name;

        return soapAttribute;
    }
}

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using com.atlassian.crowd.integration.http;

/// <summary>
/// Class containing functionality to authenticate the principal
/// Engineered from Login.Java in Demo Crowd Application
/// </summary>
public class Login
{
    #region Private Properties

    // User Credentials for Authentication
    private static string _username = null;
    private static string _password = null;

    #endregion

    #region Constructors

    static Login()
    {
        //
        // TODO: Add constructor logic here
        //
    }

    #endregion

    #region Accessors

    // Accessor for HttpRequest
    private static HttpRequest Request
    {
        get
        {
            return HttpContext.Current.Request;
        }
    }

    // Accessor for HttpResponse
    private static HttpResponse Response
    {
        get
        {
            return HttpContext.Current.Response;
        }
    }

    // Accessor for UserName
    public static string UserName
    {
        get
        {
            return _username;
        }
        set
        {
            _username = value;
        }
    }

    // Accessor for Password
    public static string Password
    {
        get
        {
            return _password;
        }
        set
        {
            _password = value;
        }
    }

    #endregion

    /// <summary>
    /// Attempts to authenticate the principal and log-in to the Crowd Application.
    /// Also sets appropriate cookie token and session variables for SSO.
    /// </summary>
    /// <returns>TRUE if successfully authenticated, FALSE otherwise</returns>
    public static bool Execute()
    {
        bool authenticated = false;

        if (_username != null && !String.IsNullOrEmpty(_username) && _password != null)
        {
            // Attempt authentication
            HttpAuthenticator.authenticate(Request, Response, _username, _password);
            authenticated = true;
        }
        else
        {
            // Didn't supply authentication information, so check if already authenticated
            authenticated = BaseAction.isAuthenticated();
        }

        return authenticated;
    }
}