Spring Boot 基于 SAML 实现单点登录全解析

于 2025-05-03 01:00:00 发布
阅读量877 收藏 13
点赞数 24
分类专栏： Java开发 文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42593797/article/details/147513072
版权

前言

在企业级应用开发中，单点登录（SSO）能显著提升用户体验和系统安全性。安全断言标记语言（SAML）作为一种广泛应用的 XML 标准，可在不同安全域之间交换身份验证和授权数据。本文将详细介绍在 Spring Boot 中基于 SAML 实现单点登录的原理、方式、优缺点及注意事项，并给出具体代码示例。

一、SAML 实现单点登录原理

1.1 SAML 基本概念

SAML 定义了三种主要角色：身份提供者（IdP）、服务提供者（SP）和用户。IdP 负责验证用户身份，SP 是用户请求访问的应用，用户则是使用系统的个体。SAML 通过断言（Assertion）来传递身份验证和授权信息。

1.2 单点登录流程

  1. 用户访问 SP：用户尝试访问 SP 的受保护资源，若未认证，SP 生成 SAML 请求。
  2. 重定向到 IdP：SP 将用户重定向到 IdP 的登录页面，并附带 SAML 请求。
  3. 用户登录 IdP：用户在 IdP 输入凭据进行身份验证。
  4. IdP 生成 SAML 断言：验证通过后，IdP 创建包含用户身份和授权信息的 SAML 断言。
  5. 返回 SAML 响应：IdP 将 SAML 响应（包含断言）发送给 SP。
  6. SP 验证 SAML 响应：SP 验证响应的签名和内容，若有效则创建本地会话，允许用户访问资源。

二、Spring Boot 基于 SAML 实现单点登录的方式

2.1 准备工作

创建 Spring Boot 项目，在 pom.xml 中添加必要依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.extensions</groupId>
        <artifactId>spring-security-saml2-core</artifactId>
        <version>1.0.10.RELEASE</version>
    </dependency>
</dependencies>

2.2 配置 SAML

创建 SAMLConfig 类来配置 SAML 相关信息：

import org.opensaml.saml2.metadata.provider.MetadataProvider;
import org.opensaml.saml2.metadata.provider.MetadataProviderException;
import org.opensaml.saml2.metadata.provider.ResourceBackedMetadataProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.saml.SAMLAuthenticationProvider;
import org.springframework.security.saml.SAMLBootstrap;
import org.springframework.security.saml.SAMLEntryPoint;
import org.springframework.security.saml.SAMLLogoutFilter;
import org.springframework.security.saml.SAMLLogoutProcessingFilter;
import org.springframework.security.saml.SAMLProcessingFilter;
import org.springframework.security.saml.context.SAMLContextProviderImpl;
import org.springframework.security.saml.key.JKSKeyManager;
import org.springframework.security.saml.metadata.CachingMetadataManager;
import org.springframework.security.saml.metadata.ExtendedMetadata;
import org.springframework.security.saml.metadata.ExtendedMetadataDelegate;
import org.springframework.security.saml.parser.ParserPoolHolder;
import org.springframework.security.saml.util.VelocityFactory;
import org.springframework.security.saml.websso.WebSSOProfileConsumer;
import org.springframework.security.saml.websso.WebSSOProfileConsumerImpl;
import org.springframework.security.saml.websso.WebSSOProfileOptions;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;
import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Configuration
@EnableWebSecurity
public class SAMLConfig extends WebSecurityConfigurerAdapter {

    @Bean
    public SAMLBootstrap sAMLBootstrap() {
        return new SAMLBootstrap();
    }

    @Bean
    public SAMLEntryPoint samlEntryPoint() {
        WebSSOProfileOptions webSSOProfileOptions = new WebSSOProfileOptions();
        webSSOProfileOptions.setIncludeScoping(false);
        SAMLEntryPoint samlEntryPoint = new SAMLEntryPoint();
        samlEntryPoint.setDefaultProfileOptions(webSSOProfileOptions);
        return samlEntryPoint;
    }

    @Bean
    public SAMLProcessingFilter samlWebSSOProcessingFilter() throws Exception {
        SAMLProcessingFilter samlWebSSOProcessingFilter = new SAMLProcessingFilter();
        samlWebSSOProcessingFilter.setAuthenticationManager(authenticationManager());
        samlWebSSOProcessingFilter.setAuthenticationSuccessHandler(successRedirectHandler());
        samlWebSSOProcessingFilter.setAuthenticationFailureHandler(authenticationFailureHandler());
        return samlWebSSOProcessingFilter;
    }

    @Bean
    public SavedRequestAwareAuthenticationSuccessHandler successRedirectHandler() {
        SavedRequestAwareAuthenticationSuccessHandler successRedirectHandler = new SavedRequestAwareAuthenticationSuccessHandler();
        successRedirectHandler.setDefaultTargetUrl("/");
        return successRedirectHandler;
    }

    @Bean
    public SimpleUrlAuthenticationFailureHandler authenticationFailureHandler() {
        SimpleUrlAuthenticationFailureHandler failureHandler = new SimpleUrlAuthenticationFailureHandler();
        failureHandler.setUseForward(true);
        failureHandler.setDefaultFailureUrl("/error");
        return failureHandler;
    }

    @Bean
    public SAMLAuthenticationProvider samlAuthenticationProvider() {
        SAMLAuthenticationProvider samlAuthenticationProvider = new SAMLAuthenticationProvider();
        samlAuthenticationProvider.setUserDetails(samlUserDetailsService());
        samlAuthenticationProvider.setForcePrincipalAsString(false);
        return samlAuthenticationProvider;
    }

    @Bean
    public SAMLUserDetailsService samlUserDetailsService() {
        return new SAMLUserDetailsService();
    }

    @Bean
    public CachingMetadataManager metadata() throws MetadataProviderException {
        List<MetadataProvider> providers = Collections.singletonList(idpMetadata());
        return new CachingMetadataManager(providers);
    }

    @Bean
    public ExtendedMetadataDelegate idpMetadata() throws MetadataProviderException {
        ResourceBackedMetadataProvider provider = new ResourceBackedMetadataProvider(
                () -> new ClassPathResource("/idp-metadata.xml").getInputStream(),
                ParserPoolHolder.getPool());
        ExtendedMetadata extendedMetadata = new ExtendedMetadata();
        extendedMetadata.setIdpDiscoveryEnabled(false);
        return new ExtendedMetadataDelegate(provider, extendedMetadata);
    }

    @Bean
    public WebSSOProfileConsumer webSSOprofileConsumer() {
        return new WebSSOProfileConsumerImpl();
    }

    @Bean
    public JKSKeyManager keyManager() {
        java.util.Map<String, String> passwords = Collections.singletonMap("apollo", "apollo");
        return new JKSKeyManager(new ClassPathResource("samlKeystore.jks"), passwords, "apollo");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
               .httpBasic().disable()
               .csrf().disable()
               .addFilterBefore(samlMetadataFilter(), BasicAuthenticationFilter.class)
               .addFilterAfter(samlWebSSOProcessingFilter(), BasicAuthenticationFilter.class)
               .addFilterBefore(samlLogoutProcessingFilter(), BasicAuthenticationFilter.class)
               .addFilterBefore(samlLogoutFilter(), BasicAuthenticationFilter.class)
               .authorizeRequests()
               .antMatchers("/saml/**").permitAll()
               .anyRequest().authenticated()
               .and()
               .exceptionHandling()
               .authenticationEntryPoint(samlEntryPoint());
    }

    @Bean
    public SAMLLogoutProcessingFilter samlLogoutProcessingFilter() {
        return new SAMLLogoutProcessingFilter(logoutSuccessHandler(), new SecurityContextLogoutHandler());
    }

    @Bean
    public SAMLLogoutFilter samlLogoutFilter() {
        return new SAMLLogoutFilter(logoutSuccessHandler(),
                new LogoutHandler[]{logoutHandler()},
                new LogoutHandler[]{logoutHandler()});
    }

    @Bean
    public SimpleUrlLogoutSuccessHandler logoutSuccessHandler() {
        SimpleUrlLogoutSuccessHandler successHandler = new SimpleUrlLogoutSuccessHandler();
        successHandler.setDefaultTargetUrl("/");
        return successHandler;
    }

    @Bean
    public LogoutHandler logoutHandler() {
        SecurityContextLogoutHandler logoutHandler = new SecurityContextLogoutHandler();
        logoutHandler.setInvalidateHttpSession(true);
        logoutHandler.setClearAuthentication(true);
        return logoutHandler;
    }

    @Bean
    public SAMLMetadataFilter samlMetadataFilter() {
        return new SAMLMetadataFilter(metadata(), new ExtendedMetadata());
    }
}

2.3 创建用户详情服务

创建 SAMLUserDetailsService 类来处理用户信息：

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.saml.SAMLUserDetailsService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collection;

@Service
public class SAMLUserDetailsService implements SAMLUserDetailsService {

    @Override
    public UserDetails loadUserBySAML(org.opensaml.saml2.core.Assertion assertion) {
        String username = assertion.getSubject().getNameID().getValue();
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
        return new User(username, "", authorities);
    }
}

2.4 提供受保护资源

创建一个简单的控制器来提供受保护的资源：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProtectedResourceController {

    @GetMapping("/protected")
    public String protectedResource() {
        return "This is a protected resource accessed via SAML SSO.";
    }
}

三、优缺点分析

3.1 优点

  • 企业级支持：SAML 是为企业环境设计的，众多企业级应用和服务都支持 SAML，方便企业内部不同系统之间的集成。
  • 安全性高：使用 XML 格式的断言进行身份验证和授权，支持数字签名和加密，能有效防止信息篡改和伪造。
  • 标准化程度高：作为开放标准，具有良好的互操作性和兼容性，不同厂商的系统之间可以方便地进行集成。

3.2 缺点

  • 实现复杂度高：涉及复杂的 XML 格式和协议规范，开发者需要对 SAML 有深入的理解，实现难度较大。
  • 配置繁琐：需要处理大量的元数据，包括服务提供商和身份提供商的元数据，配置过程容易出错。

四、需要注意的问题和难点

4.1 元数据管理

元数据包含了 SP 和 IdP 的配置信息，如端点 URL、证书等。需要确保元数据的准确性和及时性，并且在元数据发生变化时及时更新。

4.2 证书管理

SAML 中使用证书进行签名和加密，需要妥善管理证书的生成、存储和更新。确保证书的有效期和安全性，防止证书泄露导致的安全问题。

4.3 错误处理

在 SAML 交互过程中，可能会出现各种错误，如签名验证失败、断言过期等。需要实现完善的错误处理机制，向用户提供明确的错误信息。

4.4 兼容性问题

不同的 IdP 和 SP 可能对 SAML 标准的实现存在细微差异，需要进行充分的测试，确保在不同的环境下都能正常工作。

结语

基于 SAML 在 Spring Boot 中实现单点登录虽然有一定的复杂度，但能为企业级应用带来强大的身份验证和授权功能。通过本文的介绍，你了解了 SAML 单点登录的原理、实现方式、优缺点以及需要注意的问题。在实际应用中，要根据具体需求和场景进行合理配置和优化，以确保系统的安全性和稳定性。

Spring Security 6.x 系列【55】认证篇之集成SAML 2.0登录
记录知识、锤炼自我
06-12 2979
Spring Security提供了作为SP服务提供方进行SAML 2.0登录的功能，基于SAML 2.0 中Web Browser SSO Profile标准规范实现。 自2009年以来，对依赖方SP的支持一直作为一个扩展项目存在。在2019年，开始将其移植到Spring Security本身。类似于2017年开始的对Spring Security的OAuth 2.0支持的过程。
【SpringBoot】集成SpringSecurity+JWT实现多服务单点登录，原来这么easy
墩墩分墩
09-25 2855
- **单点登录(SingleSignOn，SSO)**，当用户在身份`认证服务器`上登录一次以后，即可**获得访问单点登录系统中其他关联系统和应用软件的权限**，同时这种实现是不需要管理员对用户的登录状态或其他信息进行修改的，这意味着在多个应用系统中，`用户只需一次登录就可以访问所有相互信任的应用系统`。这种方式减少了由登录产生的时间消耗，辅助了用户管理，是目前比较流行的一种**分布式登录方式**。
Spring Boot 如何实现单点登录（SSO）
u013749113的博客
09-25 4512
单点登录是一种身份验证机制，允许用户只需一次登录，即可在多个应用程序或服务之间访问资源，而无需在每个服务中重新输入凭证。这提供了更好的用户体验，同时提高了安全性，因为用户的凭证仅在一处验证。
**Spring Security SAML** 是 Spring Security 项目的一个扩展，旨在为 Spring 应用程序提供基于 SAML 2.0 的单点登录（SSO）功能
BLOG域名:programb.blog.csdn.net
05-11 485
是一个功能强大的工具，适用于需要实现基于 SAML 2.0 的单点登录和安全认证的场景。尽管项目已进入维护模式，但其核心功能仍然具有重要价值。开发者可以参考官方文档和示例代码，快速上手并集成到自己的项目中。
[SpringBoot]单点登录
YJH000_的博客
06-30 5898
【实现手段】当用户提交登录请求时，就需要获取用户的IP地址与设备信息，当验证登录通过后，将此用户的JWT、IP地址、设备信息全部存入到Redis中，后续，当客户端提交请求后，在。）中，首先检查Redis中的信息，如果此JWT在Redis中存在（例如白名单），则视为有效，所以，当退出登录时，只需要在Redis中将对应的JWT删除即可。目前的代码中，将管理员的权限列表存储在JWT中，导致JWT数据太长，并且，权限数据应该视为敏感数据，不应该表现在JWT中。以上问题都可以结合Redis的应用来解决！
Spring Boot2 使用 Spring Security + OAuth2 实现单点登录SSO
lovelichao12的专栏
03-25 1万+
前言 目前系统都是比较流行的微服务架构，在企业发展初期，企业使用的系统很少，通常一个或者两个，每个系统都有自己的登录模块，使用人员每天用自己的账号登录，很方便。但随着企业的发展，用到的微服务系统随之增多，使用人员在操作不同的系统时，需要多次登录，而且每个系统的账号都不一样，都要记录，这对于使用人员来说，很不方便还不友好。于是，就想到是不是可以在一个统一登录门户平台登录，其他系统就不用登录了呢？这就是单点登录要解决的问题。 单点登录英文全称Single signOn，简称就是SSO。它的解释是：在多个应用.
Spring Boot实战：SSO和OAuth2.0
print_helloword的博客
11-05 2752
SSO（单点登录）是一种认证机制，它允许用户只需登录一次即可访问多个独立的应用系统，而不需要在每个系统上重复登录。SSO的核心是用户身份认证，即确定用户是谁，并在多个应用系统之间共享这一登录状态。OAuth 2.0 是一种授权协议，允许第三方应用在不暴露用户凭据的情况下，安全地访问用户的资源。OAuth 2.0 的核心是授权，即用户授权第三方应用访问其资源的权限，而不是直接进行用户认证。SSO主要解决用户认证问题，让用户在多个系统之间可以使用单一的登录状态，实现“登录一次，访问多处”的效果。
SpringBoot实现基础的sso单点登录
w13369437728qy的博客
11-24 2287
springboot实现单点登录
SAML2.0使用
strivezxq的专栏
02-07 2万+
最近在工作中和海外一家公司对接单点登录，用到了SAML2.0协议，目前公司的单点登录 还是比较老的CASE3.5版本，不支持SAML2，要支持也要定制优，由于后面肯定是要升级，所 以不在源码上做调整支持，单独建了个SSO应用作为CASE客户端，并包装客户的接口，登录 还是用CASE认证。 由于客户没有完全实现SAML2.0（SP）的功能， IDP由我司CASE提供，我司SSO应用其实是半个SP的功...
Spring Boot与Spring Security saml集成方案解析
Spring Security SAML是一个基于Spring Security的安全模块，它允许Java应用程序使用SAML协议来实现安全的Web SSO（单点登录）。SAML（Security Assertion Markup Language）是一种基于XML的标准，用于在不同的安全...
spring-boot-security-saml-sample
04-07
[SBS3] Spring Boot示例SAML 2.0服务提供程序 项目简介 该项目代表完全基于Spring Framework构建的SAML 2.0服务提供程序的示例实现。 特别是，它展示了如何通过集成Spring Boot和Spring Security SAML开发为联合身份验证设计的Web解决方案。 使用Java注释（无XML）已完全定义了配置。 SSOCircle （ ）用作测试的公共身份提供者。 作者： Vincenzo De Notaris（ ） 网站： 版本： 2.3.1.RELEASE 最后更新：2020年2月15日 感谢VladimírSchäfer （ ）支持我的工作。 参考 Sprint Boot Spring Boot使得创建具有Spring动力的生产级应用程序和服务变得容易，而且绝对不会引起大惊小怪。 它从Spring平台的角度出发，以便新老用
单点登录saml
04-10
aml是一种xml格式的语言。 翻译过来大概叫 安全断言（标记）语言。 这里有两个点： 第一是“安全”， 第二是“断言(assertion)”。 用人话翻译saml就是 用安全的方式表达断言一种语言。 先看它的核心概念“断言”。 断言是什么？ 就是做出判断的语言。比如一句话： 小明是超级管理员。 这就是一个断言。再来一个例子：小红没有权限读取根目录。这也是一个断言。 这种“做出判断的语句”我们在很多场合都需要用到。 比如你在网上尝试登陆一个服务的时候， 这个服务需要知道你是不是合法的用户。 这个时候如果你能提供一个“安全，可靠，可信任”的断言：“小明有权登陆XX服务”， 那么这个服务就知道你合法了， 于是就能为你提供服务了。 这个例子比较抽象，但基本上能表达断言在实际用例中的作用了。 实际上saml的大部分用例就在于证明你是谁，你拥有什么权限等等了。 saml中大部分主要内容也都是类似于：你是谁， 你有什么。。等等这些简单的语句。 详细内容后面会介绍。 接下来第二个概念就是“安全”了。 你能提供一个断言， 别人能不能假冒你提供一个断言从而骗取服务端的信任呢？ 另外服务端为什么会信任你给的断言呢？ 这就涉及到安全的问题了。为了防止断言被假冒，篡改。saml中加入了安全措施。 当然现今能抵御假冒，篡改，重放攻击的利器就是公钥-私钥系统了。 通过给断言加上签名和加密，再结合数字证书系统就确保了saml不受攻击。
如何将Spring-oAuth2与Spring-SAML集成
04-03
另一方面，SAML是一种基于XML的身份验证和授权协议，主要用于企业级的单点登录（SSO）场景。Spring Security SAML扩展了Spring Security，使其能够处理SAML协议，方便地集成到SAML身份提供者（IdP）和SAML服务提供者...
Spring Security 6.x 系列【54】认证篇之SAML 2.0 协议
记录知识、锤炼自我
06-12 1695
SAML英文全称为Security Assertion Markup Language，即安全断言标记语言。该标准由安全服务技术委员会OASIS制定，始于2001年，2005年发布SAML 2.0沿用至今。
gitlab 单点登录
最新发布
Crazy_427的博客
12-19 606
gitlab 单点登录 一篇搞定
Spring Boot 完整讲解
热门推荐
可乐的博客
02-28 2万+
SpringBoot学习笔记 文章写得比较详细，所以很长（105336 字数），可以参考目录 文章目录SpringBoot学习笔记@[toc]一、 Spring Boot 入门预：必须掌握的技术：1. Spring Boot 简介背景解决的问题优点缺点2.微服务What are Microservices?单体应用微服务3.环境准备Maven设置：Idea设置4.Spring Boot Hel...
基于SAML2.0单点登录的实现(JAVA)
xuliang1265的博客
11-23 1万+
一、实现流程 二、git中下载sp程序，部署服务，并调试，确保与idp可以通信。 1、下载地址 https://github.com/vdenotaris/spring-boot-security-saml-sample 2、配置证书，修改 \src\main\resources\update-certifcate.sh，并运行，会根据配置生成jks证书。解决SSL peer failed ho...
SpringBoot2（二）：底层注解&自动配置
weixin_44800710的博客
12-10 630
1.容器功能 1.组件添加 1.@Configuration 2.原生配置文件引入
Linux看进程所有的内存映射,Linux Pmap 命令：查看进程用了多少内存
06-07
是的，您可以使用Linux的pmap命令来查看进程使用了多少内存，以及进程中所有的内存映射。您可以使用以下命令来查看进程的内存映射： ``` pmap <pid> ``` 其中，`<pid>`是进程的ID号。该命令将显示进程中所有的内存映射，包括可执行文件、共享库、堆、栈等等。您可以结合其他命令，如`ps`命令来查看进程的ID号。例如: ``` ps -ef | grep <process_name> ``` 其中，`<process_name>`是进程的名称。该命令将显示出所有包含该进程名称的进程的信息，包括进程ID号。您可以使用这个ID号来执行pmap命令，查看进程的内存映射。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一切皆有迹可循

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值