streamalism.org

1. Introduktion

I denne vejledning skal vi forberede en dynamisk klientregistrering med OAuth2.0. OAuth2.0 er en autorisationsramme, der muliggør opnåelse af begrænset adgang til brugerkonti på en HTTP-tjeneste. OAuth2.0-klienten er det program, der ønsker at få adgang til brugerens konto. Denne klient kan være en ekstern webapplikation, en brugeragent eller bare en indfødt klient.

For at opnå dynamisk klientregistrering gemmer vi legitimationsoplysningerne i databasen i stedet for hardkodet konfiguration. Den applikation, vi vil udvide, blev oprindeligt beskrevet i Spring REST API + OAuth2 tutorial.

Bemærk: denne artikel bruger Spring OAuth-arvsprojektet.

2. Maven-afhængigheder

Vi opretter først følgende sæt afhængigheder:

 org.springframework.boot spring-boot-starter-web org.springframework spring-jdbc org.springframework.security.oauth spring-security-oauth2 

Bemærk, at vi bruger forår-jdbc fordi vi skal bruge en DB til at gemme de nyregistrerede brugere med adgangskoder.

3. OAuth2.0-serverkonfiguration

Først skal vi konfigurere vores OAuth2.0 autorisationsserver. Hovedkonfigurationen er inden for følgende klasse:

@Configuration @PropertySource ({"classpath: persistence.properties"}) @EnableAuthorizationServer public class OAuth2AuthorizationServerConfig udvider AuthorizationServerConfigurerAdapter {// config}

Der er et par vigtige ting, vi skal konfigurere; lad os starte med ClientDetailsServiceConfigurer:

@ Override offentlig ugyldig konfiguration (endelig ClientDetailsServiceConfigurer klienter) kaster Undtagelse {clients.jdbc (dataSource ()) // ...}

Dette vil sikre, at vi bruger vedholdenhed til at få klientoplysningerne fra.

Lad os selvfølgelig oprette denne standard datakilde:

@Bean offentlig DataSource dataSource () {DriverManagerDataSource dataSource = ny 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")); returnere datakilde; }

Så nu bruger vores applikation databasen som en kilde til registrerede klienter i stedet for det typiske hardkodede i hukommelsesklienter.

4. DB-ordningen

Lad os nu definere SQL-strukturen til lagring af vores OAuth-klienter:

Opret tabel oauth_client_details (client_id VARCHAR (256) PRIMARY KEY, resource_ids VARCHAR (256), client_secret VARCHAR (256), scope VARCHAR (256), autoriserede_grant_types VARCHAR (256), web_server_redirect_uri VARCHAR (256), VARCHAR_adgang) , refresh_token_validity INTEGER, yderligere_information VARCHAR (4096), autoapprove VARCHAR (256));

De vigtigste felter fra oauth_client_details vi skal fokusere på er:

• klient_id - at gemme id for nyregistrerede kunder
• klienthemmelighed - at gemme klienters adgangskode
• adgang_token_validitet - hvilket angiver, om klienten stadig er gyldig
• myndigheder - at angive, hvilke roller der er tilladt med en bestemt klient
• rækkevidde - tilladte handlinger, for eksempel at skrive status på Facebook osv.
• autoriserede_tilskudstyper, som giver information om, hvordan brugere kan logge ind på den bestemte klient (i vores eksempel er det et formularlogin med adgangskode)

Bemærk, at hver klient har et til mange forhold til brugerne, hvilket naturligvis betyder det flere brugere kan bruge en enkelt klient.

5. Lad os fortsætte med nogle klienter

Når SQL-skema defineres, kan vi endelig oprette nogle data i systemet - og grundlæggende definere en klient.

Vi skal bruge følgende data.sql script - hvilket Spring Boot kører som standard - for at initialisere DB:

INSERT INTO oauth_client_details (client_id, client_secret, omfang, authorized_grant_types, web_server_redirect_uri, myndigheder, access_token_validity, refresh_token_validity, additional_information, autoapprove) værdier ( "fooClientIdPassword", "hemmelig", "foo, læse, skrive, "password, authorization_code, refresh_token", null , null, 36000, 36000, null, true);

Beskrivelsen af ​​de vigtigste felter i oauth_client_details findes i foregående afsnit.

6. Testning

For at teste den dynamiske klientregistrering er vi nødt til at køre begge dele spring-security-oauth-server og spring-security-oauth-resource projekter på henholdsvis 8081 og 8082 havne.

Nu kan vi endelig skrive et par live tests.

Lad os antage, at vi registrerede klient med id opkaldt fooClientIdPassword, der har adgang til at læse foos.

Først forsøger vi at få et adgangstoken fra Auth-serveren ved hjælp af en allerede defineret klient:

@Test offentlig ugyldighed givetDBUser_whenRevokeToken_thenAuthorized () {String accessToken = obtainAccessToken ("fooClientIdPassword", "john", "123"); assertNotNull (accessToken); }

Og her er logikken med at få adgangstokenet:

private String obtainAccessToken (String clientId, String brugernavn, String password) {Map params = new HashMap (); params.put ("grant_type", "password"); params.put ("client_id", clientId); params.put ("brugernavn", brugernavn); params.put ("adgangskode", adgangskode); Svarrespons = RestAssured.given (). Auth (). Præemptive () .basic (clientId, "secret"). Og (). Med (). Params (params) .when () .post ("// localhost: 8081 / spring-security-oauth-server / oauth / token "); returnere respons.jsonPath (). getString ("access_token"); }

7. Konklusion

I denne vejledning lærte vi, hvordan man dynamisk registrerer et ubegrænset antal klienter med OAuth2.0 framework.

Den fulde implementering af denne vejledning kan findes på GitHub - dette er et Maven-baseret projekt, så det skal være let at importere og køre som det er.

Bemærk, at for at teste skal du tilføje klienter i DB, og at .inMemory () config er ikke længere gyldig. Hvis du vil bruge det gamle.inMemory () config, er der en anden fil, der indeholder konfiguration med hardkodede klienter.