"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; const headings = [{ "data": { "id": "introduction", "hProperties": { "id": "introduction" } }, "depth": 2, "value": "Introduction" }, { "data": { "id": "standard-saml-authentication-flow", "hProperties": { "id": "standard-saml-authentication-flow" } }, "depth": 2, "value": "Standard SAML authentication flow" }, { "data": { "id": "security-factors-in-saml", "hProperties": { "id": "security-factors-in-saml" } }, "depth": 2, "value": "Security factors in SAML" }, { "data": { "id": "sp-entity-id", "hProperties": { "id": "sp-entity-id" } }, "depth": 3, "value": "SP entity ID" }, { "data": { "id": "idp-entity-id", "hProperties": { "id": "idp-entity-id" } }, "depth": 3, "value": "IdP entity ID" }, { "data": { "id": "relay-state", "hProperties": { "id": "relay-state" } }, "depth": 3, "value": "Relay state" }, { "data": { "id": "assertion-signature", "hProperties": { "id": "assertion-signature" } }, "depth": 3, "value": "Assertion signature" }, { "data": { "id": "assertion-encryption", "hProperties": { "id": "assertion-encryption" } }, "depth": 3, "value": "Assertion encryption" }, { "data": { "id": "binding-methods", "hProperties": { "id": "binding-methods" } }, "depth": 3, "value": "Binding methods" }, { "data": { "id": "security-elements-and-considerations-in-saml-assertions", "hProperties": { "id": "security-elements-and-considerations-in-saml-assertions" } }, "depth": 2, "value": "Security elements and considerations in SAML assertions" }, { "data": { "id": "issuer", "hProperties": { "id": "issuer" } }, "depth": 3, "value": "Issuer" }, { "data": { "id": "signature", "hProperties": { "id": "signature" } }, "depth": 3, "value": "Signature" }, { "data": { "id": "conditions", "hProperties": { "id": "conditions" } }, "depth": 3, "value": "Conditions" }, { "data": { "id": "authentication-statement", "hProperties": { "id": "authentication-statement" } }, "depth": 3, "value": "Authentication statement" }, { "data": { "id": "best-practices-for-saml-security", "hProperties": { "id": "best-practices-for-saml-security" } }, "depth": 2, "value": "Best practices for SAML security" }, { "data": { "id": "alternatives-to-saml", "hProperties": { "id": "alternatives-to-saml" } }, "depth": 2, "value": "Alternatives to SAML" }]; const readingTime = { "minutes": 8, "words": 2506, "text": "8 min read" }; const frontmatter = undefined; function _createMdxContent(props) { const _components = { a: "a", code: "code", h2: "h2", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", span: "span", strong: "strong", ul: "ul", ..._provideComponents(), ...props.components }, {LogtoCloudButton} = _components; if (!LogtoCloudButton) _missingMdxReference("LogtoCloudButton", true); return _jsxs(_Fragment, { children: [_jsxs(_components.h2, { id: "introduction", children: ["Introduction", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#introduction", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "The Security Assertion Markup Language (SAML) is an open standard for exchanging authentication and authorization data between parties, in particular, between an identity provider and a service provider. SAML is an XML-based markup language for security assertions that is used for single sign-on (SSO) and identity federation. It is commonly used in enterprise environments for authentication and authorization purposes." }), "\n", _jsxs(_components.h2, { id: "standard-saml-authentication-flow", children: ["Standard SAML authentication flow", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#standard-saml-authentication-flow", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n actor User\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n User->>SP: 1.Access request\n SP->>IdP: 2.Redirect to IdP with SAML authentication request\n IdP->>User: 3.Prompt for credentials\n User->>IdP: 4.Enter credentials\n IdP->>SP: 5.Send SAML response assertion and redirect to SP\n SP->>User: 6.Access granted\n" }) }), "\n", _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "User requests access to a client application, which acts as a service provider (SP)." }), "\n", _jsx(_components.li, { children: "SP sends a SAML SSO authentication request to the identity provider (IdP) and redirects the user to the IdP." }), "\n", _jsx(_components.li, { children: "IdP prompts the user for credentials if the user is not already authenticated." }), "\n", _jsx(_components.li, { children: "User enters credentials, and IdP authenticates the user." }), "\n", _jsx(_components.li, { children: "IdP sends a SAML response assertion to the SP, which includes the user's authentication status and attributes. IdP then redirects the user back to the SP." }), "\n", _jsx(_components.li, { children: "SP receives the SAML response assertion, validates it, and grants access to the user." }), "\n"] }), "\n", _jsxs(_components.h2, { id: "security-factors-in-saml", children: ["Security factors in SAML", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#security-factors-in-saml", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.h3, { id: "sp-entity-id", children: ["SP entity ID", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#sp-entity-id", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Think of the SP entity ID as the unique badge for a SP under the SAML authentication context. It’s like a fingerprint that helps the IdP recognize the SP during their interactions. This ID is a key part of the SP's metadata, shared with the IdP to build trust and ensure secure communication." }), "\n", _jsx(_components.p, { children: "Usage of SP entity ID:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Metadata registration" }), ": The ", _jsx(_components.code, { children: "EntityID" }), " attribute is part of the SP's metadata, shared with the IdP to establish a trust relationship. It serves as a unique identifier to locate the SP's metadata and obtain the required configuration details for SAML interactions."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Authentication request" }), ": The SP entity ID is included in the SAML authentication request sent to the IdP, clearly identifying the requesting SP. The IdP uses this information to validate the request and determine the appropriate authentication context."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assertion audience" }), ": After successful user authentication, the SP entity ID is included in the SAML assertion as an audience restriction. This measure ensures that the assertion is intended exclusively for the designated SP and cannot be misused by other SPs."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n SP-->>IdP: Metadata registration\n SP->>IdP: Authentication request with SP entity ID\n SP-->>SP: Identify SP entity\n IdP->>SP: SAML response assertion with SP entity ID as audience\n IdP-->>IdP: Validate assertion audience\n\n" }) }), "\n", _jsxs(_components.h3, { id: "idp-entity-id", children: ["IdP entity ID", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#idp-entity-id", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "On the flip side, the IdP entity ID is the special label for the IdP. It helps identify the IdP within the SAML ecosystem, making it easy for the SP to find it. This ID is included in the IdP's metadata and is shared with the SP, fostering a trusting relationship and secure connections." }), "\n", _jsx(_components.p, { children: "Usage of IdP entity ID:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Metadata registration" }), ": The ", _jsx(_components.code, { children: "EntityID" }), " attribute is also included in the IdP's metadata, shared with the SP to establish a trust relationship. It serves as a unique identifier to locate the IdP's metadata and obtain the necessary configuration details for SP to validate SAML responses."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assertion issuer" }), ": When the IdP generates a SAML assertion, it includes its entity ID as the issuer. This attribute indicates the entity that issued the assertion and helps the SP verify the assertion's authenticity and integrity."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n IdP-->>SP: Metadata registration\n IdP->>SP: SAML response assertion with IdP entity ID as issuer\n SP-->>SP: Validate assertion issuer\n\n" }) }), "\n", _jsxs(_components.h3, { id: "relay-state", children: ["Relay state", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#relay-state", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Relay state is a parameter used in SAML authentication that facilitates the transfer of state information between the SP and the IdP. It acts as a bridge between the SP-initiated and IdP-initiated SSO flows, preserving the user's context and session state during the authentication process." }), "\n", _jsx(_components.p, { children: "Usage of relay state:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Maintaining user context" }), ": Relay state allows the SP to pass additional information to the IdP during the authentication process. This information can include the user's session state, application context, or any other relevant data that needs to be preserved across the SAML flow. Such as the URL or session ID of the application the user was accessing before authentication."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Preventing CSRF attacks" }), ": Relay state is crucial for preventing cross-site request forgery (CSRF) attacks during SAML authentication. By including a unique and unpredictable relay state value in the authentication request, the SP can verify the integrity of the SAML response and ensure that it corresponds to the original request."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n SP-->>SP: Generate and persist relay state\n SP->>IdP: Authentication request with relay state\n IdP->>SP: SAML response assertion with relay state\n SP-->>SP: Validate relay state and restore user context\n\n" }) }), "\n", _jsxs(_components.h3, { id: "assertion-signature", children: ["Assertion signature", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#assertion-signature", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "The assertion signature is a critical security feature in SAML that ensures the integrity, authenticity, and non-repudiation of SAML assertions. It involves digitally signing the SAML assertion using the IdP's private key, allowing the SP to verify the assertion's origin and detect any tampering attempts." }), "\n", _jsx(_components.p, { children: "How assertion signature works:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Key pair generation" }), ": The IdP generates a public-private key pair, where the private key is used to sign the SAML assertion, and the public key is shared with the SP for verification. This asymmetric encryption scheme ensures that only the IdP can sign the assertion, while the SP can validate it."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Shared certificate" }), ": The IdP provides the SP with its public key certificate, which contains the public key used for verifying the assertion signature. Normally, this certificate will be part of the IdP's metadata, or the SP can obtain it through a secure download process."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assertion signing" }), ": After authenticating the user, the IdP digitally signs the SAML assertion using its private key. This signature is included in the assertion, along with the public key certificate, allowing the SP to verify the assertion's authenticity."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assertion verification" }), ": Upon receiving the SAML assertion, the SP uses the IdP's public key to verify the assertion's signature. If the signature is valid, the SP can trust the assertion and grant access to the user."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n IdP-->>IdP: Generate public-private key pair\n IdP-->>SP: Share public key certificate\n SP->>IdP: Authentication request\n IdP->>SP: Sign SAML assertion with private key\n SP-->>SP: Verify assertion signature using public key\n" }) }), "\n", _jsxs(_components.h3, { id: "assertion-encryption", children: ["Assertion encryption", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#assertion-encryption", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "In addition to signing, SAML also supports assertion encryption to protect sensitive user attributes and data transmitted between the IdP and SP. By encrypting the assertion, the IdP ensures that only the intended recipient (SP) can decrypt and access the assertion's contents, safeguarding user privacy and confidentiality. Assertion encryption is an optional security feature in SAML that can be used to enhance data protection." }), "\n", _jsx(_components.p, { children: "Usage of assertion encryption:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Sensitive attribute protection" }), ": Assertion encryption is particularly useful for safeguarding sensitive user attributes, such as Personally Identifiable Information (PII), financial data, or health records. By encrypting these attributes within the assertion, the IdP prevents unauthorized access and ensures data confidentiality."] }), "\n"] }), "\n", _jsx(_components.p, { children: "How assertion encryption works:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Key exchange" }), ": The IdP and SP establish a secure key exchange mechanism to share encryption keys for protecting the SAML assertion. This can involve using symmetric encryption keys or public-key encryption schemes, depending on the encryption algorithm and key management strategy."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Attribute encryption" }), ": After generating the SAML assertion, the IdP encrypts the sensitive user attributes using the shared encryption key. The encrypted attributes are embedded within the assertion, ensuring that only the SP can decrypt and access the data."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assertion decryption" }), ": Upon receiving the encrypted assertion, the SP decrypts the protected attributes using the shared encryption key. This process allows the SP to access the user's sensitive data securely and process it as needed."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n IdP-->>IdP: Generate encryption key\n IdP-->>SP: Share encryption key\n IdP->>SP: Encrypt sensitive attributes in SAML assertion\n SP-->>SP: Decrypt encrypted attributes\n" }) }), "\n", _jsxs(_components.h3, { id: "binding-methods", children: ["Binding methods", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#binding-methods", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "SAML binding methods define how SAML messages are transmitted between the SP and IdP over different communication protocols. They specify the encoding, transport, and security mechanisms used to exchange SAML assertions and requests, ensuring secure and reliable communication between the involved parties." }), "\n", _jsx(_components.p, { children: "Both the SP and IdP will specify which binding methods they support in their metadata, allowing them to negotiate the appropriate method for SAML interactions. The choice of binding method depends on factors such as message size, security requirements, and the communication channel's characteristics." }), "\n", _jsx(_components.p, { children: "SAML binding methods:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "HTTP Redirect" }), ": SAML messages are encoded as URL parameters and transmitted via HTTP redirect. This binding is suitable for scenarios where the message size is limited, and the communication channel is not secure."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "HTTP POST" }), ": SAML messages are encoded as form parameters and transmitted via HTTP POST requests. This binding is used when the message size exceeds the URL length limit or when additional security measures are required."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Artifact" }), ": SAML messages are transmitted using short-lived tokens called artifacts, which are exchanged over a secure back-channel between the SP and IdP. This binding is suitable for scenarios where message confidentiality and integrity are critical, and the communication channel is secure."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Most common binding methods:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Authentication request" }), ": The authentication request from the SP to the IdP is typically transmitted using the HTTP Redirect due to its simplicity and efficiency. The SP encodes the SAML request as URL parameters and redirects the user's browser to the IdP for authentication. This is known as the SP-initiated SSO flow."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Assertion response" }), ": The SAML response assertion from the IdP to the SP is usually transmitted using the HTTP POST binding method. The IdP encodes the SAML assertion as form parameters and posts it back to the SP for validation. This ensures that the assertion is securely transmitted without exposing sensitive data in the URL. Also, the HTTP POST binding can handle larger message sizes compared to the HTTP Redirect binding."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: " sequenceDiagram\n participant SP as Service Provider\n participant IdP as Identity Provider\n\n SP->>IdP: Authentication request (HTTP Redirect)\n IdP->>SP: Assertion response (HTTP POST)\n" }) }), "\n", _jsxs(_components.h2, { id: "security-elements-and-considerations-in-saml-assertions", children: ["Security elements and considerations in SAML assertions", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#security-elements-and-considerations-in-saml-assertions", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.h3, { id: "issuer", children: ["Issuer", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#issuer", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "As mentioned earlier, the issuer is a key attribute in SAML assertions that identifies the entity that issued the assertion. The issuer is typically the IdP that authenticated the user and generated the assertion. By including the issuer attribute in the assertion, the SP can verify the assertion's origin and ensure that it comes from a trusted source." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-xml", children: " http://idp.example.com/metadata.php\n" }) }), "\n", _jsxs(_components.h3, { id: "signature", children: ["Signature", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#signature", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "The signature element in a SAML assertion contains the digital signature generated by the IdP to ensure the assertion's integrity and authenticity. The signature is created using the IdP's private key and included in the assertion along with the public key certificate for verification by the SP. By validating the signature, the SP can verify that the assertion has not been tampered with and comes from the expected IdP." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-xml", children: "\n \n \n \n \n \n \n \n \n \n ...\n \n \n ...\n \n \n ...\n \n \n" }) }), "\n", _jsxs(_components.h3, { id: "conditions", children: ["Conditions", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#conditions", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "The conditions element in a SAML assertion defines the constraints and restrictions that apply to the assertion's validity and usage. It includes conditions such as the assertion's validity period, audience restrictions, and other contextual constraints that the SP must enforce when processing the assertion." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-xml", children: "\n \n https://sp.example.com\n \n\n" }) }), "\n", _jsxs(_components.h3, { id: "authentication-statement", children: ["Authentication statement", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#authentication-statement", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "The authentication statement (AuthnStatement) is a key component of the SAML assertion that provides information about the user's authentication status and context. It includes details such as the authentication method used, the time of authentication, and any relevant authentication context information, allowing the SP to make informed access control decisions based on the user's authentication state." }), "\n", _jsx(_components.p, { children: "Authentication statement attributes:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "AuthenticationContext" }), ": Describes the method and context of user authentication, such as username-password, multi-factor authentication, or single sign-on. This attribute helps the SP assess the strength and reliability of the authentication process and determine the appropriate access controls."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "AuthenticationInstant" }), ": Indicates the time when the user was authenticated by the IdP. This timestamp is crucial for verifying the freshness of the authentication and preventing replay attacks or session hijacking."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "SessionNotOnOrAfter" }), ": Specifies the expiration time of the user's session, after which the user must re-authenticate to access the service. This attribute helps enforce session management policies and mitigate the risk of unauthorized access."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-xml", children: "\n \n urn:oasis:names:tc:SAML:2.0:ac:classes:Password\n \n\n" }) }), "\n", _jsxs(_components.h2, { id: "best-practices-for-saml-security", children: ["Best practices for SAML security", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#best-practices-for-saml-security", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Use secure binding methods" }), ": Choose appropriate SAML binding methods based on your security requirements and communication channel characteristics. Use HTTP POST for transmitting sensitive data and HTTP Redirect for simple requests."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Validate assertion signatures" }), ": Verify the digital signatures of SAML assertions to ensure their integrity and authenticity. Use the IdP's public key certificate to validate the signature and detect tampering attempts."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Enforce audience restrictions" }), ": Include audience restrictions in SAML assertions to limit the assertion's scope to the intended SP. This prevents assertion replay attacks and unauthorized access by other service providers."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Secure metadata exchange" }), ": Protect the exchange of SP and IdP metadata to prevent metadata tampering and spoofing attacks. Use secure channels and mechanisms to share metadata securely."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Implement secure relay state handling" }), ": Use unique and unpredictable relay state values to prevent CSRF attacks during SAML authentication. Validate the relay state to ensure its integrity and authenticity."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Enforce session management" }), ": Define session expiration policies and enforce session timeouts to mitigate the risk of session hijacking and unauthorized access. Use session-related attributes in SAML assertions to manage user sessions securely."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Encrypt sensitive attributes" }), ": If necessary, encrypt sensitive user attributes within SAML assertions to protect user privacy and data confidentiality. Use secure encryption algorithms and key management practices to safeguard sensitive data."] }), "\n"] }), "\n", _jsxs(_components.h2, { id: "alternatives-to-saml", children: ["Alternatives to SAML", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#alternatives-to-saml", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "While SAML remains a widely adopted standard for SSO and identity federation, offering a robust set of features and security mechanisms, its age can pose challenges in meeting the evolving security and usability demands of modern applications. When compared to the more contemporary OAuth 2.0-based OpenID Connect (OIDC), SAML tends to be more complex and lacks some of the enhanced security features that OIDC provides. For instance, OIDC’s multi-security request authorization code grant flow offers a more secure approach than the relatively straightforward SAML assertion exchange flow. For organizations looking to adopt a more modern and flexible identity federation solution, OIDC may be a viable alternative to SAML." }), "\n", _jsx(LogtoCloudButton, { children: "Try Logto today" })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { headings, readingTime, frontmatter, default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }