Spring REST API + OAuth2 + Angular (използвайки наследения стек Spring OAuth)

1. Общ преглед

В този урок ще осигурим REST API с OAuth и ще го използваме от прост Angular клиент.

Приложението, което ще разработим, ще се състои от четири отделни модула:

  • Сървър за оторизация
  • Ресурсен сървър
  • Имплицитен потребителски интерфейс - приложение отпред, използващо неявния поток
  • UI парола - интерфейсно приложение, използващо Password Flow

Забележка : тази статия използва наследения проект Spring OAuth. За версията на тази статия, използваща новия стек Spring Security 5, погледнете нашата статия Spring REST API + OAuth2 + Angular.

Добре, нека скочим направо.

2. Сървърът за оторизация

Първо, нека започнем да настройваме сървър за упълномощаване като просто приложение за пролетно стартиране.

2.1. Maven конфигурация

Ще настроим следния набор от зависимости:

 org.springframework.boot spring-boot-starter-web   org.springframework spring-jdbc   mysql mysql-connector-java runtime   org.springframework.security.oauth spring-security-oauth2 

Имайте предвид, че използваме spring-jdbc и MySQL, защото ще използваме JDBC-подкрепена реализация на хранилището на маркери.

2.2. @EnableAuthorizationServer

Сега нека започнем да конфигурираме сървъра за оторизация, отговорен за управлението на маркерите за достъп:

@Configuration @EnableAuthorizationServer public class AuthServerOAuth2Config extends AuthorizationServerConfigurerAdapter { @Autowired @Qualifier("authenticationManagerBean") private AuthenticationManager authenticationManager; @Override public void configure( AuthorizationServerSecurityConfigurer oauthServer) throws Exception { oauthServer .tokenKeyAccess("permitAll()") .checkTokenAccess("isAuthenticated()"); } @Override public void configure(ClientDetailsServiceConfigurer clients) throws Exception { clients.jdbc(dataSource()) .withClient("sampleClientId") .authorizedGrantTypes("implicit") .scopes("read") .autoApprove(true) .and() .withClient("clientIdPassword") .secret("secret") .authorizedGrantTypes( "password","authorization_code", "refresh_token") .scopes("read"); } @Override public void configure( AuthorizationServerEndpointsConfigurer endpoints) throws Exception { endpoints .tokenStore(tokenStore()) .authenticationManager(authenticationManager); } @Bean public TokenStore tokenStore() { return new JdbcTokenStore(dataSource()); } }

Забележи, че:

  • За да запазим жетоните, използвахме JdbcTokenStore
  • Регистрирахме клиент за типа „ имплицитен “ грант
  • Регистрирахме друг клиент и упълномощихме типовете грантове „ парола “, „ авторизационен_код “ и „ опресняване_токен
  • За да използваме типа на предоставяне „ парола “, трябва да свържем и използваме боб AuthenticationManager

2.3. Конфигурация на източника на данни

След това нека конфигурираме нашия източник на данни да се използва от JdbcTokenStore :

@Value("classpath:schema.sql") private Resource schemaScript; @Bean public DataSourceInitializer dataSourceInitializer(DataSource dataSource) { DataSourceInitializer initializer = new DataSourceInitializer(); initializer.setDataSource(dataSource); initializer.setDatabasePopulator(databasePopulator()); return initializer; } private DatabasePopulator databasePopulator() { ResourceDatabasePopulator populator = new ResourceDatabasePopulator(); populator.addScript(schemaScript); return populator; } @Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName")); dataSource.setUrl(env.getProperty("jdbc.url")); dataSource.setUsername(env.getProperty("jdbc.user")); dataSource.setPassword(env.getProperty("jdbc.pass")); return dataSource; }

Имайте предвид, че тъй като използваме JdbcTokenStore , трябва да инициализираме схемата на базата данни, така че използвахме DataSourceInitializer - и следната SQL схема:

drop table if exists oauth_client_details; create table oauth_client_details ( client_id VARCHAR(255) PRIMARY KEY, resource_ids VARCHAR(255), client_secret VARCHAR(255), scope VARCHAR(255), authorized_grant_types VARCHAR(255), web_server_redirect_uri VARCHAR(255), authorities VARCHAR(255), access_token_validity INTEGER, refresh_token_validity INTEGER, additional_information VARCHAR(4096), autoapprove VARCHAR(255) ); drop table if exists oauth_client_token; create table oauth_client_token ( token_id VARCHAR(255), token LONG VARBINARY, authentication_id VARCHAR(255) PRIMARY KEY, user_name VARCHAR(255), client_id VARCHAR(255) ); drop table if exists oauth_access_token; create table oauth_access_token ( token_id VARCHAR(255), token LONG VARBINARY, authentication_id VARCHAR(255) PRIMARY KEY, user_name VARCHAR(255), client_id VARCHAR(255), authentication LONG VARBINARY, refresh_token VARCHAR(255) ); drop table if exists oauth_refresh_token; create table oauth_refresh_token ( token_id VARCHAR(255), token LONG VARBINARY, authentication LONG VARBINARY ); drop table if exists oauth_code; create table oauth_code ( code VARCHAR(255), authentication LONG VARBINARY ); drop table if exists oauth_approvals; create table oauth_approvals ( userId VARCHAR(255), clientId VARCHAR(255), scope VARCHAR(255), status VARCHAR(10), expiresAt TIMESTAMP, lastModifiedAt TIMESTAMP ); drop table if exists ClientDetails; create table ClientDetails ( appId VARCHAR(255) PRIMARY KEY, resourceIds VARCHAR(255), appSecret VARCHAR(255), scope VARCHAR(255), grantTypes VARCHAR(255), redirectUrl VARCHAR(255), authorities VARCHAR(255), access_token_validity INTEGER, refresh_token_validity INTEGER, additionalInformation VARCHAR(4096), autoApproveScopes VARCHAR(255) );

Имайте предвид, че не е задължително да се нуждаем от изричния компонент DatabasePopulator - можем просто да използваме schema.sql - който Spring Boot използва по подразбиране .

2.4. Конфигурация на защитата

И накрая, нека защитим сървъра за оторизация.

Когато клиентското приложение трябва да придобие маркер за достъп, то ще го направи след прост процес за удостоверяване, задвижван от формуляр за вход:

@Configuration public class ServerSecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("john").password("123").roles("USER"); } @Override @Bean public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } @Override protected void configure(HttpSecurity http) throws Exception { http.authorizeRequests() .antMatchers("/login").permitAll() .anyRequest().authenticated() .and() .formLogin().permitAll(); } }

Бърза бележка тук е, че конфигурацията за вход във формуляра не е необходима за потока на паролата - само за неявния поток - така че може да можете да го пропуснете в зависимост от това какъв поток OAuth2 използвате.

3. Ресурсният сървър

Сега, нека обсъдим ресурсния сървър; това е по същество REST API, който в крайна сметка искаме да можем да консумираме.

3.1. Maven конфигурация

Нашата конфигурация на Resource Server е същата като предишната конфигурация на приложението на Authorization Server.

3.2. Конфигурация на Token Store

След това ще конфигурираме нашия TokenStore за достъп до същата база данни, която сървърът за оторизация използва за съхраняване на маркери за достъп:

@Autowired private Environment env; @Bean public DataSource dataSource() { DriverManagerDataSource dataSource = new DriverManagerDataSource(); dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName")); dataSource.setUrl(env.getProperty("jdbc.url")); dataSource.setUsername(env.getProperty("jdbc.user")); dataSource.setPassword(env.getProperty("jdbc.pass")); return dataSource; } @Bean public TokenStore tokenStore() { return new JdbcTokenStore(dataSource()); }

Имайте предвид, че за тази проста реализация ние споделяме хранилището на SQL, подкрепено от маркери, въпреки че сървърите за оторизация и ресурси са отделни приложения.

Причината, разбира се, е, че Resource Server трябва да може да проверява валидността на маркерите за достъп, издадени от Authorization Server.

3.3. Услуга за отдалечен токен

Вместо да използваме TokenStore в нашия ресурсен сървър, можем да използваме RemoteTokeServices :

@Primary @Bean public RemoteTokenServices tokenService() { RemoteTokenServices tokenService = new RemoteTokenServices(); tokenService.setCheckTokenEndpointUrl( "//localhost:8080/spring-security-oauth-server/oauth/check_token"); tokenService.setClientId("fooClientIdPassword"); tokenService.setClientSecret("secret"); return tokenService; }

Забележи, че:

  • Тази RemoteTokenService ще използва CheckTokenEndPoint на Authorization Server, за да провери AccessToken и да получи обект за удостоверяване от него.
  • The can be found at AuthorizationServerBaseURL +”/oauth/check_token
  • The Authorization Server can use any TokenStore type [JdbcTokenStore, JwtTokenStore, …] – this won't affect the RemoteTokenService or Resource server.

3.4. A Sample Controller

Next, let's implement a simple controller exposing a Foo resource:

@Controller public class FooController { @PreAuthorize("#oauth2.hasScope('read')") @RequestMapping(method = RequestMethod.GET, value = "/foos/{id}") @ResponseBody public Foo findById(@PathVariable long id) { return new Foo(Long.parseLong(randomNumeric(2)), randomAlphabetic(4)); } }

Note how the client needs the “read” scope to access this Resource.

We also need to enable global method security and configure MethodSecurityExpressionHandler:

@Configuration @EnableResourceServer @EnableGlobalMethodSecurity(prePostEnabled = true) public class OAuth2ResourceServerConfig extends GlobalMethodSecurityConfiguration { @Override protected MethodSecurityExpressionHandler createExpressionHandler() { return new OAuth2MethodSecurityExpressionHandler(); } }

And here's our basic Foo Resource:

public class Foo { private long id; private String name; }

3.5. Web Configuration

Finally, let's set up a very basic web configuration for the API:

@Configuration @EnableWebMvc @ComponentScan({ "org.baeldung.web.controller" }) public class ResourceWebConfig implements WebMvcConfigurer {}

4. Front End – Setup

We're now going to look at a simple front-end Angular implementation for the client.

First, we'll use Angular CLI to generate and manage our front-end modules.

First, we'll install node and npm – as Angular CLI is an npm tool.

Then, we need to use the frontend-maven-plugin to build our Angular project using maven:

   com.github.eirslett frontend-maven-plugin 1.3  v6.10.2 3.10.10 src/main/resources    install node and npm  install-node-and-npm    npm install  npm    npm run build  npm   run build      

And finally, generate a new Module using Angular CLI:

ng new oauthApp

Note that we'll have two front-end modules – one for password flow and the other for implicit flow.

In the following sections, we will discuss the Angular app logic for each module.

5. Password Flow Using Angular

We're going to be using the OAuth2 Password flow here – which is why this is just a proof of concept, not a production-ready application. You'll notice that the client credentials are exposed to the front end – which is something we'll address in a future article.

Our use case is simple: once a user provides their credentials, the front-end client uses them to acquire an Access Token from the Authorization Server.

5.1. App Service

Let's start with our AppService – located at app.service.ts – which contains the logic for server interactions:

  • obtainAccessToken(): to obtain Access token given user credentials
  • saveToken(): to save our access token in a cookie using ng2-cookies library
  • getResource(): to get a Foo object from server using its ID
  • checkCredentials(): to check if user is logged in or not
  • logout(): to delete access token cookie and log the user out
export class Foo { constructor( public id: number, public name: string) { } } @Injectable() export class AppService { constructor( private _router: Router, private _http: Http){} obtainAccessToken(loginData){ let params = new URLSearchParams(); params.append('username',loginData.username); params.append('password',loginData.password); params.append('grant_type','password'); params.append('client_id','fooClientIdPassword'); let headers = new Headers({'Content-type': 'application/x-www-form-urlencoded; charset=utf-8', 'Authorization': 'Basic '+btoa("fooClientIdPassword:secret")}); let options = new RequestOptions({ headers: headers }); this._http.post('//localhost:8081/spring-security-oauth-server/oauth/token', params.toString(), options) .map(res => res.json()) .subscribe( data => this.saveToken(data), err => alert('Invalid Credentials')); } saveToken(token){ var expireDate = new Date().getTime() + (1000 * token.expires_in); Cookie.set("access_token", token.access_token, expireDate); this._router.navigate(['/']); } getResource(resourceUrl) : Observable{ var headers = new Headers({'Content-type': 'application/x-www-form-urlencoded; charset=utf-8', 'Authorization': 'Bearer '+Cookie.get('access_token')}); var options = new RequestOptions({ headers: headers }); return this._http.get(resourceUrl, options) .map((res:Response) => res.json()) .catch((error:any) => Observable.throw(error.json().error || 'Server error')); } checkCredentials(){ if (!Cookie.check('access_token')){ this._router.navigate(['/login']); } } logout() { Cookie.delete('access_token'); this._router.navigate(['/login']); } }

Note that:

  • To get an Access Token we send a POST to the “/oauth/token” endpoint
  • We're using the client credentials and Basic Auth to hit this endpoint
  • We're then sending the user credentials along with the client id and grant type parameters URL encoded
  • After we obtain the Access Token – we store it in a cookie

The cookie storage is especially important here, because we're only using the cookie for storage purposes and not to drive the authentication process directly. This helps protect against cross-site request forgery (CSRF) type of attacks and vulnerabilities.

5.2. Login Component

Next, let's take a look at our LoginComponent which is responsible for the login form:

@Component({ selector: 'login-form', providers: [AppService], template: `   Login` }) export class LoginComponent { public loginData = {username: "", password: ""}; constructor(private _service:AppService) {} login() { this._service.obtainAccessToken(this.loginData); }

5.3. Home Component

Next, our HomeComponent which is responsible for displaying and manipulating our Home Page:

@Component({ selector: 'home-header', providers: [AppService], template: `Welcome !! Logout ` }) export class HomeComponent { constructor( private _service:AppService){} ngOnInit(){ this._service.checkCredentials(); } logout() { this._service.logout(); } }

5.4. Foo Component

Finally, our FooComponent to display our Foo details:

@Component({ selector: 'foo-details', providers: [AppService], template: ` ID {{foo.id}} Name {{foo.name}} New Foo` }) export class FooComponent { public foo = new Foo(1,'sample foo'); private foosUrl = '//localhost:8082/spring-security-oauth-resource/foos/'; constructor(private _service:AppService) {} getFoo(){ this._service.getResource(this.foosUrl+this.foo.id) .subscribe( data => this.foo = data, error => this.foo.name = 'Error'); } }

5.5. App Component

Our simple AppComponent to act as the root component:

@Component({ selector: 'app-root', template: `` }) export class AppComponent {}

And the AppModule where we wrap all our components, services and routes:

@NgModule({ declarations: [ AppComponent, HomeComponent, LoginComponent, FooComponent ], imports: [ BrowserModule, FormsModule, HttpModule, RouterModule.forRoot([ { path: '', component: HomeComponent }, { path: 'login', component: LoginComponent }]) ], providers: [], bootstrap: [AppComponent] }) export class AppModule { }

6. Implicit Flow

Next, we'll focus on the Implicit Flow module.

6.1. App Service

Similarly, we will start with our service, but this time we will use library angular-oauth2-oidc instead of obtaining access token ourselves:

@Injectable() export class AppService { constructor( private _router: Router, private _http: Http, private oauthService: OAuthService){ this.oauthService.loginUrl = '//localhost:8081/spring-security-oauth-server/oauth/authorize'; this.oauthService.redirectUri = '//localhost:8086/'; this.oauthService.clientId = "sampleClientId"; this.oauthService.scope = "read write foo bar"; this.oauthService.setStorage(sessionStorage); this.oauthService.tryLogin({}); } obtainAccessToken(){ this.oauthService.initImplicitFlow(); } getResource(resourceUrl) : Observable{ var headers = new Headers({'Content-type': 'application/x-www-form-urlencoded; charset=utf-8', 'Authorization': 'Bearer '+this.oauthService.getAccessToken()}); var options = new RequestOptions({ headers: headers }); return this._http.get(resourceUrl, options) .map((res:Response) => res.json()) .catch((error:any) => Observable.throw(error.json().error || 'Server error')); } isLoggedIn(){ if (this.oauthService.getAccessToken() === null){ return false; } return true; } logout() { this.oauthService.logOut(); location.reload(); } }

Note how, after obtaining the Access Token, we're using it via the Authorization header whenever we consume protected resources from within the Resource Server.

6.2. Home Component

Our HomeComponent to handle our simple Home Page:

@Component({ selector: 'home-header', providers: [AppService], template: ` Login Welcome !! Logout

` }) export class HomeComponent { public isLoggedIn = false; constructor( private _service:AppService){} ngOnInit(){ this.isLoggedIn = this._service.isLoggedIn(); } login() { this._service.obtainAccessToken(); } logout() { this._service.logout(); } }

6.3. Foo Component

Our FooComponent is exactly the same as in the password flow module.

6.4. App Module

Finally, our AppModule:

@NgModule({ declarations: [ AppComponent, HomeComponent, FooComponent ], imports: [ BrowserModule, FormsModule, HttpModule, OAuthModule.forRoot(), RouterModule.forRoot([ { path: '', component: HomeComponent }]) ], providers: [], bootstrap: [AppComponent] }) export class AppModule { }

7. Run the Front End

1. За да стартираме някой от нашите предни модули, първо трябва да изградим приложението:

mvn clean install

2. След това трябва да отидем до нашата директория с приложения Angular:

cd src/main/resources

3. Накрая ще стартираме нашето приложение:

npm start

Сървърът ще се стартира по подразбиране на порт 4200, за да смени порта на всеки модул, променете

"start": "ng serve"

в package.json, за да работи на порт 8086, например:

"start": "ng serve --port 8086"

8. Заключение

В тази статия научихме как да упълномощаваме нашето приложение с помощта на OAuth2.

Пълното изпълнение на този урок може да бъде намерено в проекта GitHub.