serviço parte autorizada a recursos de clientes de acesso sem expor os clientes Senha: questões a serem abordadas
Papel: proprietários de recursos, o aplicativo cliente (serviço de festa), servidor de autorização, os recursos do servidor
Modo de Código de Autorização:: Modo a necessidade de autorização do cliente depois de obter um código de autorização para obter forma, verifique pelo serviço senha de partido novo, o mais seguro e mais complexa
Modo Fácil: Os usuários não precisam um código de autorização para expor token retornado inseguro
Modo Senha: o aplicativo cliente precisa a senha do proprietário do recurso. Caso de uso credível sob link completo
Modo Cliente: nenhuma senha proprietário do recurso, é necessário apenas a verificação da senha aplicativo cliente, o servidor usa o servidor
Este teste é principalmente padrão de código de registro de demonstração é dividido em aplicativos de servidor dois autorização e recursos do servidor, o acompanhamento vai continuar a estender a autorização para um único servidor e vários recursos do servidor.
Procedimento de teste
Criar um servidor de autorização na imagem seguinte, o pacote de servidor de autorização está estruturado da seguinte
1, utilizando o correspondente pom importação arquivo dependente introduzidos, principalmente, os seguintes dependências
1) SpringBoot de segurança e web,
2) SpringSecurity 的 OAuth2
arquivo pom da seguinte forma
<? xml version = "1.0" encoding = "UTF-8"?>
<xmlns projeto = "http://maven.apache.org/POM/4.0.0" xmlns: xsi = "http: //www.w3 .org / 2001 / XMLSchema instância"
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> io.spring2go </ groupId>
<artifactId> authcode-servidor </ artifactId>
<versão> 0.0.1-SNAPSHOT </ version>
<embalagem> jar </ embalagem>
<name> authcode-servidor </ name>
<description> projeto demo para a Primavera de inicialização </ description>
<pai>
<groupId> org.
<relativePath />springframework.boot </ groupId>
<artifactId> spring-boot-starter-parent </ artifactId>
<version> 1.5.10.RELEASE </ version> <! - pai de pesquisa a partir do repositório ->
</ parent>
<properties>
<project.build.sourceEncoding> UTF-8 </project.build.sourceEncoding>
<project .reporting.outputEncoding> UTF-8 </project.reporting.outputEncoding>
<java.version> 1,8 </java.version>
</ propriedades>
<dependências>
<dependência>
<groupId> org.springframework.boot </ groupId>
<artifactId> spring-boot-starter-segurança </ artifactId>
</ dependency>
<dependency>
<groupId> org.springframework.boot </ groupId>
<artifactId> spring-boot-starter-web </ artifactId>
</ dependency> <! - para OAuth 2.0 ->
<groupId> org.springframework.security.oauth </ groupId>
<artifactId> spring-security-oauth2 </ artifactId>
</ dependency>
<dependency>
<groupId> org.springframework.boot </ groupId>
<artifactId> spring-boot-starter-test </ artifactId>
<scope> test </ scope>
</ dependency>
<dependency>
<groupId> org.springframework.security </ groupId>
<artifactId> spring-security-test </ artifactId>
<scope> test </ scope>
</ dependency>
</ dependencies>
<build>
<dependency>
<plugins>
<plug-in>
<groupId> org.springframework.boot </ groupId>
<artifactId> spring-boot-maven-plugin </ artifactId>
</ plugin>
</ plugins>
</ build>
</ project>
2 Modificar application.properties set senha do usuário
# Spring Security Definir security.user.name = bobo security.user.password = xyz
arquivos de inicialização SpringBoot 3 Faça
empacotar com.test.authcodeserver;
importação org.springframework.boot.SpringApplication;
importação org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
AuthCodeServerApplication classe pública {
public static void main (String [] args) {
SpringApplication.run (AuthCodeServerApplication.class, args);
}
}
4 Set Autorizado Código de serviço
empacotar com.test.authcodeserver.config;
importação org.springframework.context.annotation.Bean;
importação org.springframework.context.annotation.Configuration;
importação org.springframework.context.annotation.Primary;
importação org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
importação org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
importação org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
importação org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
importação org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
org.springframework.security.oauth2.provider.token.DefaultTokenServices importação;
importação org.springframework.security.oauth2.provider.token.TokenStore;
importação org.springframework.security.oauth2.provider.token.store.InMemoryTokenStore;
importação org.springframework.security.oauth2.provider.token.store.JdbcTokenStore;
@Configuration
@EnableAuthorizationServer
classe pública AuthCodeServerConfig estende AuthorizationServerConfigurerAdapter {
@Override
pública configure void (última AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
oauthServer.tokenKeyAccess ( "permitAll ()")
.checkTokenAccess ( "isAuthenticated ()");
}
@Override
configure public void (clientes ClientDetailsServiceConfigurer)
throws Exception {
// JdbcClientDetailsService pode gerenciar dinamicamente os dados do cliente de banco de dados
// http: // localhost :? 8080 / oauth / autorizar client_id = testclientid & redirect_uri = http: // localhost: 9001 / authCodeCallback & response_type = código read_userinfo & scope =
clients.inMemory ()
.withClient ( "testclientid") // clientId :( necessário) usado para identificar o cliente Id.
.secret ( "1234") // Segredo :( necessidade de um cliente confiável) código de segurança do cliente, se houver.
.redirectUris ( "HTTP: // localhost: 9001 / authCodeCallback") // aplicação cliente é responsável por obter o código de autorização Endpoint
.authorizedGrantTypes ( "authorization_code") // modo Código de autorização
.scopes ( "read_userinfo", " "); // escopo: para limitar o acesso a uma gama de clientes, se ela estiver vazia (o padrão), então o cliente tem acesso total para o intervalo.
}
}
5 Iniciar serviço SpringBoot
6 cliente do servidor de autorização de acesso de serviço, visite o seguinte url Tonggu código de autorização
http: // localhost: 8080 / oauth / autorizar client_id = testclientid & redirect_uri = http: // localhost: 9001 / authCodeCallback & response_type = código & scope = read_userinfo
Após a conclusão do acesso irá redirecionar de volta para o cliente eo servidor retorna um código de autorização como um parâmetro, que localhost: 9001 é o aplicativo cliente
7 cliente usando o código de autorização para ter acesso à retornou símbolo
parâmetros de solicitação transmissão são os seguintes
url: http: // localhost: 8080 / oauth / símbolo
code = ifz2BV & grant_type = authorization_code & redirect_uri = http% 3A% 2F% 2Flocalhost% 3A9001 &% 2FauthCodeCallback escopo = read_userinfo
de dados simbicos obtido
}
Acima de servidor de autorização é simples para ser concluída, e vai fazer o seguinte servidor de recursos
-------------------------------------------------- ------------------------------------------------
servidor de recursos
estrutura de pacotes 0 recursos do servidor
Um servidor de autenticação de configuração do servidor de recursos, método de autenticação RemoteTokenServices recuperado para autenticar o token
empacotar com.test.resourceserver.config;
importação org.springframework.beans.factory.annotation.Autowired;
importação org.springframework.context.annotation.Bean;
importação org.springframework.context.annotation.Configuration;
importação org.springframework.context.annotation.Primary;
importação org.springframework.security.config.annotation.web.builders.HttpSecurity;
importação org.springframework.security.config.http.SessionCreationPolicy;
importação org.springframework.security.core.AuthenticationException;
importação org.springframework.security.oauth2.common.OAuth2AccessToken;
importação org.springframework.security.oauth2.common.exceptions.InvalidTokenException;
importação org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
importação org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
importação org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
importação org.springframework.security.oauth2.provider.OAuth2Authentication;
org.springframework.security.oauth2.provider.token.DefaultTokenServices importação;
org.springframework.security.oauth2.provider.token.RemoteTokenServices importação;
org.springframework.security.oauth2.provider.token.ResourceServerTokenServices importação;
importação org.springframework.security.web.AuthenticationEntryPoint;
importação javax.servlet.ServletException;
importação javax.servlet.http.HttpServletRequest;
importação javax.servlet.http.HttpServletResponse;
importação Java.io.IOException; //资源服务配置
@Configuration
@EnableResourceServer
classe pública OAuth2ResourceConfig estende ResourceServerConfigurerAdapter {
@Primary
@Bean
RemoteTokenServices públicas tokenServices () {
RemoteTokenServices finais tokenService = new RemoteTokenServices ();
tokenService.setCheckTokenEndpointUrl ( "http: // localhost: 8080 / oauth / check_token");
tokenService.setClientId ( "testclientid");
tokenService.setClientSecret ( "1234");
voltar tokenService;
}
@Override
pública configure void (HttpSecurity http) throws Exception { // http.sessionManagement (). SessionCreationPolicy (SessionCreationPolicy.IF_REQUIRED)
// .e ()
// .authorizeRequests ()
// .anyRequest ()
// .authenticated ()
// .e ()
// .requestMatchers ()
// .antMatchers ( "/ api / **");
. http.sessionManagement () sessionCreationPolicy (. SessionCreationPolicy IF_REQUIRED )
.e ()
.authorizeRequests () anyRequest () permitAll ()..;
}
}
2 fornecem uma interface API externa
empacotar com.test.resourceserver.api;
importação org.springframework.http.ResponseEntity;
importação org.springframework.security.core.context.SecurityContextHolder;
importação org.springframework.security.core.userdetails.User;
importação org.springframework.stereotype.Controller;
importação org.springframework.web.bind.annotation.RequestMapping;
@Controller
classe pública UserController { //资源API
@RequestMapping ( "/ api / userinfo")
ResponseEntity pública <UserInfo> getUserInfo () {
user String = (String) SecurityContextHolder.getContext ()
.getAuthentication () getPrincipal (.);
Cordas email = usuário + "@ test.com";
UserInfo userInfo = novo UserInfo ();
userInfo.setName (utilizador);
userInfo.setEmail (e-mail);
retorno ResponseEntity.ok (userInfo);
}
}
chamada getUserInfo
http: // localhost: 8004 / api / userinfo
autorização: Portador 638aa01c-4ccd-4873-ab86-d46f22aea091
Retorna o servidor de recursos após o resultado da chamada
Neste ponto, uma chamada de recursos separado servidor servidor de recursos e autenticação é longo.