Spring Security Single Sign On

最新推荐文章于 2022-04-28 18:31:25 发布
最新推荐文章于 2022-04-28 18:31:25 发布
阅读量247 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38765404/article/details/98227873
版权

1. 新建sso父工程 pom.xml如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.security</groupId>
    <artifactId>sso</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring.security.oauth2.autoconfigure.version>2.1.6.RELEASE</spring.security.oauth2.autoconfigure.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security.oauth.boot</groupId>
            <artifactId>spring-security-oauth2-autoconfigure</artifactId>
            <version>${spring.security.oauth2.autoconfigure.version}</version>
        </dependency>
    </dependencies>

    <modules>
        <module>sso-server</module>
        <module>sso-client_a</module>
        <module>sso-client_b</module>
    </modules>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>


</project>

2. 新建sso-server工程 pom.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>sso</artifactId>
        <groupId>com.security</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sso-server</artifactId>

</project>

3. 分别建立sso-client_a和sso-client_b子模块pom.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>sso</artifactId>
        <groupId>com.security</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sso-client_a</artifactId>
    <!-- 单独建立 -->
    <!-- <artifactId>sso-client_b</artifactId> -->

</project>

4. sso-service编写

package com.security.sso.authentication;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

/**
 * 认证相关的扩展点配置。配置在这里的bean，业务系统都可以通过声明同类型或同名的bean来覆盖安全
 * 模块默认的配置。
 */
@Configuration
public class AuthenticationBeanConfig {

    /**
     * 默认密码处理器
     *
     * @return
     */
    @Bean
    @ConditionalOnMissingBean(PasswordEncoder.class)
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

}

 

package com.security.sso.authentication;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

@Component(value = "userDetailsService")
public class DefaultUserDetailsService implements UserDetailsService {

    @Autowired
    private PasswordEncoder passwordEncoder;

    /* (non-Javadoc)
     * @see org.springframework.security.core.userdetails.UserDetailsService#loadUserByUsername(java.lang.String)
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        String password = passwordEncoder.encode("123456");
        System.out.println("用户名: ["+ username +"]，数据库密码: ["+ password +"]");
        User admin = new User(username, password,
                true, true, true, true,
                AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_USER"));
        return admin;
    }

}

 

package com.security.sso.authentication;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

@Configuration
@EnableAuthorizationServer
public class SsoAuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("healthy")
                .secret(passwordEncoder.encode("healthysecrect"))
                .authorizedGrantTypes("authorization_code", "refresh_token")
                .scopes("all")
                .redirectUris(
                        "http://localhost:8080/client1/login")
                .and()
                .withClient("demo")
                .secret(passwordEncoder.encode("demosecrect"))
                .authorizedGrantTypes("authorization_code", "refresh_token")
                .scopes("all")
                .redirectUris(
                        "http://localhost:8081/client2/login");
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(jwtTokenStore()).accessTokenConverter(jwtAccessTokenConverter());
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        // 客户端来向认证服务器获取签名的时候需要登录认证身份才能获取
        // 因为客户端需要用密钥解密jwt字符串
        security
                .tokenKeyAccess("isAuthenticated()")
                .passwordEncoder(passwordEncoder); // 密码加密策略;
    }

    @Bean
    public TokenStore jwtTokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey("imooc");
        return converter;
    }

}

 

package com.security.sso.authentication;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SsoSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and().csrf().disable()
             // .httpBasic()
                .formLogin()  // 更改为form表单登录
                .and()
                // 所有的请求都必须授权后才能访问
                .authorizeRequests()
                .antMatchers("/error").permitAll()
                .anyRequest()
                .authenticated();
    }

}

 

package com.security.sso.authentication;

import org.springframework.security.oauth2.provider.AuthorizationRequest;
import org.springframework.security.web.server.csrf.CsrfToken;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
import org.springframework.web.util.HtmlUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Iterator;
import java.util.Map;

/**
 * 自定义的授权页面
 */
@RestController
@SessionAttributes({"authorizationRequest"})
public class SsoWhitelabelApprovalEndpoint {

    public SsoWhitelabelApprovalEndpoint() {
    }

    @RequestMapping({"/oauth/confirm_access"})
    public ModelAndView getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
        final String approvalContent = this.createTemplate(model, request);
        if (request.getAttribute("_csrf") != null) {
            model.put("_csrf", request.getAttribute("_csrf"));
        }

        View approvalView = new View() {
            @Override
            public String getContentType() {
                return "text/html";
            }

            @Override
            public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
                response.setContentType(this.getContentType());
                response.getWriter().append(approvalContent);
            }
        };
        return new ModelAndView(approvalView, model);
    }

    protected String createTemplate(Map<String, Object> model, HttpServletRequest request) {
        AuthorizationRequest authorizationRequest = (AuthorizationRequest) model.get("authorizationRequest");
        String clientId = authorizationRequest.getClientId();
        StringBuilder builder = new StringBuilder();
        // style='display:none;'设置body不显示
        builder.append("<html><body style='display:none;'><h1>OAuth Approval</h1>");
        builder.append("<p>Do you authorize \"").append(HtmlUtils.htmlEscape(clientId));
        builder.append("\" to access your protected resources?</p>");
        builder.append("<form id=\"confirmationForm\" name=\"confirmationForm\" action=\"");
        String requestPath = ServletUriComponentsBuilder.fromContextPath(request).build().getPath();
        if (requestPath == null) {
            requestPath = "";
        }

        builder.append(requestPath).append("/oauth/authorize\" method=\"post\">");
        builder.append("<input name=\"user_oauth_approval\" value=\"true\" type=\"hidden\"/>");
        String csrfTemplate = null;
        CsrfToken csrfToken = (CsrfToken) ((CsrfToken) (model.containsKey("_csrf") ? model.get("_csrf") : request.getAttribute("_csrf")));
        if (csrfToken != null) {
            csrfTemplate = "<input type=\"hidden\" name=\"" + HtmlUtils.htmlEscape(csrfToken.getParameterName()) + "\" value=\"" + HtmlUtils.htmlEscape(csrfToken.getToken()) + "\" />";
        }

        if (csrfTemplate != null) {
            builder.append(csrfTemplate);
        }

        String authorizeInputTemplate = "<label><input name=\"authorize\" value=\"Authorize\" type=\"submit\"/></label></form>";
        if (!model.containsKey("scopes") && request.getAttribute("scopes") == null) {
            builder.append(authorizeInputTemplate);
            builder.append("<form id=\"denialForm\" name=\"denialForm\" action=\"");
            builder.append(requestPath).append("/oauth/authorize\" method=\"post\">");
            builder.append("<input name=\"user_oauth_approval\" value=\"false\" type=\"hidden\"/>");
            if (csrfTemplate != null) {
                builder.append(csrfTemplate);
            }

            builder.append("<label><input name=\"deny\" value=\"Deny\" type=\"submit\"/></label></form>");
        } else {
            builder.append(this.createScopes(model, request));
            builder.append(authorizeInputTemplate);
        }
        //  添加提交表单的事件
        builder.append("<script>document.getElementById('confirmationForm').submit()</script>");
        builder.append("</body></html>");
        return builder.toString();
    }

    private CharSequence createScopes(Map<String, Object> model, HttpServletRequest request) {
        StringBuilder builder = new StringBuilder("<ul>");
        Map<String, String> scopes = (Map) ((Map) (model.containsKey("scopes") ? model.get("scopes") : request.getAttribute("scopes")));
        Iterator var5 = scopes.keySet().iterator();

        while (var5.hasNext()) {
            String scope = (String) var5.next();
            String approved = "true".equals(scopes.get(scope)) ? " checked" : "";
            String denied = !"true".equals(scopes.get(scope)) ? " checked" : "";
            scope = HtmlUtils.htmlEscape(scope);
            builder.append("<li><div class=\"form-group\">");
            builder.append(scope).append(": <input type=\"radio\" name=\"");
            builder.append(scope).append("\" value=\"true\"").append(approved).append(">Approve</input> ");
            builder.append("<input type=\"radio\" name=\"").append(scope).append("\" value=\"false\"");
            builder.append(denied).append(">Deny</input></div></li>");
        }

        builder.append("</ul>");
        return builder.toString();
    }
}

yml

server:
  port: 9999
  servlet:
    context-path: /server

spring:
  security:
    user:
      password: 123456
package com.security.sso;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SsoServerApplication {
    /**
     * 官网文档: https://docs.spring.io/spring-security-oauth2-boot/docs/current/reference/html5/#boot-features-security-oauth2-single-sign-on
     * 客户端application.yml 需配置：user-info-uri 和 token-info-uri 不配置就会报错；可以参考官网文档
     *
     * OAuth Error error="invalid_grant", error_description="Invalid redirect: http://xxxx/login does not match one of the registered values: xxxx"
     * 如上错误：请检查com.security.sso.authentication.SsoAuthorizationServerConfig中的redirectUris()
     *
     * 自定义授权页面
     * @FrameworkEndpoint注解 的优先级没有@RestController的优先级高，直接定义同样的配置控制器路径即可，会优先使用自定义的处理；
     * 默认处理：org.springframework.security.oauth2.provider.endpoint.WhitelabelApprovalEndpoint
     * 自定义处理(默认直接提交表单)：com.security.sso.authentication.SsoWhitelabelApprovalEndpoint
     *
     *  Error creating bean with name 'jwtTokenServices'
     *  如上错误请检查：com.security.sso.authentication.SsoAuthorizationServerConfig&configure(ClientDetailsServiceConfigurer clients)中的secret(passwordEncoder.encode("xxx"))是否使用了加密；
     *
     */
    public static void main(String[] args) {
        SpringApplication.run(SsoServerApplication.class, args);
    }

}

5. 编写sso-client_a项目配置

package com.security.sso.client;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
@EnableOAuth2Sso // 开启单点登录
public class SsoClient1Application {

    public static void main(String[] args) {
        SpringApplication.run(SsoClient1Application.class, args);
    }

    //编写一个获取当前服务器的用户信息控制器
    @GetMapping("/user")
    public Authentication user(Authentication user){
        return user;
    }
}
security:
  oauth2:
    client:
      clientId: healthy
      clientSecret: healthysecrect
      user-authorization-uri: http://127.0.0.1:9999/server/oauth/authorize
      access-token-uri: http://127.0.0.1:9999/server/oauth/token
    resource:
      jwt:
        key-uri: http://127.0.0.1:9999/server/oauth/token_key
      user-info-uri: http://127.0.0.1:9999/server/user
      token-info-uri: http://127.0.0.1:9999/server/oauth/check_token
      preferTokenInfo: false

server:
  port: 8080
  servlet:
    context-path: /client1

 sso-client_b ---> resource ----> static ----> index.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>SSO Client1</title>
</head>
<body>
<h1>SSO Demo Client1</h1>
    <a href="http://localhost:8081/client2/index.html">访问Client2</a>
</body>
</html>

6. 编写sso-client_b

package com.security.sso.client;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
@EnableOAuth2Sso // 开启单点登录
public class SsoClient2Application {

    public static void main(String[] args) {
        SpringApplication.run(SsoClient2Application.class, args);
    }

    //编写一个获取当前服务器的用户信息控制器
    @GetMapping("/user")
    public Authentication user(Authentication user){
        return user;
    }
}
security:
  oauth2:
    client:
      clientId: demo
      clientSecret: demosecrect
      user-authorization-uri: http://127.0.0.1:9999/server/oauth/authorize
      access-token-uri: http://127.0.0.1:9999/server/oauth/token
    resource:
      jwt:
        key-uri: http://127.0.0.1:9999/server/oauth/token_key
      user-info-uri: http://127.0.0.1:9999/server/user
      token-info-uri: http://127.0.0.1:9999/server/oauth/check_token
      preferTokenInfo: false

server:
  port: 8081
  servlet:
    context-path: /client2

 sso-client_b ---> resource ----> static ----> index.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>SSO Client2</title>
</head>
<body>
<h1>SSO Demo Client2</h1>
    <a href="http://localhost:8080/client1/index.html">访问Client1</a>
</body>
</html>

7. 测试：

               http://localhost:8080/client1/user

               http://localhost:8081/client2/user

8. 官方文档:

               https://docs.spring.io/spring-security-oauth2-boot/docs/current/reference/html5/#boot-features-security-oauth2-single-sign-on

点滴1993
关注
专栏目录
SpringCloud Alibaba实战二十七 - Oauth2认证服务器自定义异常
飘渺Jam的博客
02-04 4083
前言今天内容主要是解决一位粉丝提的问题：在使用 Spring Security OAuth2 时如何自定义认证服务器返回异常。那么首先我们先以 Password模式为例看看在认证时会出现哪...
spring security权限控制
10-15
- **会话管理**：Spring Security还提供了会话管理功能，可以防止会话固定攻击（Session Fixation），控制会话超时，以及实现单点登录（Single Sign-On, SSO）。 通过分析"springsecuritydemo4"项目，我们可以学习...
遇坑OAuth2 error: error=“invalid_grant“, error_description=“Invalid redirect
ywdevil1314的博客
08-27 2万+
Handling OAuth2 error: error="invalid_grant", error_description="Invalid redirect: =http://www.baidu.com does not match one of the registered values." spring Outh2请求code时，请求code重定向时与坑！错误描述错误截图错误日志AuthorizationServerConfigurerAdapter配置如下原因如下关于解析回调url部分源码剖析
error: error=“invalid_grant“, does not match one of the registered values
m0_60725291的博客
08-05 3895
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Spring Security——自定义认证错误提示信息及自适应返回格式解决方案
无限迭代中......
02-20 2228
解决方案 package com.hailiu.web.handler; import com.hailiu.model.Log; import com.hailiu.web.bean.ResponseBean; import com.hailiu.web.util.HttpServletUtil; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; impor
does not match one of the registered values异常原因及对应方式
阁下何不踏风起
02-24 3797
转载自： https://blog.csdn.net/baidu_29609961/article/details/106230077 异常现象 有时候使用OAuth2做SSO时，客户端访问统一认证中心，经过验证通过，重定向返回后可能会遇到下列问题 OAuth Error error=“invalid_grant”, error_description=“Invalid redirect: http://localhost:8082/login does not match one of the
SpringSecurity Demo
08-28
这对于构建API或者实现单点登录（Single Sign-On, SSO）的场景非常有用。 **6. CSRF防护** Spring Security内置了跨站请求伪造（CSRF）防护，通过在表单提交中添加一个隐藏的CSRF令牌来防止这类攻击。这可以确保...
Spring Security整合CAS的示例代码
08-27
5. 当用户在CAS服务器上登出时，`SingleSignOutFilter`监听并同步客户端应用程序的会话，实现SSO登出。 **注意事项** - `client.url`和`cas.server.url`是需要替换的实际客户端和CAS服务器的URL。 - 数据库配置...
SpringSecurity
12-18
9. **企业级特性**：除了基本的安全功能，SpringSecurity还提供了许多企业级特性，如审计（Audit）、密码加密、单点登录（Single Sign-On, SSO）等。 在实际应用中，开发者通常会结合`security.jar`这样的依赖来...
spring spring security2.5 jar
01-08
4. **会话管理**：Spring Security提供了会话管理功能，可以防止会话固定攻击（Session Fixation）、实现会话超时以及单点登录（Single Sign-On, SSO）。 5. **异常处理**：当安全规则不满足时，Spring Security会...
OAuth Error错误提示error=“invalid_grant“
热门推荐
cauchy6317的博客
12-26 3万+
在Spring Security的Oauth2时，经常遇到error="invalid_grant"错误提示。 这种错误提示，有很多种情况。这里常见的就是我们的权限不匹配和重定向地址不匹配。对于权限的问题，笔者在[从源码看Spring Security的角色和权限之区别]这篇博文(https://blog.csdn.net/cauchy6317/article/details/85162225)...
随笔【oauth2】获取token认证/oauth/token返回{“error“: “invalid_grant“, “error_description“: “用户名不存在或者密码错误“}
亦碎流年的博客
04-28 6678
现要将feign调用改成restTemplate远程调用 请求如下地址： http://127.0.0.1:8083/user-service/oauth/token?client_id=abc&client_secret=abc&grant_type=password&username=test&password=test123&scope=server postman报错： { "error": "invalid_grant", ...
Spring security登录 显示用户名不存在或者密码错误
m0_67394360的博客
03-28 1749
本文章只是做简单记录下曾经踩到坑，如果有什么别的想法，也可以提点宝贵的意见 1、整合spring security，我就不过多的介绍； 2、区分这两个错误之前，需要判断为什么会用户名或者密码错误时都返回相同的异常。 原因： 解决思路：将此属性配置为false. 具体的操作： 1、在security配置类中编写DaoAuthenticationProvider，将hideUserNotFoundExceptions设置成false 2、在重写的configure方法中配置DaoAuthentication
从零开始搭建微服务：异常处理
余弦的自留地
05-11 2005
目前系统的异常响应都是以Spring内部构建好的默认的格式返回。这样的格式对于开发的友好度不是很好。 { "error": "invalid_grant", "error_description": "Bad credentials" } 下面我们通过自定义各种异常处理器，来将默认的异常响应转换为对我们友好的的格式响应。 认证服务器异常处理 默认情况下，当我们在获取令牌时输入错误的用户名或密码，系统返回如下格式响应: { "error": "invalid_grant",
百度小程序服务器出错,百度智能小程序错误码解读
weixin_36482579的博客
08-12 2033
百度OAuth2.0在接受验证授权请求时，授权服务器会按照OAuth2.0协议对本次请求参数、请求头部进行检验，若请求不合法或验证未通过，授权服务器会返回相应的错误信息。错误码返回信息简介错误码返回方式分两种：1、在浏览器访问请求授权Endpoint"https://openapi.baidu.com/oauth/2.0/authorize"时返回，直接在浏览器页面上显示错误信息。2、在应用的服务...
Spring Security OAuth2源码解析（一）
demon7552003的小本本
08-07 1078
目录 引入 AuthorizationServerEndpointsConfiguration 属性 AuthorizationEndpoint OAuth2RequestFactory DefaultOAuth2RequestFactory TokenEndpoint TokenGranter AuthorizationServerTokenServices DefaultTokenServices TokenStore AuthorizationServerSecu...
Spring-Security-OAuth2架构及源码浅析
weixin_34242509的博客
07-06 630
个人博客地址：blog.sqdyy.cn Spring Security OAuth2架构 Spring Security OAuth2是一个基于OAuth2封装的一个类库，它提供了构建Authorization Server、Resource Server和Client三种Spring应用程序角色所需要的功能。Spring Security OAuth需要与Spring Framework（...
浅谈spring security oauth2——授权码授权
WannaRunning的博客
10-24 732
上一篇梳理了获取Token接口的流程 https://blog.csdn.net/qq_29569183/article/details/109224073 这篇写一下授权码方式在获取token前的流程。由于授权码模式与密码等模式不同，在使用授权码获取token前还有两个步骤： 发起授权和确认授权。这两个步骤的接口是 /oauth/authorize 在org.springframework.security.oauth2.provider.endpoint.AuthorizationEndpoi.
springcloud2.2.1 oauth2实现用户认证授权及sso
MJ的博客
10-31 2659
基于cas实现的sso虽然实现比较简单，但功能实在是单一，性能（每个请求都有验证ticket），可靠性（必须保证认证服务器高可用）都得打个问号，而oauth2功能强大，整合spring security，jwt，能实现一套用户session管理，token刷新,权限控制，单点登录等，是一套强大的组合拳，oauth2也是第三方微信，QQ授权登录的核心。 一、基本原理 二、认证服务器雏形 1.依赖 <?xml version="1.0" encoding="UTF-8"?>...
Spring Security 单点登录实战教程
本文将深入讲解Spring Security的单点登录（Single Sign-On, SSO）实现原理，并通过一个简单的示例演示如何利用Spring Boot框架集成单点登录功能。首先，我们将介绍单点登录的概念，即用户在访问任何受保护的资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值