streamalism.org

1. Introduksjon

I denne opplæringen skal vi forberede en dynamisk klientregistrering med OAuth2.0. OAuth2.0 er et autorisasjonsrammeverk som gjør det mulig å få begrenset tilgang til brukerkontoer på en HTTP-tjeneste. OAuth2.0-klienten er applikasjonen som ønsker å få tilgang til brukerens konto. Denne klienten kan være en ekstern webapplikasjon, en brukeragent eller bare en innfødt klient.

For å oppnå dynamisk klientregistrering skal vi lagre legitimasjonen i databasen i stedet for hardkodet konfigurasjon. Applikasjonen vi skal utvide ble opprinnelig beskrevet i vår REST API + OAuth2-opplæring.

Merk: denne artikkelen bruker Spring OAuth arvprosjekt.

2. Maven-avhengigheter

Vi setter først opp følgende sett med avhengigheter:

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

Vær oppmerksom på at vi bruker vår-jdbc fordi vi skal bruke en DB til å lagre de nylig registrerte brukerne med passord.

3. OAuth2.0-serverkonfigurasjon

Først må vi konfigurere vår OAuth2.0 autorisasjonsserver. Hovedkonfigurasjonen er i følgende klasse:

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

Det er noen få viktige ting vi trenger å konfigurere; la oss begynne med ClientDetailsServiceConfigurer:

@Override public void configure (final ClientDetailsServiceConfigurer clients) kaster unntak {clients.jdbc (dataSource ()) // ...}

Dette vil sørge for at vi bruker utholdenhet for å få klientinformasjonen fra.

La oss selvfølgelig sette opp denne standard datakilden:

@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")); returner datakilde; }

Og så, nå, vil applikasjonen vår bruke databasen som en kilde til registrerte klienter, i stedet for de typiske hardkodede minneklientene.

4. DB-ordningen

La oss nå definere SQL-strukturen for lagring av OAuth-klientene:

opprett tabell oauth_client_details (client_id VARCHAR (256) PRIMARY KEY, resource_ids VARCHAR (256), client_secret VARCHAR (256), scope VARCHAR (256), authorisated_grant_types VARCHAR (256), web_server_redirect_uri VARCHARCH (256), VARCHAR access (VARCHARCH (256), VARCHAR (256) , refresh_token_validity INTEGER, tilleggsinformasjon VARCHAR (4096), autoapprove VARCHAR (256));

De viktigste feltene fra oauth_client_details vi bør fokusere på er:

• klient-ID - å lagre id for nyregistrerte kunder
• klienthemmelighet - å lagre passordet til klienter
• tilgang_token_gyldighet - som indikerer om klienten fremdeles er gyldig
• autoriteter - for å indikere hvilke roller som er tillatt med en bestemt klient
• omfang - tillatte handlinger, for eksempel å skrive statuser på Facebook osv.
• autoriserte_tilskuddstyper, som gir informasjon om hvordan brukere kan logge på den bestemte klienten (i vårt eksempel er det en skjemainnlogging med passord)

Vær oppmerksom på at hver klient har et til mange forhold til brukerne, noe som naturlig betyr det flere brukere kan bruke en enkelt klient.

5. La oss fortsette noen kunder

Med definisjon av SQL-skjema kan vi endelig opprette noen data i systemet - og i utgangspunktet definere en klient.

Vi skal bruke følgende data.sql skript - hvilken Spring Boot vil kjøre som standard - for å initialisere DB:

INSERT INTO oauth_client_details (client_id, client_secret, scope, autoriserte_grant_types, web_server_redirect_uri, autorities, access_token_validity, refresh_token_validity, additional_information, autoapprove) VALUES ("fooClientIdPassword", "secret", "password_code, nullstill, nullstill, passord" , null, 36000, 36000, null, true);

Beskrivelsen av de viktigste feltene i oauth_client_details er gitt i forrige avsnitt.

6. Testing

For å teste den dynamiske klientregistreringen, må vi kjøre begge deler spring-security-oauth-server og vår-sikkerhet-oauth-ressurs prosjekter på henholdsvis 8081 og 8082 porter.

Nå kan vi endelig skrive noen live tester.

La oss anta at vi registrerte klienten med ID-navnet fooClientIdPassword, som har tilgang til å lese foos.

Først prøver vi å skaffe et Access Token fra Auth Server ved hjelp av en allerede definert klient:

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

Og her er logikken med å skaffe Access Token:

private String obtainAccessToken (String clientId, String brukernavn, String passord) {Map params = new HashMap (); params.put ("grant_type", "password"); params.put ("client_id", clientId); params.put ("brukernavn", brukernavn); params.put ("passord", passord); Svarrespons = RestAssured.given (). Auth (). Preemptive () .basic (clientId, "secret"). Og (). With (). Params (params) .when () .post ("// localhost: 8081 / spring-security-oauth-server / oauth / token "); return response.jsonPath (). getString ("access_token"); }

7. Konklusjon

I denne opplæringen lærte vi hvordan vi dynamisk kan registrere ubegrenset antall klienter med OAuth2.0 framework.

Den fulle implementeringen av denne veiledningen finner du på GitHub - dette er et Maven-basert prosjekt, så det skal være enkelt å importere og kjøre som det er.

Vær oppmerksom på at for å teste, må du legge til klienter i DB, og at .i minne() config vil ikke lenger være gyldig. Hvis du vil bruke det gamle.i minne() config, det er en annen fil som inneholder konfigurasjon med hardkodede klienter.