spring-oauth2原理及使用（REST)

最新推荐文章于 2024-08-12 12:35:47 发布
最新推荐文章于 2024-08-12 12:35:47 发布
阅读量683 收藏 2
点赞数
分类专栏： spring security 文章标签： java 测试 php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_123/article/details/82618539
版权

spring-oauth2 (bearer)是基于spring-security的验证机制，对于第三方访问受限资源时通过token机制来验证

验证steps：



 通过时序图来看一下，验证方式：

 

发送username, password, client_id, client_secret, grant_type到server

 

server返回包括access_token, token_type, refresh_token, expires_in



 其中，expires_in有效期，如果超期了，refresh_token起作用，如下：

使用refresh_token重新发起验证请求



 来看一下，如何通过spring配置，完成上面的验证机制：

 

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:oauth="http://www.springframework.org/schema/security/oauth2"
    xmlns:sec="http://www.springframework.org/schema/security" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/security/oauth2 http://www.springframework.org/schema/security/spring-security-oauth2-1.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
 
    <sec:http pattern="/oauth/token" create-session="stateless"
        authentication-manager-ref="authenticationManager">
        <sec:intercept-url pattern="/oauth/token" access="IS_AUTHENTICATED_FULLY" />
        <sec:anonymous enabled="false" />
        <sec:http-basic entry-point-ref="clientAuthenticationEntryPoint" />
        <sec:custom-filter ref="clientCredentialsTokenEndpointFilter" before="BASIC_AUTH_FILTER" />
        <sec:access-denied-handler ref="oauthAccessDeniedHandler" />
    </sec:http>
 
    <sec:http pattern="/protected/**" create-session="never"
        entry-point-ref="oauthAuthenticationEntryPoint">
        <sec:anonymous enabled="false" />
        <sec:intercept-url pattern="/protected/**" method="GET" access="IS_AUTHENTICATED_FULLY" />
        <sec:custom-filter ref="resourceServerFilter" before="PRE_AUTH_FILTER" />
        <sec:access-denied-handler ref="oauthAccessDeniedHandler" />
    </sec:http>
 
    <bean id="oauthAuthenticationEntryPoint"
        class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint">
    </bean>
 
    <bean id="clientAuthenticationEntryPoint"
        class="org.springframework.security.oauth2.provider.error.OAuth2AuthenticationEntryPoint">
        <property name="realmName" value="springsec/client" />
        <property name="typeName" value="Basic" />
    </bean>
 
    <bean id="oauthAccessDeniedHandler"
        class="org.springframework.security.oauth2.provider.error.OAuth2AccessDeniedHandler">
    </bean>
 
    <bean id="clientCredentialsTokenEndpointFilter"
        class="org.springframework.security.oauth2.provider.client.ClientCredentialsTokenEndpointFilter">
        <property name="authenticationManager" ref="authenticationManager" />
    </bean>
 
    <sec:authentication-manager alias="authenticationManager">
        <sec:authentication-provider user-service-ref="clientDetailsUserService" />
    </sec:authentication-manager>
 
    <bean id="clientDetailsUserService"
        class="org.springframework.security.oauth2.provider.client.ClientDetailsUserDetailsService">
        <constructor-arg ref="clientDetails" />
    </bean>
 
    <bean id="clientDetails" class="it.iol.oauthaaa.security.AAAGuestServiceImpl">
        <property name="id" value="mysupplycompany" />
        <property name="secretKey" value="mycompanykey" />
    </bean>
 
    <sec:authentication-manager id="userAuthenticationManager">
        <sec:authentication-provider ref="customUserAuthenticationProvider" />
    </sec:authentication-manager>
 
    <bean id="customUserAuthenticationProvider"
        class="it.iol.oauthaaa.security.AAAUserAuthenticationProvider">
    </bean>
 
    <oauth:authorization-server
        client-details-service-ref="clientDetails" token-services-ref="tokenServices">
        <oauth:authorization-code />
        <oauth:implicit/>
        <oauth:refresh-token/>
        <oauth:client-credentials />
        <oauth:password authentication-manager-ref="userAuthenticationManager"/>
    </oauth:authorization-server>
 
    <oauth:resource-server id="resourceServerFilter"
        resource-id="springsec" token-services-ref="tokenServices" />
 
    <bean id="tokenStore"
        class="org.springframework.security.oauth2.provider.token.InMemoryTokenStore" />
 
    <bean id="tokenServices"
        class="org.springframework.security.oauth2.provider.token.DefaultTokenServices">
        <property name="tokenStore" ref="tokenStore" />
        <property name="supportRefreshToken" value="true" />
        <property name="accessTokenValiditySeconds" value="120"></property>
        <property name="clientDetailsService" ref="clientDetails" />
    </bean>
 
    <mvc:annotation-driven />
 
    <mvc:default-servlet-handler />
 
    <context:annotation-config/>
 
    <bean id="MyResource" class="it.iol.oauthaaa.resources.UserResource"></bean>
    <bean id="aaaProxy" class="it.iol.oauthaaa.security.AAAProxy"></bean
</beans>

 通过发起/oauth/token 请求， filter拦截处理，具体代码：

 

 

@Service
public class AAAGuestServiceImpl implements ClientDetailsService {
 
    private String id;
    private String secretKey;
 
    @Override
    public ClientDetails loadClientByClientId(String clientId)
            throws OAuth2Exception {
 
        if (clientId.equals(id))
        {
            List<String> authorizedGrantTypes = new ArrayList<String>();
            authorizedGrantTypes.add("password");
            authorizedGrantTypes.add("refresh_token");
            authorizedGrantTypes.add("client_credentials");
 
            BaseClientDetails clientDetails = new BaseClientDetails();
            clientDetails.setClientId(id);
            clientDetails.setClientSecret(secretKey);
            clientDetails.setAuthorizedGrantTypes(authorizedGrantTypes);
 
            return clientDetails;
        }
        else {
            throw new NoSuchClientException("No client recognized with id: "
                    + clientId);
        }
    }
 
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getSecretKey() {
        return secretKey;
    }
 
    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }
 
}

 现在基于username和passwd来验证（grant_type=password), 在<oauth:authorization-server>的拦截userAuthenticationManager中：

 

 

public class AAAUserAuthenticationProvider
 
implements AuthenticationProvider {
 
    @Autowired
    AAAProxy aaaProxy;
 
    @Override
    public Authentication authenticate(Authentication authentication)
            throws AuthenticationException {
 
        boolean result = aaaProxy.isValidUser(authentication.getPrincipal()
                .toString(), authentication.getCredentials().toString());
 
        if (result) {
            List<GrantedAuthority> grantedAuthorities =
 
new ArrayList<GrantedAuthority>();
            AAAUserAuthenticationToken auth =
 
new AAAUserAuthenticationToken(authentication.getPrincipal(),
            authentication.getCredentials(), grantedAuthorities);
 
            return auth;
        } else {
            throw new BadCredentialsException("Bad User Credentials.");
        }
    }
 
    public boolean supports(Class<?> arg0) {
        return true;
    }
}

 这里的aaproxy是真正来验证user的（代理机制）不细化了，如果用户是有效，做三件事：

 

1. 在框架的security上下文中更新对象

2. TokenService将会生成一个新的token

3. TokenStore将会保存这个token

然后token就发给request的client了

最后这里是token和resource的代码：

 

public class AAAUserAuthenticationToken 
 
extends AbstractAuthenticationToken {
 
    private static final long serialVersionUID = -1092219614309982278L;
    private final Object principal;
    private Object credentials;
 
    public AAAUserAuthenticationToken(Object principal, Object credentials,
            Collection<? extends GrantedAuthority> authorities) {
        super(authorities);
        this.principal = principal;
        this.credentials = credentials;
        super.setAuthenticated(true);
    }
 
    public Object getCredentials() {
        return this.credentials;
    }
 
    public Object getPrincipal() {
        return this.principal;
    }
}

 

@Path("/userresource")
public class UserResource {
 
    @GET
    @Path("/userprofile")
    public String getUserProfile(){
        return "Welcome in protected Area. User enabled.";
    }
}

 

 

测试：

使用了Fidder， 可以用curl，wget（what ever you want)

请求：

/OAuthAAA/oauth/token ?username=myuser&password=mypassword
&client_id=mysupplycompany&client_secret=mycompanykey&grant_type=password



 
 

资源请求：

/OAuthAAA/protected/userresource/userprofile
Authorization: Bearer 5cf0732b-6bbb-40c7-8fab-dcfefcc2fcfe


 

 

 

补充：AAProxy的代码：

 

package it.iol.oauthaaa.security;
 
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.Proxy.Type;
import java.util.List;
 
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
 
public class AAAProxy {
 
    private Proxy proxy;
    private RestTemplate template;
 
    public AAAProxy() {
        proxy = new Proxy(Type.HTTP, new InetSocketAddress(
                "proxy.abc.net", 3001));
 
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
 
        requestFactory.setProxy(proxy);
 
        template = new RestTemplate(requestFactory);
    }
 
    public boolean isValidUser(String user, String password) {
 
        MultiValueMap<String, String> map = new LinkedMultiValueMap<String, String>();
        map.add("user", user);
        map.add("password", password);
 
        HttpEntity<String> response = template.postForEntity(
                "https://authentication.local/auth", map,
                String.class);
 
        HttpHeaders headers = response.getHeaders();
 
        List<String> cookies = headers.get("Set-Cookie");
 
        for (String cookie : cookies) {
            if (cookie.indexOf("Auth")!=-1)
                return true;
        }
 
        return false;
    }
 
}

 

 

当grant_type="client_credentials"时的验证：



 

 

 相关资源：

https://raymondhlee.wordpress.com/2014/12/21/implementing-oauth2-with-spring-security/

https://github.com/spring-projects/spring-security-oauth/blob/master/spring-security-oauth2/src/main/java/org/springframework/security/oauth2/provider/authentication/BearerTokenExtractor.java

https://github.com/spring-projects/spring-security-oauth/tree/master/spring-security-oauth2

https://developer.linkedin.com/docs/oauth2

http://api-doc.assembla.com/content/authentication.html

 

iteye_123
关注
专栏目录
OAuth2.0认证原理
weixin_47073925的博客
06-01 7781
OAuth2.0认证原理 一.OAuth是什么？ OAuth的英文全称是Open Authorization，它是一种开放授权协议。OAuth目前共有2个版本，2007年12月的1.0版（之后有一个修正版1.0a）和2010年4月的2.0版，1.0版本存在严重安全漏洞，而2.0版解决了该问题，下面简单谈一下我对OAuth2.0的理解。 二.OAuth2.0有什么用？ 引用一下OAuth2.0中文文档中的介绍： 1.需要第三方应用存储资源所有者的凭据，以供将来使用，通常是
OAuth2.0认证和授权原理
Just Code
10-04 2020
什么是OAuth授权？   一、什么是OAuth协议 OAuth(开放授权)是一个开放标准。 允许第三方网站在用户授权的前提下访问在用户在服务商那里存储的各种信息。 而这种授权无需将用户提供用户名和密码提供给该第三方网站。 OAuth允许用户提供一个令牌给第三方网站，一个令牌对应一个特定的第三方网站，同时该令牌只能在特定的时间内访问特定的资源。   二、OAuth的原理和授...
微服务认证系列一：SpringCloud OAuth2
最新发布
wanping15825992341的博客
08-12 497
OAuth(开放授权)是一个开放协议/标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方应用或分享他们数据的所有内容。OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0Spring Cloud OAuth2 是 Spring Cloud 体系对OAuth2协议的实现，可以用来做多个微服务的统一认证(验证身份合法性)授权(验证权限)。
spring oauth2相关资料
zhao1949的专栏
03-21 803
理解OAuth 2.0  ***** http://www.ruanyifeng.com/blog/2014/05/oauth_2_0.html  Secure REST API with oauth2 （翻译） ***** http://blog.csdn.net/haiyan_qi/article/details/52384734 https://spring.io/gui
Spring中的OAuth2
qq_45726327的博客
03-24 2086
Auth” 表示 “授权” Authorization“O” 是 Open 的简称，表示 “开放”连在一起就表示，OAuth2是一种开放授权协议。
spring-security-oauth2-rest:使用Spring Security Oauth2保护REST API
05-07
Spring OAuth 2.0演示 Oauth2刷新令牌请求 http : // localhost:8080/oauth2/oauth/token?grant_type=password&client_id=rajith-client-id&client_secret=12345&username=rajith&password=password { access_...
spring-boot-security-oauth2-example:使用Spring Security OAuth2保护REST API
05-24
Spring Boot Security OAuth...使用Spring Security OAuth2保护REST API 要运行此仓库，请遵循以下命令： 将此命令粘贴到您的终端 mvn clean spring-boot:run 启动POSTMAN生成令牌 无令牌访问 使用令牌访问资源
Using-Spring-Oauth2-to-secure-REST：该项目是Spring Oauth教程的一部分
01-31
使用Spring Oauth2保护REST 该项目是有关Spring上的Oauth2身份验证的教程的一部分。 您可以在阅读材料。 教程摘要 如何使用Spring Boot从头开始创建REST服务。 我们将使用Oauth2协议，JSON Web令牌或JWT保护它的...
spring-security-oauth：刚刚宣布-“学习Spring Security OAuth”：
02-19
oauth-rest rest-基于新的Spring Security 5堆栈的授权服务器（Keycloak），资源服务器和Angular App oauth-jwt jwt-基于新的Spring Security 5堆栈的授权服务器（Keycloak），资源服务器和Angular App，专注于JWT...
spring-security-oauth2-2.0.3.jar(包括jar包，源码，doc)
10-11
Spring Security OAuth2是一个广泛使用的Java库，用于在Spring应用程序中实现OAuth2协议，提供安全授权服务。OAuth2是一种授权框架，允许第三方应用在用户许可的情况下访问其私有资源，如在社交媒体上的数据。2.0.3....
spring-boot spring-security-oauth2 完整demo
11-22
spring-boot spring-security-oauth2 完整demo，可以使用微信的方式来获取token和查看资源，注意看代码中的备注
Spring Security OAuth2认证授权示例详解
08-25
主要介绍了Spring Security OAuth2认证授权示例详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
OAuth 2.0的认证原理
keehom的博客
06-17 1254
使用 OAuth 2.0 认证的的好处是显然易见的。你只需要用同一个账号密码，就能在各个网站进行访问，而免去了在每个网站都进行注册的繁琐过程。本文将介绍 OAuth 2.0 的原理，并基于 Spring Security 和 GitHub 账号，来演示 OAuth 2.0 的认证的过程。什么是 OAuth 2.0OAuth 2.0 的规范可以参考 ：RFC 6749OAuth 是一个开放标准，...
spring-oauth2总结
越自律越自由
06-12 726
OAuth2协议流程 授权服务器也叫认证服务器(Authorization Server) 1、用户打开客户端以后，客户端要求用户给予授权。 2、用户同意给予客户端授权。 3、客户端使用上一步获得的授权，向认证服务器申请令牌。 4、认证服务器对客户端进行认证以后，确认无误，同意发放令牌。 5、客户端使用令牌，向资源服务器申请获取资源。 6、资源服务器确认令牌无误，同意向客户端开放资源。 第2步很重...
oauth2认证模式原理梳理
yrsg666的博客
05-26 288
授权码模式：https://blog.csdn.net/qq_33542154/article/details/89851150?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.none
使用OAuth2令牌的安全REST服务
最佳 Java 编程
06-05 448
1.简介 在本教程中，我们将介绍如何将Spring Security与OAuth结合使用以保护REST服务。 在演示应用程序中，可以使用路径模式（ / api / ** ）访问服务器上受保护的REST资源，以便基于该路径的请求URL映射到不同的控制器方法。 这意味着 - 路径中没有' / api '的任何REST请求URL都将保持无效 ，因为这些URL与任何控制器映射都不匹配。 完...
SpringOAuth2授权流程分析
hungteshun的专栏
08-08 3000
SpringOAuth2授权流程分析
spring-oauth2原理及使用
yueguanyun的专栏
08-04 7006
spring-oauth2原理及使用 转自：http://patrick002.iteye.com/blog/2207795 spring-oauth2 (bearer)是基于spring-security的验证机制，对于第三方访问受限资源时通过token机制来验证 验证steps：  通过时序图来看一下，验证方式：   发送username, password, clie
Spring Boot与JWT-Spring Security实现REST API安全防护
"本文主要探讨了如何在Spring Boot应用中使用JWT（Json Web Token）和Spring Security来保护RESTful API，适用于需要理解API安全性的开发者。文中提到了三种常见的鉴权方式，并着重讲解了JWT的工作原理和流程。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值