RFC 6595
A Simple Authentication and Security Layer (SASL) and GSS-API Mechanism for the Security Assertion Markup Language (SAML)
RFC 6595: A Simple Authentication and Security Layer (SASL) and GSS-API Mechanism for the Security Assertion Markup Language (SAML) 🎀
Organization: Internet Engineering Task Force (IETF) 🌸 Authors: K. Wierenga (Cisco Systems, Inc.), E. Lear (Cisco Systems GmbH), S. Josefsson (SJD AB) 🫶 Category: Standards Track 👑 ISSN: 2070-1721 Date: April 2012 📅 Obsoletes / Updates: Nothing. This RFC doesn't list any Obsoletes or Updates. 🦋
Abstract ✨
Okay so SAML has totally taken over Web Single Sign-On on the Internet 💅. SASL and GSS-API are application frameworks that generalize authentication, and this memo specifies a SASL mechanism and a GSS-API mechanism for SAML 2.0. That means existing SAML Identity Providers can plug right into apps that use SASL and GSS-API 🔥.
Status of This Memo 📜
This is an Internet Standards Track document.
This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). For more on Internet Standards, check out Section 2 of RFC 5741 🧚.
Info about the current status of this document, any errata, and how to give feedback on it lives at http://www.rfc-editor.org/info/rfc6595 💖.
Copyright Notice 🌈
Copyright (c) 2012 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please read these carefully, because they spell out your rights and restrictions for this document 🙈. Code Components pulled out of this document must include Simplified BSD License text, as described in Section 4.e of the Trust Legal Provisions. They come without warranty, just like the Simplified BSD License says 💀.
Table of Contents 🍓
1. Introduction ....................................................3
1.1. Terminology ................................................4
1.2. Applicability ..............................................4
2. Authentication Flow .............................................5
3. SAML SASL Mechanism Specification ...............................7
3.1. Initial Response ...........................................8
3.2. Authentication Request .....................................8
3.3. Outcome and Parameters .....................................9
4. SAML GSS-API Mechanism Specification ...........................10
4.1. GSS-API Principal Name Types for SAML .....................11
5. Examples .......................................................11
5.1. XMPP ......................................................11
5.2. IMAP ......................................................15
6. Security Considerations ........................................17
6.1. Man-in-the-Middle and Tunneling Attacks ...................17
6.2. Binding SAML Subject Identifiers to Authorization
Identities ................................................17
6.3. User Privacy ..............................................18
6.4. Collusion between RPs .....................................18
6.5. Security Considerations Specific to GSS-API ...............18
7. IANA Considerations ............................................18
7.1. IANA Mech-Profile .........................................18
7.2. IANA OID ..................................................19
8. References .....................................................19
8.1. Normative References ......................................19
8.2. Informative References ....................................21
Appendix A. Acknowledgments .......................................221. Introduction ✨
Security Assertion Markup Language (SAML) 2.0 [OASIS-SAMLv2-CORE] is a bunch of specs that let a user be identified to a Relying Party (RP) by exchanging assertions, which are usually signed, issued by an Identity Provider (IdP) 🦋. It includes a number of protocols, protocol bindings [OASIS-SAMLv2-BIND], and interoperability profiles [OASIS-SAMLv2-PROF] built for different use cases 💜.
The Simple Authentication and Security Layer (SASL) [RFC4422] is a generalized mechanism for identifying and authenticating a user, and it can optionally negotiate a security layer for later protocol interactions 🔥. SASL is used by application protocols like IMAP [RFC3501], the Post Office Protocol (POP) [RFC1939], and the Extensible Message and Presence Protocol (XMPP) [RFC6120]. The result is modular authentication, so newer authentication mechanisms can be added whenever they're needed. This memo specifies just such a mechanism 🌸.
The Generic Security Service Application Program Interface (GSS-API) [RFC2743] gives applications a framework to support multiple authentication mechanisms through one unified programming interface 🧚. This document defines a pure SASL mechanism for SAML, but it also conforms to the new bridge between SASL and the GSS-API called GS2 [RFC5801]. So this document defines both a SASL mechanism and a GSS-API mechanism. The GSS-API interface is OPTIONAL for SASL implementers, and you can skip the GSS-API stuff entirely in environments that use SASL directly without GSS-API 🫶.
The big idea is that this mechanism lets SASL and SAML talk to each other, so the RP can learn who the user is and other attributes about them 💅. Servers (as RPs) will advertise SASL mechanisms, SAML included, and clients will pick the SAML SASL mechanism as their favorite ✨.
The SAML mechanism in this memo reuses the Web Browser Single Sign-On (SSO) profile from Section 4.1 of the SAML 2.0 profiles specification [OASIS-SAMLv2-PROF] as much as possible 🎀. That's why it doesn't set up its own authentication, integrity, and confidentiality mechanism. It assumes a security layer, like Transport Layer Security (TLS) [RFC5246], will keep being used 🔐. This spec is meant for when a browser instance is around. Without a browser, SAML profiles that don't need one, like the Enhanced Client or Proxy profile (as defined in Section 4.2 of [OASIS-SAMLv2-PROF]), may be used, but that's outside the scope of this spec 🙈.
Figure 1 shows how SAML and SASL work together 🧩. This document needs upgrades on the RP (the SASL server) and on the client, since those are the two SASL endpoints, but the SAML IdP doesn't need any changes 🫶. To make it work, some indirect messaging gets tunneled inside SASL, and some external methods get used too.
+-----------+
| |
>| Relying |
/ | Party |
// | |
// +-----------+
SAML/ // ^
HTTPS // +--|--+
// | S| |
/ S | A| |
// A | M| |
// S | L| |
// L | | |
// | | |
</ +--|--+
+------------+ v
| | +----------+
| SAML | HTTPS | |
| Identity |<--------------->| Client |
| Provider | | |
+------------+ +----------+
Figure 1: Interworking Architecture1.1. Terminology
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119] 📚. These are the BCP 14 key words, so they carry real weight here.
You're assumed to already know the terms used in the SAML 2.0 core specification [OASIS-SAMLv2-CORE] 🤓.
1.2. Applicability
Okay, this part is super important 🚨. This mechanism moves information that an attacker should not be able to control, so the SAML mechanism MUST only be used over channels protected by TLS, or over similar integrity-protected and authenticated channels 🔒. Also, when TLS is used, the client MUST successfully validate the server's certificate ([RFC5280], [RFC6125]) 💅.
Note: An Intranet does not constitute such an integrity-protected and authenticated channel! 💀
2. Authentication Flow ✨
okay so SAML by itself is basically just a markup language 💅 Its main job these days is living inside HTTP [RFC2616] or HTTPS [RFC2818] and HTML [W3C-REC-HTML401]. Here's the typical flow, bestie 🫶
- The browser requests a resource from an RP (via an HTTP request) 🌸
- The RP sends the browser off to the IdP, or to an IdP discovery service, using an HTTP redirect (as described in Section 10.3 of [RFC2616]) 🦋 It tucks in three things: (1) an authentication request that names the resource being requested, (2) a browser cookie, and (3) a return URL as specified in Section 3.1 of [OASIS-SAMLv2-PROF].
- The user logs in to the IdP and maybe okays the release of user attributes to the RP 🔐
- In its authentication response, the IdP redirects the browser back to the RP (via an HTTP redirect) with an authentication assertion. The assertion says the IdP vouches that the subject has successfully authenticated, and it can optionally come with some extra attributes ✨
- The RP now has enough identity info to decide whether to approve access to the resource, and acts on that. The authentication is concluded 👑
Now, when we look at this flow through the lens of SASL, it's giving a little twist 🧚 The RP and the client both must change their code to implement this SASL mechanism, but the IdP can stay totally untouched 💜 The RP already has some sort of session (probably a TCP connection) with the client. Still, it may be necessary to redirect a SASL client to another application or handler. The steps go like this:
- The SASL server (RP) advertises support for the SASL SAML20 mechanism to the client 📣
- The client starts a SASL authentication with SAML20 and sends a domain name, so the SASL server can figure out which IdP is the right one 🍓
- The SASL server transmits an authentication request encoded as a Uniform Resource Identifier (URI) as described in RFC 3986 [RFC3986], plus an HTTP redirect to the IdP that matches the domain 🌈
- The SASL client now sends a response made of
"=". Authentication continues through the normal SAML flow. The SASL server receives the answer to the challenge out of band from the SASL conversation, meaning outside the SASL chat itself 🙈 - At this point the SASL client MUST construct a URL containing the content it got in the previous message from the SASL server. That URL gets sent to the IdP, either by the SASL client application or by an appropriate handler, like a browser 🔥
- Next, the user logs in to the IdP. How the end user gets authenticated to the IdP, plus any policies around that, are out of scope for SAML and therefore out of scope for this document. This step happens out of band from SASL 💀
- The IdP sends info about whether the authentication succeeded or failed back to the SASL server (RP). It does this as an authentication statement or a failure, using an indirect response via the client browser or the handler. (And if an external browser is used, client control gets passed back to the SASL client.) This step also happens out of band from SASL 🦋
- The SASL server sends an appropriate SASL response to the client 🎀
Please note, bestie: all of this describes the case where the client has not previously authenticated. It's possible the client already holds a valid SAML authentication token, so the user doesn't need to be involved anymore. But that would still be external to SASL. This is classic Web Single Sign-On, where the Web Browser client presents the authentication token (cookie) to the RP without renewed user authentication at the IdP 🍰
With all of that in mind, the flow looks like this in Figure 2 👀
SASL Serv. Client IdP
|>-----(1)----->| | Advertisement
| | |
|<-----(2)-----<| | Initiation
| | |
|>-----(3)----->| | Authentication Request
| | |
|<-----(4)-----<| | Response of "="
| | |
| |<- -(5,6) - ->| Client<>IdP
| | | Authentication
| | |
|<- - - - - - - - - - -(7)- - -| Authentication Statement
| | |
|>-----(8)----->| | SASL Completion with
| | | Status
| | |
----- = SASL
- - - = HTTP or HTTPS (external to SASL)
Figure 2: Authentication Flow3. SAML SASL Mechanism Specification ✨
This section lays out the nitty-gritty of the SAML SASL mechanism 🧁 For more details, check out Section 5 of [RFC4422].
The name of this mechanism is "SAML20" 🎀 It can carry an authorization identity (via the "gs2-header"), but it does not offer a security layer.
The mechanism is client-first 🏃♀️ The first mechanism message, from the client to the server, is the "initial-response". As described in [RFC4422], if the application protocol doesn't support sending a client response together with the authentication request, the server will send an empty server challenge to let the client begin. The second mechanism message goes from the server to the client and contains the SAML "authentication-request". The third mechanism message goes from the client to the server and is the fixed message "=". The fourth mechanism message goes from the server to the client and indicates the SASL mechanism outcome 💜
3.1. Initial Response
A client starts a SAML20 authentication with SASL by sending the GS2 header, followed by the Identity Provider identifier (message 2 in Figure 2). It's defined using ABNF [RFC5234] like this 📜
initial-response = gs2-header IdP-Identifier
IdP-Identifier = domain ; domain name with corresponding IdPHere's how the gs2-header gets used 🌸
- The
"gs2-nonstd-flag"MUST NOT be present. - The
"gs2-cb-flag"MUST be set to"n", because channel-binding [RFC5056] data cannot be integrity protected by the SAML negotiation. (Note: In theory, channel-binding data could be inserted in the SAML flow by the client and verified by the server, but that is currently not supported in SAML.) - The
"gs2-authzid"carries the optional authorization identity as specified in [RFC5801]. (Not to be confused with the IdP-Identifier!)
A domain name is either a "traditional domain name" as described in [RFC1035] or an "internationalized domain name" as described in [RFC5890] 🌍 Clients and servers MUST treat the IdP-Identifier as a domain name slot [RFC5890]. They also SHOULD support internationalized domain names (IDNs) in the IdP-Identifier field. If they do, all of the domain name's labels MUST be A-labels or NR-LDH labels [RFC5890]. If necessary, internationalized labels MUST be converted from U-labels to A-labels by using the Punycode encoding [RFC3492] for A-labels before they're sent to the SASL server, as described in the protocol specification for Internationalized Domain Names in Applications [RFC5891] ✨
3.2. Authentication Request
The SASL server sends the SASL client a URI that redirects the SAML client to the IdP (the one that matches the domain the user provided), with a SAML authentication request as one of the parameters (message 3 in Figure 2). It uses this ABNF 🦋
authentication-request = URIThe URI is specified in [RFC3986] and is encoded according to Section 3.4 ("HTTP Redirect Binding") of the SAML 2.0 bindings specification [OASIS-SAMLv2-BIND]. The SAML authentication request is encoded according to Section 3.4 ("Authentication Request Protocol") of [OASIS-SAMLv2-CORE]. Should the client support Internationalized Resource Identifiers (IRIs) [RFC3987], it MUST first map the IRI to a URI before sending it to the server, as defined in Section 3.1 of [RFC3987] 🌷
Note: The SASL server may have a static mapping of domain to corresponding IdP. Alternatively, a DNS-lookup mechanism could be envisioned, but that's out of scope for this document.
Note: While the SASL client MAY sanity-check the URI it received, ultimately it is the SAML IdP that will be validated by the SAML client. That topic is out of scope for this document 🙈
The client then sends the authentication request via an HTTP GET (sent over a server-authenticated TLS channel) to the IdP, as if it had been redirected to do so by an HTTP server, following the Web Browser SSO profile as described in Section 4.1 of [OASIS-SAMLv2-PROF] (messages 5 and 6 in Figure 2) 🫶
The client handles both the user's authentication to the IdP and the confirmation or rejection of the RP's authentication (which is out of scope for this document) 💅
After all authentication is done by the IdP, the IdP sends a redirect message to the client. It's a URI corresponding to the RP, as specified in the authentication request ("AssertionConsumerServiceURL"), with the SAML response as one of the parameters (message 7 in Figure 2) 👑
Please note, bestie: this means the SASL server needs to implement a SAML RP. The SASL server also needs to correlate the session it has with the SASL client with the right SAML authentication result. It can do that by comparing the ID of the SAML authentication request it issued with the one it receives in the SAML authentication statement 🧠
3.3. Outcome and Parameters
The SASL server (in its capacity as a SAML RP) now validates the SAML authentication response it received from the SAML client via HTTP or HTTPS 🔍
The outcome of that validation by the SASL server constitutes a SASL mechanism outcome. Therefore (as stated in [RFC4422]), it SHALL be used to set state in the server accordingly, and it SHALL be used by the server to report that state to the SASL client, as described in [RFC4422], Section 3.6 (message 8 in Figure 2) 🎉
4. SAML GSS-API Mechanism Specification ✨
Okay bestie, this section and its sub-sections are NOT required for SASL implementors 🙅♀️ but this section MUST be observed if you're building the GSS-API mechanism we're about to talk about 💅
This section specifies a GSS-API mechanism that, when used via the GS2 bridge to SASL, acts just like the SASL mechanism from earlier 🦋 So it's fair to say that the SAML SASL mechanism is also a GSS-API mechanism, iykyk. The SAML user plays the GSS-API Initiator, and the SAML RP plays the GSS-API Acceptor. The SAML IdP doesn't have a role in GSS-API at all. It's treated as an internal matter for the SAML mechanism 🧚 The messages are the same, but:
a) the GS2 header on the client's first message and channel-binding data are excluded when SAML is used as a GSS-API mechanism, and
b) the initial context token header (Section 3.1 of [RFC2743]) is prefixed to the client's first authentication message (context token).
The GSS-API mechanism OID for SAML is 1.3.6.1.5.5.17 (see Section 7.2 for more information) 🌸 The DER encoding of the OID is:
0x2b 0x06 0x01 0x05 0x05 0x11SAML20 security contexts MUST have the mutual_state flag (GSS_C_MUTUAL_FLAG) set to TRUE 🫶 SAML doesn't support credential delegation, so SAML security contexts MUST have the deleg_state flag (GSS_C_DELEG_FLAG) set to FALSE. No delegation, no drama 💅
The mutual authentication property of this mechanism relies on successfully comparing the TLS server's identity with the negotiated target name 🔥 The TLS channel is managed by the application outside of the GSS-API mechanism, so the mechanism itself can't confirm the name, but the application can do that comparison for it. For this reason, applications MUST match the TLS server's identity with the target name, as discussed in [RFC6125]. More precisely, to pass identity validation, the client uses the securely negotiated targ_name as the reference identifier and matches it to the DNS-ID of the server's certificate, and it MUST reject the connection if there is a mismatch 🚫 For compatibility with deployed certificate hierarchies, the client MAY also perform a comparison with the Common Name ID (CN-ID) when there is no DNS-ID present 🌈 Wildcard matching is permitted ✨ The targ_name reference identifier is a "traditional domain names", so the comparison is made using case-insensitive ASCII comparison. Very precise, very iconic 👑
The SAML mechanism does not support per-message tokens or the GSS_Pseudo_random() function [RFC4401] 🙈
4.1. GSS-API Principal Name Types for SAML
SAML supports standard generic name syntaxes for acceptors, such as GSS_C_NT_HOSTBASED_SERVICE (see [RFC2743], Section 4.1) 🍓 For initiators, SAML supports only a single name type: GSS_C_NT_USER_NAME. That's also the default name type for SAML 🎀 The query, display, and exported name syntaxes for SAML principal names are all the same. There are no SAML-specific name syntaxes, so applications should use generic GSS-API name types, such as GSS_C_NT_USER_NAME and GSS_C_NT_HOSTBASED_SERVICE (see [RFC2743] Section 4) 💜 The exported name token, of course, conforms to [RFC2743], Section 3.2. Standard, reliable, no surprises ✨
5. Examples 🎀
5.1. XMPP
Let's say the user has an identity at the SAML IdP saml.example.org and a Jabber Identifier (JID) "somenode@example.com", and wants to authenticate their XMPP [RFC6120] connection to xmpp.example.com 🦋 The authentication on the wire would then look something like this:
Step 1: Client initiates stream to server:
<stream:stream xmlns='jabber:client'
xmlns:stream='http://etherx.jabber.org/streams'
to='example.com' version='1.0'>Step 2: Server responds with a stream tag sent to client:
<stream:stream
xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'
id='some_id' from='example.com' version='1.0'>Step 3: Server informs client of available authentication mechanisms:
<stream:features>
<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
<mechanism>DIGEST-MD5</mechanism>
<mechanism>PLAIN</mechanism>
<mechanism>SAML20</mechanism>
</mechanisms>
</stream:features>Step 4: Client selects an authentication mechanism and provides the initial client response (the gs2-header and domain, base64-encoded according to Section 4 of [RFC4648]) 🌷
<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='SAML20'>
biwsZXhhbXBsZS5vcmc=</auth>The decoded string is:
n,,example.orgStep 5: Server sends a base64-encoded challenge to client in the form of an HTTP redirect to the SAML IdP corresponding to example.org (https://saml.example.org), with the SAML authentication request included in the redirection URL 🧚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The decoded challenge is as follows:
https://saml.example.org/SAML/Browser?SAMLRequest=PHNhbWxwOk
F1dGhuUmVxdWVzdCB4bWxuczpzYW1scD0idXJuOm9hc2lzOm5hbWVzOnRjOl
NBTUw6Mi4wOnByb3RvY29sIg0KICAgIElEPSJfYmVjNDI0ZmE1MTAzNDI4OT
A5YTMwZmYxZTMxMTY4MzI3Zjc5NDc0OTg0IiBWZXJzaW9uPSIyLjAiDQogIC
AgSXNzdWVJbnN0YW50PSIyMDA3LTEyLTEwVDExOjM5OjM0WiIgRm9yY2VBdX
Robj0iZmFsc2UiDQogICAgSXNQYXNzaXZlPSJmYWxzZSINCiAgICBQcm90b2
NvbEJpbmRpbmc9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDpiaW5kaW
5nczpIVFRQLVBPU1QiDQogICAgQXNzZXJ0aW9uQ29uc3VtZXJTZXJ2aWNlVV
JMPQ0KICAgICAgICAiaHR0cHM6Ly94bXBwLmV4YW1wbGUuY29tL1NBTUwvQX
NzZXJ0aW9uQ29uc3VtZXJTZXJ2aWNlIj4NCiA8c2FtbDpJc3N1ZXIgeG1sbn
M6c2FtbD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOmFzc2VydGlvbi
I+DQogICAgIGh0dHBzOi8veG1wcC5leGFtcGxlLmNvbQ0KIDwvc2FtbDpJc3
N1ZXI+DQogPHNhbWxwOk5hbWVJRFBvbGljeSB4bWxuczpzYW1scD0idXJuOm
9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOnByb3RvY29sIg0KICAgICBGb3JtYX
Q9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDpuYW1laWQtZm9ybWF0On
BlcnNpc3RlbnQiDQogICAgIFNQTmFtZVF1YWxpZmllcj0ieG1wcC5leGFtcG
xlLmNvbSIgQWxsb3dDcmVhdGU9InRydWUiIC8+DQogPHNhbWxwOlJlcXVlc3
RlZEF1dGhuQ29udGV4dA0KICAgICB4bWxuczpzYW1scD0idXJuOm9hc2lzOm
5hbWVzOnRjOlNBTUw6Mi4wOnByb3RvY29sIiANCiAgICAgICAgQ29tcGFyaX
Nvbj0iZXhhY3QiPg0KICA8c2FtbDpBdXRobkNvbnRleHRDbGFzc1JlZg0KIC
AgICAgeG1sbnM6c2FtbD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOm
Fzc2VydGlvbiI+DQogICAgICAgICAgIHVybjpvYXNpczpuYW1lczp0YzpTQU
1MOjIuMDphYzpjbGFzc2VzOlBhc3N3b3JkUHJvdGVjdGVkVHJhbnNwb3J0DQ
ogIDwvc2FtbDpBdXRobkNvbnRleHRDbGFzc1JlZj4NCiA8L3NhbWxwOlJlcX
Vlc3RlZEF1dGhuQ29udGV4dD4gDQo8L3NhbWxwOkF1dGhuUmVxdWVzdD4=Where the decoded SAMLRequest looks like the following:
<samlp:AuthnRequest xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
ID="_bec424fa5103428909a30ff1e31168327f79474984" Version="2.0"
IssueInstant="2007-12-10T11:39:34Z" ForceAuthn="false"
IsPassive="false"
ProtocolBinding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST"
AssertionConsumerServiceURL=
"https://xmpp.example.com/SAML/AssertionConsumerService">
<saml:Issuer xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">
https://xmpp.example.com
</saml:Issuer>
<samlp:NameIDPolicy xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
Format="urn:oasis:names:tc:SAML:2.0:nameid-format:persistent"
SPNameQualifier="xmpp.example.com" AllowCreate="true" />
<samlp:RequestedAuthnContext
xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
Comparison="exact">
<saml:AuthnContextClassRef
xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">
urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport
</saml:AuthnContextClassRef>
</samlp:RequestedAuthnContext>
</samlp:AuthnRequest>Note: The server can use the request ID ("_bec424fa5103428909a30ff1e31168327f79474984") to correlate the SASL session with the SAML authentication 🔍
Step 5 (alternative): Server returns an error to the client if no SAML authentication request can be constructed 💀
<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
<temporary-auth-failure/>
</failure>
</stream:stream>Step 6: Client sends the "=" response (base64-encoded) to the challenge 🫶
<response xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
PQ==
</response>The following steps between brackets are out of scope for this document, but they're included to better illustrate the entire flow 🌈
[The client now sends the URL to a browser instance for processing. The browser engages in a normal SAML authentication flow (external to SASL), like redirection to the IdP (https://saml.example.org); the user logs into https://saml.example.org and agrees to authenticate to xmpp.example.com. A redirect is passed back to the client browser. The client browser in turn sends the AuthN response, which contains the subject-identifier as an attribute, to the server. If the AuthN response doesn't contain the JID, the server maps the subject-identifier received from the IdP to a JID.]
Step 7: Server informs client of successful authentication 🎉
<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl'/>Step 7 (alternative): Server informs client of failed authentication 😭
<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
<not-authorized/>
</failure>
</stream:stream>Please note: Line breaks were added to the base64 data for clarity 🦋
5.2. IMAP ✨
okay so this one is the IMAP version, and it's giving "email client meets SAML" 📬💖 Lines that start with S: are the server talking and lines that start with C: are the client. The long lines got wrapped so they're easier to read, which is very considerate of whoever wrote this 🎀
S: * OK IMAP4rev1
C: . CAPABILITY
S: * CAPABILITY IMAP4rev1 STARTTLS
S: . OK CAPABILITY Completed
C: . STARTTLS
S: . OK Begin TLS negotiation now
C: . CAPABILITY
S: * CAPABILITY IMAP4rev1 AUTH=SAML20
S: . OK CAPABILITY Completed
C: . AUTHENTICATE SAML20
S: +
C: biwsZXhhbXBsZS5vcmc=
S: + aHR0cHM6Ly9zYW1sLmV4YW1wbGUub3JnL1NBTUwvQnJvd3Nlcj9TQU1M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C: PQ==
S: . OK Success (TLS protection)Okay, so here's the decoded challenge, which is basically the good stuff hiding under all that base64 🫶
https://saml.example.org/SAML/Browser?SAMLRequest=PHNhbWxwOkF
1dGhuUmVxdWVzdCB4bWxuczpzYW1scD0idXJuOm9hc2lzOm5hbWVzOnRjOlNB
TUw6Mi4wOnByb3RvY29sIg0KICAgIElEPSJfYmVjNDI0ZmE1MTAzNDI4OTA5Y
TMwZmYxZTMxMTY4MzI3Zjc5NDc0OTg0IiBWZXJzaW9uPSIyLjAiDQogICAgSX
NzdWVJbnN0YW50PSIyMDA3LTEyLTEwVDExOjM5OjM0WiIgRm9yY2VBdXRobj0
iZmFsc2UiDQogICAgSXNQYXNzaXZlPSJmYWxzZSINCiAgICBQcm90b2NvbEJp
bmRpbmc9InVybjpvYXNpczpuYW1lczp0YzpTQU1MOjIuMDpiaW5kaW5nczpIV
FRQLVBPU1QiDQogICAgQXNzZXJ0aW9uQ29uc3VtZXJTZXJ2aWNlVVJMPQ0KIC
AgICAgICAiaHR0cHM6Ly9tYWlsLmV4YW1wbGUuY29tL1NBTUwvQXNzZXJ0aW9
uQ29uc3VtZXJTZXJ2aWNlIj4NCiA8c2FtbDpJc3N1ZXIgeG1sbnM6c2FtbD0i
dXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOmFzc2VydGlvbiI+DQogICAgI
Gh0dHBzOi8veG1wcC5leGFtcGxlLmNvbQ0KIDwvc2FtbDpJc3N1ZXI+DQogPH
NhbWxwOk5hbWVJRFBvbGljeSB4bWxuczpzYW1scD0idXJuOm9hc2lzOm5hbWV
zOnRjOlNBTUw6Mi4wOnByb3RvY29sIg0KICAgICBGb3JtYXQ9InVybjpvYXNp
czpuYW1lczp0YzpTQU1MOjIuMDpuYW1laWQtZm9ybWF0OnBlcnNpc3RlbnQiD
QogICAgIFNQTmFtZVF1YWxpZmllcj0ieG1wcC5leGFtcGxlLmNvbSIgQWxsb3
dDcmVhdGU9InRydWUiIC8+DQogPHNhbWxwOlJlcXVlc3RlZEF1dGhuQ29udGV
4dA0KICAgICB4bWxuczpzYW1scD0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6
Mi4wOnByb3RvY29sIiANCiAgICAgICAgQ29tcGFyaXNvbj0iZXhhY3QiPg0KI
CA8c2FtbDpBdXRobkNvbnRleHRDbGFzc1JlZg0KICAgICAgeG1sbnM6c2FtbD
0idXJuOm9hc2lzOm5hbWVzOnRjOlNBTUw6Mi4wOmFzc2VydGlvbiI+DQogICA
gICB1cm46b2FzaXM6bmFtZXM6dGM6U0FNTDoyLjA6YWM6Y2xhc3NlczpQYXNz
d29yZFByb3RlY3RlZFRyYW5zcG9ydA0KICA8L3NhbWw6QXV0aG5Db250ZXh0Q
2xhc3NSZWY+DQogPC9zYW1scDpSZXF1ZXN0ZWRBdXRobkNvbnRleHQ+IA0KPC
9zYW1scDpBdXRoblJlcXVlc3Q+And this is the decoded SAMLRequest, so you can see exactly what's inside 👀
<samlp:AuthnRequest xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
ID="_bec424fa5103428909a30ff1e31168327f79474984" Version="2.0"
IssueInstant="2007-12-10T11:39:34Z" ForceAuthn="false"
IsPassive="false"
ProtocolBinding="urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST"
AssertionConsumerServiceURL=
"https://mail.example.com/SAML/AssertionConsumerService">
<saml:Issuer xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">
https://xmpp.example.com
</saml:Issuer>
<samlp:NameIDPolicy xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
Format="urn:oasis:names:tc:SAML:2.0:nameid-format:persistent"
SPNameQualifier="xmpp.example.com" AllowCreate="true" />
<samlp:RequestedAuthnContext
xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"
Comparison="exact">
<saml:AuthnContextClassRef
xmlns:saml="urn:oasis:names:tc:SAML:2.0:assertion">
urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport
</saml:AuthnContextClassRef>
</samlp:RequestedAuthnContext>
</samlp:AuthnRequest>6. Security Considerations 🔐
okay bestie, this section is only about security stuff that's specific to using SAML with SASL applications 🫣 For the general SAML stuff and the general SASL security stuff, you'll need to check the SAML specs and other literature. Don't worry, we'll stay focused on the important bits here 💅
6.1. Man-in-the-Middle and Tunneling Attacks
⚠️ This one is serious, babe. This mechanism is vulnerable to man-in-the-middle and tunneling attacks unless a client always verifies the server's identity before it goes on with authentication (see [RFC6125]).
Typically, TLS is used to give you a secure channel with server authentication 🔒
6.2. Binding SAML Subject Identifiers to Authorization Identities
As [RFC4422] says, the server is in charge of binding credentials to a specific authorization identity 👑 So it's necessary that only specific trusted IdPs get to be allowed. This is a typical part of SAML trust establishment between RPs and the IdP 🤝
6.3. User Privacy
The IdP knows every RP that a user logs into 👀 There's nothing in the protocol that hides this info from the IdP. It's not a requirement to track the visits, but nothing prohibits collecting the information either. SASL server implementers should be aware that SAML IdPs will be able to track -- to some extent -- user access to their services 🕵️♀️
6.4. Collusion between RPs
It's possible for RPs to link data they've collected on users, ngl 🙈 If you use the same identifier to log into every RP, collusion between RPs is possible. In SAML, targeted identity was introduced to fix this. Targeted identity lets the IdP transform the identifier the user typed in into an RP-specific opaque identifier. That way, the RP would never see the actual user identifier and would instead see a randomly generated identifier 🧚
6.5. Security Considerations Specific to GSS-API
Security issues that are inherent in GSS-API [RFC2743] and GS2 [RFC5801] apply to the SAML GSS-API mechanism defined in this document 🚨 Further, and as discussed in Section 4, proper TLS server identity verification is critical to the security of the mechanism. Literally the whole thing depends on it 😭
7. IANA Considerations 📋
7.1. IANA Mech-Profile
The IANA has registered the following SASL profile, slay ✨
SASL mechanism profile: SAML20
Security Considerations: See this document
Published Specification: See this document
For further information: Contact the authors of this document.
Owner/Change controller: the IETF
Intended usage: COMMON
Note: None7.2. IANA OID
The IANA has also assigned a new entry for this GSS mechanism in the SMI Security for Mechanism Codes sub-registry 🦋 The prefix for that sub-registry is iso.org.dod.internet.security.mechanisms (1.3.6.1.5.5), and the IANA referenced this specification in the registry.
8. References 📚
8.1. Normative References 📚
these are the must-read docs the spec leans on, so no skipping bestie 🫶
- [OASIS-SAMLv2-BIND] Cantor, S., Ed., Hirsch, F., Ed., Kemp, J., Ed., Philpott, R., Ed., and E. Maler, Ed., "Bindings for the OASIS Security Assertion Markup Language (SAML) V2.0", OASIS Standard saml-bindings-2.0-os, March 2005,
<http://docs.oasis-open.org/security/saml/v2.0/saml-bindings-2.0-os.pdf>. - [OASIS-SAMLv2-CORE] Cantor, S., Ed., Kemp, J., Ed., Philpott, R., Ed., and E. Maler, Ed., "Assertions and Protocols for the OASIS Security Assertion Markup Language (SAML) V2.0", OASIS Standard saml-core-2.0-os, March 2005,
<http://docs.oasis-open.org/security/saml/v2.0/saml-core-2.0-os.pdf>. - [OASIS-SAMLv2-PROF] Hughes, J., Ed., Cantor, S., Ed., Hodges, J., Ed., Hirsch, F., Ed., Mishra, P., Ed., Philpott, R., Ed., and E. Maler, Ed., "Profiles for the OASIS Security Assertion Markup Language (SAML) V2.0", OASIS Standard OASIS.saml-profiles-2.0-os, March 2005,
<http://docs.oasis-open.org/security/saml/v2.0/saml-profiles-2.0-os.pdf>. - [RFC1035] Mockapetris, P., "Domain names - implementation and specification", STD 13, RFC 1035, November 1987.
- [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
- [RFC2616] Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and T. Berners-Lee, "Hypertext Transfer Protocol -- HTTP/1.1", RFC 2616, June 1999.
- [RFC2743] Linn, J., "Generic Security Service Application Program Interface Version 2, Update 1", RFC 2743, January 2000.
- [RFC2818] Rescorla, E., "HTTP Over TLS", RFC 2818, May 2000.
- [RFC3492] Costello, A., "Punycode: A Bootstring encoding of Unicode for Internationalized Domain Names in Applications (IDNA)", RFC 3492, March 2003.
- [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, January 2005.
- [RFC3987] Duerst, M. and M. Suignard, "Internationalized Resource Identifiers (IRIs)", RFC 3987, January 2005.
- [RFC4422] Melnikov, A., Ed., and K. Zeilenga, Ed., "Simple Authentication and Security Layer (SASL)", RFC 4422, June 2006.
- [RFC5056] Williams, N., "On the Use of Channel Bindings to Secure Channels", RFC 5056, November 2007.
- [RFC5234] Crocker, D., Ed., and P. Overell, "Augmented BNF for Syntax Specifications: ABNF", STD 68, RFC 5234, January 2008.
- [RFC5246] Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, August 2008.
- [RFC5280] Cooper, D., Santesson, S., Farrell, S., Boeyen, S., Housley, R., and W. Polk, "Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 5280, May 2008.
- [RFC5801] Josefsson, S. and N. Williams, "Using Generic Security Service Application Program Interface (GSS-API) Mechanisms in Simple Authentication and Security Layer (SASL): The GS2 Mechanism Family", RFC 5801, July 2010.
- [RFC5890] Klensin, J., "Internationalized Domain Names for Applications (IDNA): Definitions and Document Framework", RFC 5890, August 2010.
- [RFC5891] Klensin, J., "Internationalized Domain Names in Applications (IDNA): Protocol", RFC 5891, August 2010.
- [RFC6125] Saint-Andre, P. and J. Hodges, "Representation and Verification of Domain-Based Application Service Identity within Internet Public Key Infrastructure Using X.509 (PKIX) Certificates in the Context of Transport Layer Security (TLS)", RFC 6125, March 2011.
- [W3C-REC-HTML401] Le Hors, A., Ed., Raggett, D., Ed., and I. Jacobs, Ed., "HTML 4.01 Specification", World Wide Web Consortium Recommendation REC-html401-19991224, December 1999,
<http://www.w3.org/TR/1999/REC-html401-19991224>.
8.2. Informative References 🌸
these ones are extra context, not required reading, but they're so good to know 🧚
- [RFC1939] Myers, J. and M. Rose, "Post Office Protocol - Version 3", STD 53, RFC 1939, May 1996.
- [RFC3501] Crispin, M., "INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1", RFC 3501, March 2003.
- [RFC4401] Williams, N., "A Pseudo-Random Function (PRF) API Extension for the Generic Security Service Application Program Interface (GSS-API)", RFC 4401, February 2006.
- [RFC4648] Josefsson, S., "The Base16, Base32, and Base64 Data Encodings", RFC 4648, October 2006.
- [RFC6120] Saint-Andre, P., "Extensible Messaging and Presence Protocol (XMPP): Core", RFC 6120, March 2011.
Appendix A. Acknowledgments 💜
the authors gave a huge shoutout to these legends for reviewing and contributing, and they absolutely deserve it ✨
Scott Cantor, Joe Hildebrand, Josh Howlett, Leif Johansson, Thomas Lenggenhager, Diego Lopez, Hank Mauldin, RL "Bob" Morgan, Stefan Plug, and Hannes Tschofenig.
Authors' Addresses 🎀
Klaas Wierenga
Cisco Systems, Inc.
Haarlerbergweg 13-19
1101 CH Amsterdam
The Netherlands
Phone: +31 20 357 1752
EMail: klaas@cisco.com
Eliot Lear
Cisco Systems GmbH
Richtistrasse 7
CH-8304 Wallisellen
Switzerland
Phone: +41 44 878 9200
EMail: lear@cisco.com
Simon Josefsson
SJD AB
Johan Olof Wallins vag 13
Solna 171 64
Sweden
EMail: simon@josefsson.org
URI: http://josefsson.org/📦 where this page comes from
- ietf: rfc6595 2012-04
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms