[0001] The invention relates generally to communication networks, and more particularly to passive client single sign-on for Web applications.
[0002] The Web programming model makes it possible to build and deploy Web applications incrementally and in a decentralized manner. The Web programming model is considered “loosely coupled” and provides Web applications having a high degree of interoperability, scalability, and manageability. Generally, Web applications operate with at least a passive client that understands both HTTP and HTML, such as a Web browser. Examples of Web applications include e-commerce web sites such as www.microsoft.com and www.amazon.com.
[0003] In contrast, Web services adapt the loosely coupled Web programming model for use in services that do not require a visual UI (“user interface”) (e.g., do not require a browser). Web services typically incorporate some combination of programming, data and (possibly) human resources to provide services made available from an organization's Web server to other Web-connected programs. Exemplary Web services may include major services, such as storage management and customer relationship management (CRM), down to much more limited services, such as online stock quotations and online bidding for an auction item.
[0004] Some features of a Web application are openly available to any user visiting a Web site. For example, the Amazon web site provides a catalog-type feature without strict authentication and authorization mechanisms. However, other features of a Web application may require that a user be authenticated before receiving access. For example, the Amazon web site requires authentication before a user is able to check the status of an order or to change payment information. Likewise, accessing a user's online email account provided by a Web email application requires logon information to authenticate the user.
[0005] Many users typically employ Web applications through many different sites. In many circumstances, each individual Web application requires the user to individually authenticate before access to a secure Web application feature is granted. For most Web applications, such authentication is performed via a custom authentication protocol based on posting a user's name and password for each Web application accessed.
[0006] In other circumstances, multiple Web applications provided by an individual organization (e.g., multiple Web sites provided by Amazon) may share authentication information, policies, and protocols to provide a Single Sign-On (SSO) or Single Sign-In (SSI) facility throughout that organization. As such, a user need only login once in a single session to one Web application of a given organization, and the user can be automatically or transparently authenticated for access to any other Web application provided by that organization.
[0007] However, when a user wishes to employ Web applications from multiple, independent organizations, individual logins are typically still required for each organization, a limitation which detracts from the desired convenience and seamless access potentially expected of Web applications. This is particularly true when the user is accessing a Web application in another organization through a passive client device, such as a client computer running a browser.
[0008] Implementations described and claimed herein address the foregoing problems by providing a system supporting single sign-on capabilities for accessing a Web application through a passive client across different realms within a federation. A federation refers to different organizations (e.g., different autonomous identity domains or realms) that have employed agreements, standards, and/or cooperative technologies to make user identity and entitlements portable between the organizations. In this manner, a user of one realm can access a Web application of a different realm without multiple logon events.
[0009] In some implementations, articles of manufacture are provided as computer program products. One implementation of a computer program product provides a computer program storage medium readable by a computer system and encoding a computer program that authenticates a user. Another implementation of a computer program product may be provided in a computer data signal embodied in a carrier wave by a computing system and encoding the computer program that authenticates a user.
[0010] The computer program product encodes a computer program for executing on a computer system a computer process for authenticating a user. A resource challenge is received from a resource server of a resource realm through a Web-based client of an account realm. The resource challenge is generated responsive to a request for access to a Web application provided by the resource server. The resource realm and the account realm share a trust policy in a federation. A security token service challenge is sent to an account security token service module of the account realm through the Web-based client, responsive to receiving the resource challenge. An account security token received from the account security token service module through the Web-based client is verified, responsive to the sending of the security token service challenge. The account security token is formatted in accordance with the trust policy in the federation. A resource security token generated by the resource security token service module through the Web-based client is sent to the resource server to authenticate the user for access to the Web application, responsive to verifying the account security token.
[0011] In another implementation, a method of authenticating a user is provided. A resource challenge is received from a resource server of a resource realm through a Web-based client of an account realm. The resource challenge is generated responsive to a request for access to a Web application provided by the resource server. The resource realm and the account realm share a trust policy in a federation. A security token service challenge is sent to an account security token service module of the account realm through the Web-based client, responsive to receiving the resource challenge. An account security token received from the account security token service module through the Web-based client is verified, responsive to the sending of the security token service challenge. The account security token is formatted in accordance with the trust policy in the federation. A resource security token generated by the resource security token service module through the Web-based client is sent to the resource server to authenticate the user for access to the Web application, responsive to verifying the account security token.
[0012] In yet another implementation, a system for authenticating a user is provided. A Web-based client in an account realm generates a request for access to a Web application provided by a resource server of a resource realm, wherein the account realm and the resource realm share a trust policy in a federation. The resource server sends a resource challenge through the Web-based client to a resource security token service module of the resource realm. The resource challenge is generated by the resource server responsive to the request. The request is received through the Web-based client from a user of the account realm. The resource security token service module generates a security token service challenge, responsive to receipt of the resource challenge. An account security token service module of the account realm receives the security token service challenge from the resource security token service through the Web-based client and generates an account security token in accordance with the trust policy in the federation. The resource security token service module verifies the account security token received from the account security token service of the account realm through the Web-based client and generates a resource security token. The resource server verifies the resource security token generated by the resource security token service module to authenticate the user for access to the Web application.
[0013] Other implementations are also described and recited herein.
[0014]
[0015]
[0016]
[0017]
[0018] Single sign-on capabilities for accessing a Web application through a passive client across multiple realms within a federation are described.
[0019]
[0020] It should also be understood that at least in one implementation, a mechanism for carrying GXA formatted messages (such as security tokens defined in WS-Security and RST and RSTR messages defined in WS-Trust) is provided. Thus, Web applications can utilize the same security infrastructure as Web services. Alternatively, applications that use passive clients can use the same security infrastructure as applications that use active/rich clients.
[0021] The STS module
[0022] It should be understood that the user at client
[0023] The organization B
[0024] The organization A
[0025] As an example of a single sign-on, a user associated with the organization A
[0026] The organizations are often termed “realms” in the federation context. An entity may be a member of a realm by sharing a symmetric key with the STS of that realm or trusting signatures created with the STS private key of that realm. A trust policy is established between two realms in a federation to enable the sharing of keys or the trusting of each other's signatures.
[0027]
[0028] The STS module
[0029] The organization B
[0030] In one implementation, the user requests access to the resource server
[0031] The logon server
[0032] The federation server
[0033] The message flow described above is merely exemplary. Other message flows are also contemplated. For example, the client of organization A, responsive to a detected configuration state, may obtain security token before attempting to access the target Web application in organization B.
[0034] Regarding authentication policies, a policy URI references the authentication preferences for the authentication requester, such as the target application. Exemplary policy values may include the requested security token type, security token lifetime, identity properties request, required authentication strength (e.g., request login with biometric device), etc. Policies may be used in accordance with the following rules:
[0035] Each STS defines schema details for the policies it supports (e.g., trust specific property definitions).
[0036] Each resource specifies policy URIs it is willing to accept when joining a realm.
[0037] If a realm participates in a relationship with another realm (e.g., a federation), the realms share a trust policy.
[0038] A policy defines a preference. The recipient of a security token verifies that the token's contents reflect the applicable policy.
[0039] An exemplary policy for a realm is shown:
<authPolicy> <forceSignin>true</ForceSignin> <timeToLive>60</TimeToLive> <tokenType>SAML</TokenType> </AuthPolicy>
[0040] An exemplary policy schema is also shown:
<?xml version=“1.0” encoding=“utf-8” ?> <xs:schema targetNamespace= http://schemas.microsoft.com/Passport/PolicySchema elementFormDefault=“qualified” xmlns=“http://schemas.microsoft.com/Passport/PolicySchema
xmlns:xs=“http://www.w3.org/2001/XMLSchema” xmlns:wsse=“http://schemas.xmlsoap.org/ws/2002/02/secext
> <xs:complexType name=“AuthPolicy”> <xs:sequence> <xs:element name=“noUI” type=“NoUI” minOccurs=“0”/> <xs:element name=“forceSignin” type=“ForceSignin” minOccurs=“0”/> <xs:element name=“timeToLive” type=“TimeToLive” minOccurs=“0”/> <xs:element name=“tokenType” type=“TokenType” minOccurs=“0”/> <xs:element name=“targetKeyType” type= “TargetKeyType” minOccurs=“0”/> <xs:element name=“requestedAuthType” type=“RequestedAuthType” minOccurs=“0”/> </xs:sequence> </xs:complexType> <xs:simpleType name=“NoUI”> <xs:annotation> <xs:documentation> Specifies whether or not STS UI should be displayed if user is not authenticated </xs:documentation> </xs:annotation> <xs:restriction base=“xs:boolean” /> </xs:simpleType> <xs:simpleType name=“ForceSignin”> <xs:annotation> <xs:documentation> Boolean specifying whether to renew ticket automatically or ask for credentials </xs:documentation> </xs:annotation> <xs:restriction base=“xs:boolean” /> </xs:simpleType> <xs:simpleType name=“TimeToLive”> <xs:annotation> <xs:documentation> This policy value defines requested lifetime of the token </xs:documentation> </xs:annotation> <xs:restriction base=“xs:decimal” /> </xs:simpleType> <xs:simpleType name=“TokenType”> <xs:annotation> <xs:documentation> Token type requested by the partner site. These are for now Saml assertions or passport tickets </xs:documentation> </xs:annotation> <xs:restriction base=“xs:string”> <xs:enumeration value=“SAML” /> <xs:enumeration value=“Passport” /> </xs:restriction> </xs:simpleType> <xs:simpleType name=“TargetKeyType”> <xs:annotation> <xs:documentation> what key to use to encrypt Partner's token. See wsse for key types. The usage is different than RequestKeyType in RST. </xs:documentation> </xs:annotation> <xs:restriction base=“xs:string”/> </xs:simpleType> <xs:simpleType name=“RequestedAuthType”> <xs:annotation> <xs:documentation> Authentication type requested. Optional. Allowed types are password auth, client cert and password + PIN </xs:documentation> </xs:annotation> <xs:restriction base=“xs:anyURI”> <xs:enumeration value=“urn:passport:names:password” /> <xs:enumeration value=“urn:ietf:rfc:2246” /> <xs:enumeration value=“urn:passport:names:passwordpin” /> </xs:restriction> </xs:simpleType> <xs:element name=“authPolicy” type=“AuthPolicy”/> </xs:schema>
[0041]
[0042] A resource request
[0043] Not having appropriate authentication information for the user to grant access to the Web application, the resource server
[0044] 302 Found
[0045] Location: <Resource STS URL>?<QS parameters>
[0046] where <Resource STS URL> identifies the location of the resource STS module
Wa Indicating the requested action, WREQ, or login request for the resource. wru Indicating the return URL (Uniform Resource Locator), which is where the resource STS sends the security token or error information. The return URL is in the resource DNS domain. If omitted, a default URL for the resource is used. wp Indicating the policy URI (Uniform Resource Identifier) that identifies the policy to be used for authentication in the organization B. wct Indicating the current time at the resource server when it challenges for authentication (e.g., in the canonical representation of dateTime from [XML-Schema2]).
[0047] In an alternative implementation, the resource challenge may be performed using a POST through the client browser. An exemplary POST is shown below:
<form action=<Resource STS URL>> <input type=hidden name=”wa” value=“WREQv1.0”> <input type=hidden name=”wru” value=<return URL>> <input type=hidden name=”wp” value=<policy URI>> <input type=hidden name=”wct” value=<current time>> </form>
[0048] In one implementation, secure HTTPs URLs are used to identify STS modules. The passive client
[0049] If the user is not already authenticated within organization B, the resource STS module
[0050] If the user is not a member of organization B's realm, the resource STS module
[0051] 302 Found
[0052] Location: <Account STS URL>?<QS parameters>
[0053] where <Account STS URL> identifies the location of the account STS module
wa Indicating the requested action, LREQ, or login request for the resource. In this case, the request is for a client login to a foreign realm. wrr Indicating the name of the resource realm (i.e., the realm of the entity that is requesting the login). Wri Indicating the resource information that is to be returned to the resource STS. This parameter is a pass-through parameter that is returned in the response and is not processed by the account STS. Wtp Identifying the trust policy URI. Indicates preferences for the token to be issued to the resource STS. Wct Indicating the current time at the resource server when it challenges for authentication (e.g., in the canonical representation of dateTime from [XML-Schema2]).
[0054] In an alternative implementation, the STS challenge may be performed using a POST through the client browser. An exemplary POST is shown below:
<form action=<resource STS URL>> <input type=hidden name=”wa” value=”LREQv1.0”> <input type=hidden name=”wrr” value=<resource realm>> <input type=hidden name=”wri” value=<resource information>> <input type=hidden name=”wtp” value=<policy URI>> <input type=hidden name=”wct” value=<current time>> </form>
[0055] The passive client
[0056] If the user is not already authenticated by the account STS module
[0057] The account security token is returned to the resource STS module
<form action=<resource STS URL>> <input type=hidden name=”wtoken” value=<account security token >> <input type=hidden name=”wrri” value=<resource information>> </form>
[0058] The POST may be automated via a client-side intermediate language script. The account security token may be, for example, a base64 encoded XML document. The <resource information> includes the “wri” parameter in the query string of the STS challenge. The account STS module
[0059] A security token may take many forms, although returned security tokens are encrypted. An exemplary format for a security token is shown below using a recipient's public key to encrypt the security token:
<wsse:Security> <!-- encrypted token for the message --> <EncryptedData Id=“Token” xmlns=“http://www.w3.org/2001/04/xmlenc#” Type=“http://www.w3.org/2001/04/xmlenc#Element”> <!-- encryption key is AES --> <EncryptionMethod Algorithm=“http://www.w3.org/2001/04/ xmlenc#aes256-cbc”/> <ds:KeyInfo xmlns:ds=‘http://www.w3.org/2000/09/xmldsig#> <!-- the key is provided encrypted --> <EncryptedKey ID=“EK”> <EncryptionMethod Algorithm=“http://www.w3.org/2001/04/xmlenc#rsa-oaep-mg
f1p”/> <ds:KeyInfo> <ds:X509Data> <ds:X509SKI>123456...</ds:X509SKI> </ds:X509Data> </ds:KeyInfo> <CipherData> <CipherValue> encryptedkeybase64encoded </CipherValue> </CipherData> </EncryptedKey> </ds:KeyInfo> <CipherData> <CipherValue>EncryptedToken</CipherValue> </CipherData> </EncryptedData> </wsse:Security>
[0060] In one implementation, the account security token is defined in the form of a SAML (Security Assertion Markup Language) assertion and a public key signature. SAML is an XML-based framework for ensuring that transmitted communications are secure and defines mechanisms to exchange authentication, authorization, and non-repudiation information. Exemplary security token data in the form of a SAML assertion and a public key signature is shown (after decryption):
<saml:Assertion MajorVersion=“1” MinorVersion=“0” AssertionID=“1234567890987654321-10-29-02” Issuer=“Sample” IssueInstant=“2002-10-29T09:00:00-08:00” xsi:schemaLocation=” urn:oasis:names:tc:SAML:1.0:assertion file:///c:\InfoModel\SAML\ cs-sstc-schema- assertion-01.xsd” xmlns:xsi=“http://www.w3.org/2001/ XMLSchema-instance” xmlns:saml=“urn:oasis:names:tc:SAML:1.0:assertion”> <!-- validity interval for the token --> <saml:Conditions NotBefore=xxxx NotOnOrAfter=xxxx> <!-- recipient name --> <saml:AudienceRestrictionCondition> <saml:Audience>resourcerealm.com</saml:Audience>
</saml:AudienceRestrictionCondition> </saml:Conditions> <saml:AuthenticationStatement AuthenticationMethod= “urn:oasis:names:tc:SAML:1.0:am:password” AuthenticationInstant=xxx/> <saml:AttributeStatement> <saml:Subject> <saml:SubjectConfirmation> <saml:ConfirmationMethod> urn:oasis:names:tc:SAML:1.0:cm:sender-vouches <\saml:ConfirmationMethod> </saml:SubjectConfirmation> <!-- this is the unique name for the client --> <saml:NameIdentifier Format=“#emailAddress”> user@accountrealm.com </saml:NameIdentifier> </saml:Subject> ... </saml:AttributeStatement> </saml:Assertion> <ds:Signature xmlns:ds=“http://www.w3.org/2000/09/xmldsig#”> <ds:SignedInfo> <ds:CanonicalizationMethod Algorithm=“http://www.w3.org/TR/2001/REC-xml-c14n- 20010315”/> <ds:SignatureMethod Algorithm=“http://www.w3.org/2000/09/xmldsig#rsa-sha1”/&
gt; <ds:Reference URI=“”> <ds:Transforms> <ds:Transform Algorithm=“http://www.w3.org/TR/2001/REC-xpath-1999111”&
gt; <XPath>//saml:Assertion[1]</XPath> </ds:Transform> <ds:Transform Algorithm=“http://www.w3.org/TR/2001/ REC-xml-c14n-20010315”/> </ds:Transforms> <ds:DigestMethod Algorithm=“http://www.w3.org/2000/09/xmldsig#sha1”/> <ds:DigestValue>digest of transform</DigestValue> </ds:Reference> </ds:SignedInfo> <ds:SignatureValue> encryptthehashwiththesigkey </SignatureValue> <ds:KeyInfo> <ds:X509Data> <ds:X509SKI>123456...</ds:X509SKI> </ds:X509Data> </KeyInfo> </ds:Signature>
[0061] Other token formats may also be defined. Possible properties of security tokens are listed below:
[0062] Security tokens contain signature of the issuing authority over the whole token. This is the “signature” element over the SAML assertion above.
[0063] Security tokens contain a subject identifier uniquely identifying the entity for which the security token was granted. The SAML assertions used assure the identifiers issued are unique across the realms. The originating realm of a given security token is derivable from the subject identifier.
[0064] Security tokens contain a recipient identifier, such as the “Audience Restriction” element in the SAML assertion above.
[0065] Security tokens contain the time of initial authentication, validity interval, and the type of authentication that was performed. The validity of the SAML assertion is satisfied by the “NotBefore” and NotOnOrAfter” Attributes of the “Conditions” element. The initial authentication type and time are covered by the attributes of the “AuthenticationStatement” element.
[0066] Security tokens contain identity information, provided schema describing the additional identify information is understood by the recipient.
[0067] Security tokens are sent over a secure connection and are encrypted with the recipient's public key known to the STS.
[0068] Upon receipt of message
[0069] If the account security token is verified successfully, the resource STS module
<form action=<resource server URL>> <input type=hidden name=”wt” value=<resource security token>> </form>
[0070] where the <resource server URL> identifies the location of the resource server and, in one implementation, the <resource security token> includes a base64-encoded XML document. The resource STS module
[0071] Upon receipt of message
[0072] In the course of message exchange between entities in the network, cookies may have been set to record the user's authentication state. A logout process provides mechanism to delete the cookies for all visited resources and STS servers. One implementation of a logout process is performed in accordance with the following rules:
[0073] Each STS provides a logout URL.
[0074] Each resource provides a logout URL.
[0075] Each STS keeps track of resources for which it issues security tokens.
[0076] Each STS keeps track of trusting realms for which it has issued security tokens.
[0077] Each STS keeps track of trusted realms from which it has received security tokens.
[0078] A logout is initiated when an STS logout URL is accessed. In response, the authentication cookies for that STS are deleted and the logout URLs for all recorded visited resources, trusting realms, and trusting realms are accessed, causing deletion of authentication state cookies on those entities. By this protocol, the logout mechanism is extended to include federations.
[0079] An exemplary structure of a security token is shown below, although other structures are also contemplated. The structure represents a security token from a resource STS to a resource server when a symmetric key is shared between those two entities for authentication purposes.
<wsse:Security> <!-- encrypted token for the message --> <!-- encrypted for resource web server --> <EncryptedData Id=“EncryptedWSToken” xmlns=“http://www.w3.org/2001/04/xmlenc#” Type=“http://www.w3.org/2001/04/xmlenc#Element”> <EncryptionMethod Algorithm=“http://www.w3.org/2001/04/xmlenc#aes256-cbc”/
> <ds:KeyInfo> <!-- the key is derived from the shared key --> <wsse:DerivedKeyToken ID=“” wsse:Algorithm=“ http://www.w3.org/2000/09/xmldsig#hmac-sha1”> <SecurityTokenReference> <!-- refers to the key shared between STS-R and WS-R --> <Reference URI=“#SharedKey”/> </SecurityTokenReference> <Properties> <Label>FederationSTS-WSEncKey</Label> <Nonce>321...</Nonce> </Properties> <Generation>1</Generation> </wsse:DerivedKeyToken> </ds:KeyInfo> <CipherData> <CipherValue>EncryptedWSToken</CipherValue> </CipherData> </EncryptedData> </wsse:Security>
[0080] If there is no pre-negotiated shared key, the security token can be sent as an encrypted (with public key) key. Also if the security token travels over SSL connections in its entire path, the security token does not have to be (but still can be) encrypted at all. Encryption requirements can be set via policy. The basis of trust is the signature in the token.
[0081] The exemplary hardware and operating environment of
[0082] The system bus
[0083] The hard disk drive
[0084] A number of program modules may be stored on the hard disk, magnetic disk
[0085] The computer
[0086] When used in a LAN-networking environment, the computer
[0087] In an exemplary implementation, STS modules, resource servers, client modules, federation servers, logon servers and other modules may be incorporated as part of the operating system
[0088] The embodiments of the invention described herein are implemented as logical steps in one or more computer systems. The logical operations of the present invention are implemented (1) as a sequence of processor-implemented steps executing in one or more computer systems and (2) as interconnected machine modules within one or more computer systems. The implementation is a matter of choice, dependent on the performance requirements of the computer system implementing the invention. Accordingly, the logical operations making up the embodiments of the invention described herein are referred to variously as operations, steps, objects, or modules.
[0089] The above specification, examples and data provide a complete description of the structure and use of exemplary embodiments of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended.