streamalism.org

1. Áttekintés

Ebben az oktatóanyagban megvizsgáljuk az Apereo Központi Hitelesítési Szolgáltatást (CAS), és meglátjuk, hogy a Spring Boot szolgáltatás miként tudja felhasználni a hitelesítéshez. A CAS egy vállalati egyszeri bejelentkezés (SSO) megoldás, amely szintén nyílt forráskódú.

Mi az egyszeri bejelentkezés? Ha ugyanazokkal az adatokkal jelentkezik be a YouTube-ra, a Gmailbe és a Térképbe, ez az egyszeri bejelentkezés. Ezt be fogjuk mutatni egy CAS szerver és egy Spring Boot alkalmazás létrehozásával. A Spring Boot alkalmazás a CAS-t fogja használni a hitelesítéshez.

2. CAS kiszolgáló beállítása

2.1. CAS telepítés és függőségek

A szerver a Maven (Gradle) War Overlay stílust használja a telepítés és a telepítés megkönnyítése érdekében:

git klón //github.com/apereo/cas-overlay-template.git cas-server

Ez a parancs klónozza a cas-overlay-template ba,-be cas-szerver Könyvtár.

Néhány szempont, amelyre kitérünk, a JSON szolgáltatás regisztrációja és a JDBC adatbázis-kapcsolat. Tehát hozzáadjuk a moduljaikat a függőségek szakasza épít.gradle fájl:

fordítás "org.apereo.cas: cas-server-support-json-service-register: $ {casServerVersion}" fordítás "org.apereo.cas: cas-server-support-jdbc: $ {casServerVersion}"

Győződjön meg arról, hogy ellenőrizte a casServer legújabb verzióját.

2.2. CAS kiszolgáló konfigurálása

Mielőtt elindíthatnánk a CAS szervert, hozzá kell adnunk néhány alapvető konfigurációt. Kezdjük azzal, hogy létrehozunk egy cas-server / src / main / resources és ebben a mappában. Ezt követi a alkalmazás.tulajdonságok a mappában is:

server.port = 8443 spring.main.allow-bean-definition-overriding = true server.ssl.key-store = classpath: / etc / cas / thekeystore server.ssl.key-store-password = changeit

Folytassuk a fenti konfigurációban hivatkozott kulcstárfájl létrehozását. Először létre kell hoznunk a mappákat / etc / cas és / etc / cas / config ban ben cas-server / src / main / resources.

Ezután meg kell változtatnunk a könyvtárat erre: cas-server / src / main / resources / etc / cas és futtassa a parancsot a generáláshoz theystore:

keytool -genkey -keyalg RSA -alias thekeystore -keystore thekeystore -storepass changeit -validity 360 -keysize 2048

Annak érdekében, hogy ne legyen SSL kézfogási hiba, használnunk kell helyi kiszolgáló a kereszt- és vezetéknév értékeként. Ugyanezt kell használnunk a szervezet nevéhez és egységéhez is. Továbbá be kell importálnunk a a thysteystore a JDK / JRE-be, amelyet az ügyfélalkalmazásunk futtatásához fogunk használni:

keytool -importkeystore -srckeystore thekeystore -destkeystore $ JAVA11_HOME / jre / lib / security / cacerts

A forrás és cél kulcstár jelszava a következő változtasd meg. Unix rendszereken előfordulhat, hogy ezt a parancsot az admin (sudo) kiváltság. Az importálás után újra kell indítanunk a futó Java összes példányát, vagy újra kell indítanunk a rendszert.

A JDK11-et használjuk, mert a CAS 6.1.x verziója megköveteli. Meghatároztuk a $ JAVA11_HOME környezeti változót is, amely a saját könyvtárára mutat. Most elindíthatjuk a CAS szervert:

./gradlew run -Dorg.gradle.java.home = $ JAVA11_HOME

Amikor az alkalmazás elindul, a terminálra nyomtatva megjelenik a „KÉSZ” felirat és a szerver elérhető lesz a címen // localhost: 8443.

2.3. CAS Server felhasználói konfiguráció

Még nem tudunk bejelentkezni, mivel még egyetlen felhasználót sem konfiguráltunk. A CAS különböző módszerekkel rendelkezik a konfiguráció kezelésére, beleértve az önálló módot is. Hozzunk létre egy config mappát cas-server / src / main / resources / etc / cas / config amelyben létrehozunk egy tulajdonságfájlt cas.tulajdonságok. Most meghatározhatunk egy statikus felhasználót a tulajdonságfájlban:

cas.authn.accept.users = casuser :: Mellon

A beállítások érvénybe lépése érdekében közölnünk kell a konfigurációs mappa helyét a CAS szerverrel. Frissítsük feladatok.birkózni így átadhatjuk a helyet JVM argumentumként a parancssorból:

feladat futtatása (csoport: "build", leírás: "A CAS webalkalmazás futtatása beágyazott tároló módban") {dependOn 'build' doLast {def casRunArgs = new ArrayList (Arrays.asList ("-server -noverify -Xmx2048M -XX: + TieredCompilation -XX: TieredStopAtLevel = 1 ".split (" "))) if (project.hasProperty ('args')) {casRunArgs.addAll (project.args.split ('\ s +'))} javaexec {main = "-jar" jvmArgs = casRunArgs args = ["build / libs / $ {casWebApplicationBinaryName}"] logger.info "Indított $ {commandLine}"}}}

Ezután elmentjük a fájlt, és futtatjuk:

./gradlew run -Dorg.gradle.java.home = $ JAVA11_HOME -Pargs = "- Dcas.standalone.configurationDirectory = / cas-server / src / main / resources / etc / cas / config"

Felhívjuk figyelmét, hogy a cas.standalone.configurationDirectory abszolút út. Most elmehetünk // localhost: 8443 és jelentkezzen be felhasználónévvel ügyész és jelszóval Mellon.

3. CAS kliens beállítása

A Spring Initializr használatával létrehozunk egy Spring Boot kliens alkalmazást. Meglesz Web, Biztonság, Freemarker és DevTools függőségek. Emellett hozzáadjuk a Spring Security CAS modul függőségét is pom.xml:

 org.springframework.security spring-security-cas 5.3.0.FELHASZNÁLÁS 

Végül adjuk hozzá a következő Spring Boot tulajdonságokat az alkalmazás konfigurálásához:

server.port = 8900 spring.freemarker.suffix = .ftl

4. CAS szerver szolgáltatás regisztrációja

Az ügyfélalkalmazásoknak minden hitelesítés előtt regisztrálniuk kell a CAS szerveren. A CAS szerver támogatja a YAML, JSON, MongoDB és LDAP kliens regiszterek használatát.

Ebben az oktatóanyagban a JSON szolgáltatásnyilvántartási módszert fogjuk használni. Hozzunk létre még egy mappát cas-server / src / main / resources / etc / cas / services. Ebben a mappában találhatók a JSON fájlok.

Létrehozunk egy JSON fájlt, amely tartalmazza az ügyfélalkalmazásunk definícióját. A fájl neve, casSecuredApp-8900.json, követi az s mintáterviceName-Id.json:

{"@class": "org.apereo.cas.services.RegexRegisteredService", "serviceId": "// localhost: 8900 / login / cas", "name": "casSecuredApp", "id": 8900, "logoutType ":" BACK_CHANNEL "," logoutUrl ":" // localhost: 8900 / exit / cas "}

A serviceId attribútum egy regex URL-mintát határoz meg az ügyfélalkalmazáshoz. A mintának meg kell egyeznie az ügyfélalkalmazás URL-jével.

A id attribútumnak egyedinek kell lennie. Más szóval, nem lehet két vagy több azonos szolgáltatású szolgáltatás id regisztrálva van ugyanarra a CAS szerverre. Másolat birtoklása id konfliktusokhoz és a konfigurációk felülbírálásához vezet.

A kijelentkezés típusát is konfiguráljuk BACK_CHANNEL és az URL legyen // localhost: 8900 / exit / cas hogy később egyszeri kijelentkezést hajtsunk végre. Mielőtt a CAS szerver igénybe veheti a JSON konfigurációs fájlunkat, engedélyeznünk kell a JSON nyilvántartást a rendszerünkben cas.tulajdonságok:

cas.serviceRegistry.initFromJson = true cas.serviceRegistry.json.location = classpath: / etc / cas / services

5. CAS kliens egyszeri bejelentkezés konfigurálása

A következő lépés számunkra a Spring Security beállítása a CAS szerverrel való együttműködésre. Ellenőriznünk kell az interakciók teljes áramlását is, az úgynevezett CAS-szekvenciát.

Adjuk hozzá a következő babkonfigurációkat a CasSecuredApplication tavaszi csomagtartó alkalmazásunk osztálya:

@Bean public CasAuthenticationFilter casAuthenticationFilter (AuthenticationManager authenticationManager, ServiceProperties serviceProperties) dobja a Kivételt {CasAuthenticationFilter filter = new CasAuthenticationFilter (); filter.setAuthenticationManager (authenticationManager); filter.setServiceProperties (serviceProperties); visszatérő szűrő; } @Bean public ServiceProperties serviceProperties () {logger.info ("szolgáltatás tulajdonságai"); ServiceProperties serviceProperties = new ServiceProperties (); serviceProperties.setService ("// cas-client: 8900 / login / cas"); serviceProperties.setSendRenew (false); visszatérési szolgáltatásTulajdonságok; } @Bean public TicketValidator ticketValidator () {return new Cas30ServiceTicketValidator ("// localhost: 8443"); } @Bean public CasAuthenticationProvider casAuthenticationProvider (TicketValidator ticketValidator, ServiceProperties serviceProperties) {CasAuthenticationProvider szolgáltató = új CasAuthenticationProvider (); szolgáltató.setServiceProperties (serviceProperties); szolgáltató.setTicketValidator (ticketValidator); szolgáltató.setUserDetailsService (s -> új Felhasználó ("[email protected]", "Mellon", true, true, true, true, AuthorityUtils.createAuthorityList ("ROLE_ADMIN"))); szolgáltató.setKey ("CAS_PROVIDER_LOCALHOST_8900"); visszatérési szolgáltató; }

A ServiceProperties A bean URL-je megegyezik az URL-lel serviceId ban ben casSecuredApp-8900.json. Ez azért fontos, mert azonosítja ezt az ügyfelet a CAS kiszolgálóval.

A sendRenew tulajdona ServiceProperties értékre van állítva hamis. Ez azt jelenti, hogy a felhasználónak csak egyszer kell bemutatnia a bejelentkezési adatokat a kiszolgálónak.

A AuthenticationEntryPoint A bab kezeli a hitelesítési kivételeket. Így átirányítja a felhasználót a CAS szerver bejelentkezési URL-jére hitelesítés céljából.

Összefoglalva, a hitelesítési folyamat:

1. A felhasználó megpróbál hozzáférni egy biztonságos oldalhoz, ami hitelesítési kivételt vált ki
2. A kivétel kiváltja AuthenticationEntryPoint. Válaszul a AuthenticationEntryPoint elviszi a felhasználót a CAS szerver bejelentkezési oldalára - // localhost: 8443 / login
3. Sikeres hitelesítés esetén a szerver egy jeggyel visszairányítja az ügyfelet
4. CasAuthenticationFilter felveszi az átirányítást és felhívja CasAuthenticationProvider
5. CasAuthenticationProvider használni fogja TicketValidator hogy megerősítse a bemutatott jegyet a CAS szerveren
6. Ha a jegy érvényes, a felhasználó átirányítja a kért biztonságos URL-re

Végül konfiguráljuk HttpBiztonság hogy biztosítson néhány útvonalat WebSecurityConfig. A folyamat során hozzáadjuk a hitelesítési belépési pontot is a kivételkezeléshez:

A @Orride protected void configure (HttpSecurity http) a (z) {http.authorizeRequests (). Kivételet dobja. AntMatchers ("/ Secured", "/ login") .authenticated () .and (). KivételHandling () .authenticationEntryPoint (authenticationEntryPoint ()); }

6. CAS Client Single Logout konfiguráció

Eddig az egyszeri bejelentkezéssel foglalkoztunk; most vegyük figyelembe a CAS egyszeri kijelentkezését (SLO).

Azok az alkalmazások, amelyek CAS-t használnak a felhasználói hitelesítés kezeléséhez, két helyről is kijelentkeztethetnek egy felhasználót:

• Az ügyfélalkalmazás helyileg kijelentkeztetheti magától a felhasználót - ez nem befolyásolja a felhasználó bejelentkezési állapotát más, ugyanazt a CAS-kiszolgálót használó alkalmazásokban
• Az ügyfélalkalmazás kijelentkeztetheti a felhasználót a CAS-kiszolgálóról is - ezáltal a felhasználó kijelentkezik az összes, ugyanazon CAS-kiszolgálóhoz csatlakozó kliens-alkalmazásból.

Először kijelöljük a kijelentkezést az ügyfélalkalmazásban, majd kibővítjük az egyszeri kijelentkezéssel a CAS szerveren.

Annak érdekében, hogy nyilvánvaló legyen, mi történik a színfalak mögött, létrehozunk egy Kijelentkezés() módszer a helyi kijelentkezés kezelésére. Siker esetén egy olyan oldalra irányít át minket, amely linket jelent az egyszeri kijelentkezéshez:

@GetMapping ("/ logout") nyilvános karakterlánc-kijelentkezés (HttpServletRequest kérés, HttpServletResponse válasz, SecurityContextLogoutHandler logoutHandler) {Hitelesítés auth = SecurityContextHolder .getContext (). GetAuthentication (); logoutHandler.logout (kérés, válasz, hitelesítés); új CookieClearingLogoutHandler (AbstractRememberMeServices.SPRING_SECURITY_REMEMBER_ME_COOKIE_KEY) .logout (kérés, válasz, hitelesítés); return "auth / logout"; }

Az egyszeri kijelentkezés során a CAS-kiszolgáló először lejáratja a felhasználó jegyét, majd aszinkron kérést küld az összes regisztrált kliens alkalmazásnak. Minden, a jelet fogadó ügyfélalkalmazás helyi kijelentkezést hajt végre. Ezáltal a kijelentkezés céljának egyszeri teljesítése mindenütt kijelentkezést okoz.

Ezt követően adjunk hozzá néhány babkonfigurációt az ügyfélalkalmazásunkhoz. Pontosabban a CasSecuredApplicaiton:

@Bean public SecurityContextLogoutHandler securityContextLogoutHandler () {return new SecurityContextLogoutHandler (); } @Bean public LogoutFilter logoutFilter () {LogoutFilter logoutFilter = new LogoutFilter ("// localhost: 8443 / logout", securityContextLogoutHandler ()); logoutFilter.setFilterProcessesUrl ("/ logout / cas"); return logoutFilter; } @Bean public SingleSignOutFilter singleSignOutFilter () {SingleSignOutFilter singleSignOutFilter = új SingleSignOutFilter (); singleSignOutFilter.setCasServerUrlPrefix ("// localhost: 8443"); singleSignOutFilter.setLogoutCallbackPath ("/ exit / cas"); singleSignOutFilter.setIgnoreInitConfiguration (true); return singleSignOutFilter; }

A logoutFilter lehallgatja a kéréseket / logout / cas és irányítsa át az alkalmazást a CAS szerverre. A SingleSignOutFilter elfogja a CAS szerverről érkező kéréseket és végrehajtja a helyi kijelentkezést.

7. Csatlakoztassa a CAS szervert egy adatbázishoz

Beállíthatjuk a CAS-kiszolgálót a hitelesítő adatok olvasására a MySQL adatbázisból. Használjuk a teszt egy MySQL kiszolgáló adatbázisa, amely egy helyi gépen fut. Frissítsük cas-server / src / main / resources / etc / cas / config / cas.properties:

cas.authn.accept.users = cas.authn.jdbc.query [0] .sql = KIVÁLASZTÁS * FEL felhasználóktól HOL email =? cas.authn.jdbc.query [0] .url = jdbc: mysql: //127.0.0.1: 3306 / teszt? useUnicode = true & useJDBCCompliantTimezoneShift = true & useLegacyDatetimeCode = false & serverTimezone = UTC cas.authn.jdbc.query [0] .dialect = org.hibernate.dialect.MySQLDialect cas.authn.jdbc.query [cas]. [0] .password = gyökér cas.authn.jdbc.query [0] .ddlAuto = nincs cas.authn.jdbc.query [0] .driverClass = com.mysql.cj.jdbc.Driver cas.authn.jdbc.query [0] .fieldPassword = jelszó cas.authn.jdbc.query [0] .passwordEncoder.type = NINCS

Beállítottuk a cas.authn.accept.users hogy üres legyen. Ez kikapcsolja a statikus felhasználói adattárak CAS-kiszolgáló általi használatát.

A fenti SQL szerint a felhasználók hitelesítő adatait az felhasználók asztal. A email oszlop az, ami a felhasználók tőkéjét jelöli (felhasználónév).

Kérjük, ellenőrizze a támogatott adatbázisok listáját, az elérhető illesztőprogramokat és nyelvjárásokat. A jelszó kódoló típusát is beállítottuk EGYIK SEM. Egyéb titkosítási mechanizmusok és sajátos tulajdonságaik is rendelkezésre állnak.

Ne feledje, hogy a CAS kiszolgáló adatbázisának főnek meg kell egyeznie az ügyfélalkalmazás főével.

Frissítsük CasAuthenticationProvider hogy ugyanaz a felhasználóneve legyen, mint a CAS szervernek:

@Bean public CasAuthenticationProvider casAuthenticationProvider () {CasAuthenticationProvider szolgáltató = new CasAuthenticationProvider (); szolgáltató.setServiceProperties (serviceProperties ()); szolgáltató.setTicketValidator (ticketValidator ()); szolgáltató.setUserDetailsService (s -> új Felhasználó ("[email protected]", "Mellon", true, true, true, true, AuthorityUtils.createAuthorityList ("ROLE_ADMIN"))); szolgáltató.setKey ("CAS_PROVIDER_LOCALHOST_8900"); visszatérési szolgáltató; }

CasAuthenticationProvider nem használja a jelszót a hitelesítéshez. Ennek ellenére a felhasználónevének meg kell egyeznie a CAS szerverével, hogy a hitelesítés sikeres legyen. A CAS szerverhez MySQL szerver szükséges helyi kiszolgáló a kikötőben 3306. A felhasználónévnek és a jelszónak meg kell lennie gyökér.

Indítsa újra a CAS szervert és a Spring Boot alkalmazást. Ezután használja az új hitelesítő adatokat a hitelesítéshez.

8. Következtetés

Megvizsgáltuk, hogyan kell használni a CAS SSO-t a Spring Security alkalmazással, és számos érintett konfigurációs fájlt. A CAS egyszeri bejelentkezésnek számos más konfigurálható aspektusa van. Témáktól és protokolltípusoktól kezdve a hitelesítési házirendekig.

Ezek és mások a dokikban vannak. A CAS-kiszolgáló és a Spring Boot alkalmazás forráskódja elérhető a GitHubon.