Mari perkenalkan login reguler melalui email dan OAuth2 ke Spring Security menggunakan contoh layanan catatan

Saat menulis aplikasi saya, saya menemukan kurangnya artikel yang jelas tentang cara membuat pengguna mendaftar baik melalui email dan jejaring sosial. Ada tutorial bagus tentang menyiapkan formulir login klasik. Ada tutorial bagus tentang OAuth2 . Hanya ada sedikit informasi kriminal tentang bagaimana menggabungkan kedua metode tersebut. Selama proses pencarian, kami dapat menemukan solusi yang bisa diterapkan. Ia tidak mengaku sebagai kebenaran hakiki, namun ia memenuhi fungsinya. Pada artikel ini saya akan menunjukkan cara mengimplementasikan layanan penyimpanan catatan dengan konfigurasi Spring Security serupa dari awal. Catatan: ada baiknya jika pembaca telah membaca setidaknya beberapa tutorial tentang Spring, karena perhatian akan terfokus hanya pada Keamanan Spring, tanpa penjelasan rinci tentang repositori, pengontrol, dll. Jika tidak, artikel yang sudah agak besar akan berubah menjadi menjadi raksasa. Isi

1. Membuat Proyek
2. Membuat Entitas dan Logika Aplikasi
1. Entitas
2. Repositori
3. Pengendali
4. Halaman
3. Mengonfigurasi Keamanan Musim Semi untuk Login Klasik
1. Konfigurasi dasar SecurityConfig
2. Login pengguna khusus
3. Mari tingkatkan pengontrolnya
4. Meluncurkan
4. Menyiapkan OAuth2 menggunakan Google sebagai contoh di Spring Security
1. Filter konfigurasi dan properti aplikasi
2. Sorotan mendaftarkan aplikasi ke Google Cloud Platform
3. Layanan CustomUserInfoToken
5. Peluncuran akhir proyek

Membuat Proyek

Kami pergi ke start.spring.io dan menjadi dasar proyek:

• Web - meluncurkan aplikasi pada Tomcat bawaan, pemetaan url dan sejenisnya;
• JPA - koneksi basis data;
• Kumis adalah mesin templat yang digunakan untuk menghasilkan halaman web;
• Keamanan - perlindungan aplikasi. Untuk itulah artikel ini dibuat.

Unduh arsip yang dihasilkan dan ekstrak ke dalam folder yang Anda perlukan. Kami meluncurkannya di IDE. Anda dapat memilih database sesuai kebijaksanaan Anda. Saya menggunakan MySQL sebagai database untuk proyek tersebut, jadi saya menambahkan dependensi berikut ke file pom.xml di blok <dependencies>:

<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.34</version>
</dependency>

Konfigurasi application.properties saat ini adalah sebagai berikut:

spring.datasource.url=jdbc:mysql://localhost:3306/springsectut?createDatabaseIfNotExist=true&useSSL=false&autoReconnect=true&useLegacyDatetimeCode=false&serverTimezone=UTC&useUnicode=yes&characterEncoding=UTF-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=yourUsername
spring.datasource.password=yourPassword

spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update

spring.jpa.properties.connection.characterEncoding=utf-8
spring.jpa.properties.connection.CharSet=utf-8
spring.jpa.properties.connection.useUnicode=true

spring.mustache.expose-request-attributes=true

Membuat Entitas dan Logika Aplikasi

Entitas

Mari kita buat sebuah paket entitiesdi mana kita akan menempatkan entitas database. Pengguna akan dijelaskan oleh kelas Useryang mengimplementasikan antarmuka UserDetails, yang akan diperlukan untuk konfigurasi Keamanan Musim Semi. Pengguna akan memiliki id, nama pengguna (ini email), kata sandi, nama, peran, tanda aktivitas, nama akun Google dan email ( googleNamedan googleUsername).

@Entity
@Table(name = "user")
public class User implements UserDetails
{
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  private String username;
  private String password;
  private String name;
  private boolean active;
  private String googleName;
  private String googleUsername;

  @ElementCollection(targetClass = Role.class, fetch = FetchType.EAGER)
  @CollectionTable(name = "user_role", joinColumns = @JoinColumn(name = "user_id"))
  @Enumerated(EnumType.STRING)
  private Set<Role> roles;

    //Геттеры, сеттеры, toString(), equals(), hashcode(), имплементация UserDetails
}

Peran pengguna digunakan untuk mengatur akses di Spring Security. Aplikasi kita hanya akan menggunakan satu peran:

public enum Role implements GrantedAuthority
{
  USER;

  @Override
  public String getAuthority()
  {
     return name();
  }
}

Mari kita buat kelas catatan dengan id, judul catatan, isi catatan, dan id pengguna yang memilikinya:

@Entity
@Table(name = "note")
public class Note
{
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;

  private String title;
  private String note;
  private Long userId;

    //Геттеры, сеттеры, toString(), equals(), hashcode()
}

Repositori

Untuk menyimpan entitas ke database, kita memerlukan repositori yang akan melakukan semua pekerjaan kotor untuk kita. Mari kita buat sebuah paket repos, di dalamnya kita akan membuat antarmuka UserRepoyang diwarisi NoteRepodari antarmuka JpaRepository<Entity, Id>.

@Service
@Repository
public interface UserRepo extends JpaRepository<User, Long>
{}

@Service
@Repository
public interface NoteRepo extends JpaRepository<Note, Long>
{
  List<Note> findByUserId(Long userId);
}

Pengendali

Layanan catatan kami akan memiliki halaman berikut:

• Rumah;
• Registrasi;
• Pintu masuk;
• Daftar catatan pengguna.

Hanya pengguna yang berwenang yang boleh memiliki akses ke daftar catatan. Halaman selebihnya bersifat publik. Mari kita membuat paket controllersyang berisi kelas IndexControlleryang berisi pemetaan halaman utama seperti biasa. Kelas RegistrationControllerbertanggung jawab untuk mendaftarkan pengguna. Pasca-pemetaan mengambil data dari formulir, menyimpan pengguna ke database dan mengarahkan ke halaman login. PasswordEncoderakan dijelaskan nanti. Ini digunakan untuk mengenkripsi kata sandi.

@Controller
public class RegistrationController
{
  @Autowired
  private UserRepo userRepo;

  @Autowired
  private PasswordEncoder passwordEncoder;

  @GetMapping("/registration")
  public String registration()
  {
     return "registration";
  }

  @PostMapping("/registration")
  public String addUser(String name, String username, String password)
  {
     User user = new User();
     user.setName(name);
     user.setUsername(username);
     user.setPassword(passwordEncoder.encode(password));
     user.setActive(true);
     user.setRoles(Collections.singleton(Role.USER));

     userRepo.save(user);

     return "redirect:/login";
  }

Pengontrol yang bertanggung jawab atas halaman daftar catatan saat ini berisi fungsionalitas yang disederhanakan, yang akan menjadi lebih kompleks setelah penerapan Spring Security.

@Controller
public class NoteController
{
  @Autowired
  private NoteRepo noteRepo;

  @GetMapping("/notes")
  public String notes(Model model)
  {
     List<Note> notes = noteRepo.findAll();
     model.addAttribute("notes", notes);

     return "notes";
  }

  @PostMapping("/addnote")
  public String addNote(String title, String note)
  {
     Note newNote = new Note();
     newNote.setTitle(title);
     newNote.setNote(note);

     noteRepo.save(newNote);

     return "redirect:/notes";
  }
}

Kami tidak akan menulis pengontrol untuk halaman login karena digunakan oleh Spring Security. Sebaliknya, kita memerlukan konfigurasi khusus. Seperti biasa, mari buat paket lain, beri nama config, dan tempatkan kelas di sana MvcConfig. Saat kita menulis konfigurasi Spring Security, ia akan mengetahui halaman mana yang kita maksud saat kita menggunakan "/ login".

@Configuration
public class MvcConfig implements WebMvcConfigurer
{
  public void addViewControllers(ViewControllerRegistry registry)
  {
     registry.addViewController("/login").setViewName("login");
     registry.setOrder(Ordered.HIGHEST_PRECEDENCE);
  }
}

Halaman

Saya menggunakan mesin template Kumis untuk membuat halaman . Anda bisa menerapkan yang lain, tidak masalah. File meta.mustache telah dibuat untuk informasi meta yang digunakan di semua halaman. Ini juga menyertakan Bootstrap untuk membuat halaman proyek kita terlihat lebih cantik. Halaman dibuat di direktori "src/main/resources/templates". File-file tersebut memiliki ekstensi kumis. Menempatkan kode html langsung di artikel akan membuatnya terlalu besar, jadi berikut ini tautan ke folder templat di repositori GitHub proyek .

Mengonfigurasi Keamanan Musim Semi untuk Login Klasik

Spring Security membantu kami melindungi aplikasi dan sumber dayanya dari akses tidak sah. Kami akan membuat konfigurasi kerja ringkas di kelas SecurityConfigyang diwarisi darinya WebSecurityConfigurerAdapter, yang akan kami tempatkan di paket config. Mari kita tandai dengan anotasi @EnableWebSecurity, yang akan mengaktifkan dukungan Spring Security, dan anotasi @Configuration, yang menunjukkan bahwa kelas ini berisi beberapa konfigurasi. Catatan: pom.xml yang dikonfigurasi secara otomatis berisi versi komponen induk Spring Boot 2.1.4.RELEASE, yang mencegah Keamanan diterapkan dengan cara yang sudah ada. Untuk menghindari konflik dalam proyek, disarankan untuk mengubah versi ke 2.0.1.RELEASE.

Konfigurasi dasar SecurityConfig

Konfigurasi kami akan dapat:

1. Enkripsi kata sandi menggunakan BCryptPasswordEncoder:

   @Autowired
   private PasswordEncoder passwordEncoder;
   
   @Bean
   PasswordEncoder passwordEncoder()
   {
     PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
     return passwordEncoder;
   }

2. Masuk menggunakan penyedia otentikasi yang ditulis khusus:

   @Autowired
   private AuthProvider authProvider;
   
   @Override
   protected void configure(AuthenticationManagerBuilder auth)
   {
     auth.authenticationProvider(authProvider);
   }

3. Izinkan pengguna anonim mengakses halaman beranda, halaman registrasi dan login. Semua permintaan lainnya harus dilakukan oleh pengguna yang masuk. Mari kita tetapkan “/ login” yang dijelaskan sebelumnya sebagai halaman login. Jika login berhasil maka pengguna akan dibawa ke halaman yang berisi daftar catatan, jika terjadi kesalahan maka pengguna akan tetap berada di halaman login. Setelah berhasil keluar, pengguna akan dibawa ke halaman utama.

   @Override
   protected void configure(HttpSecurity http) throws Exception
   {
     http
           .authorizeRequests()
           .antMatchers("/resources/**", "/", "/login**", "/registration").permitAll()
           .anyRequest().authenticated()
           .and().formLogin().loginPage("/login")
           .defaultSuccessUrl("/notes").failureUrl("/login?error").permitAll()
           .and().logout().logoutSuccessUrl("/").permitAll();
   }

Login pengguna khusus

Yang ditulis sendiri AuthProviderakan memungkinkan pengguna untuk masuk tidak hanya melalui email, tetapi juga dengan nama pengguna.

@Component
public class AuthProvider implements AuthenticationProvider
{
  @Autowired
  private UserService userService;

  @Autowired
  private PasswordEncoder passwordEncoder;

  public Authentication authenticate(Authentication authentication) throws AuthenticationException
  {
     String username = authentication.getName();
     String password = (String) authentication.getCredentials();

     User user = (User) userService.loadUserByUsername(username);

     if(user != null && (user.getUsername().equals(username) || user.getName().equals(username)))
     {
        if(!passwordEncoder.matches(password, user.getPassword()))
        {
           throw new BadCredentialsException("Wrong password");
        }

        Collection<? extends GrantedAuthority> authorities = user.getAuthorities();

        return new UsernamePasswordAuthenticationToken(user, password, authorities);
     }
     else
        throw new BadCredentialsException("Username not found");
  }

  public boolean supports(Class<?> arg)
  {
     return true;
  }
}

Seperti yang mungkin Anda ketahui, kelas UserServiceyang terletak di dalam paket bertanggung jawab untuk memuat pengguna services. Dalam kasus kami, ia mencari pengguna tidak hanya berdasarkan bidang username, seperti penerapan bawaan, tetapi juga berdasarkan nama pengguna, nama akun Google, dan email akun Google. Dua metode terakhir akan berguna bagi kita saat mengimplementasikan login melalui OAuth2. Di sini kelas diberikan dalam versi singkat.

@Service
public class UserService implements UserDetailsService
{
  @Autowired
  private UserRepo userRepo;

  @Override
  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException
  {
     User userFindByUsername = userRepo.findByUsername(username);
     //Остальные поиски

     if(userFindByUsername != null)
     {
        return userFindByUsername;
     }
     //Остальные проверки
     return null;
  }
}

Catatan: jangan lupa untuk menulis metode yang diperlukan di UserRepo!

Mari tingkatkan pengontrolnya

Kami telah mengonfigurasi Keamanan Musim Semi. Sekaranglah waktunya untuk memanfaatkan ini di pengontrol catatan Anda. Sekarang setiap pemetaan akan menerima parameter Utama tambahan, yang dengannya ia akan mencoba menemukan pengguna. Mengapa saya tidak bisa langsung menginjeksi kelas User? Kemudian akan terjadi konflik akibat ketidaksesuaian tipe pengguna saat kita menulis login melalui jejaring sosial. Kami memberikan fleksibilitas yang diperlukan sebelumnya. Kode pengontrol catatan kami sekarang terlihat seperti ini:

@GetMapping("/notes")
public String notes(Principal principal, Model model)
{
  User user = (User) userService.loadUserByUsername(principal.getName());
  List<Note> notes = noteRepo.findByUserId(user.getId());
  model.addAttribute("notes", notes);
  model.addAttribute("user", user);

  return "notes";
}

@PostMapping("/addnote")
public String addNote(Principal principal, String title, String note)
{
  User user = (User) userService.loadUserByUsername(principal.getName());

  Note newNote = new Note();
  newNote.setTitle(title);
  newNote.setNote(note);
  newNote.setUserId(user.getId());

  noteRepo.save(newNote);

  return "redirect:/notes";
}

Catatan: proyek ini memiliki perlindungan CSRF yang diaktifkan secara default , jadi nonaktifkan sendiri (http.csrf().disable()), atau jangan lupa, sebagai penulis artikel, untuk menambahkan bidang tersembunyi dengan token csrf untuk semua permintaan posting.

Meluncurkan

Kami sedang mencoba meluncurkan proyek tersebut. Kami melihat bahwa pengguna baru telah muncul di database. Kata sandi dienkripsi. Catatan disimpan ke database. Kami melihat proyek berhasil diluncurkan dan dijalankan. Untuk kebahagiaan seutuhnya, kita hanya membutuhkan kemampuan untuk login melalui jejaring sosial. Baiklah, mari kita mulai!

Menyiapkan OAuth2 menggunakan Google sebagai contoh di Spring Security

Saat mengimplementasikan OAuth2, saya mengandalkan tutorial resmi dari Spring ini . Untuk mendukung OAuth2, tambahkan perpustakaan berikut ke pom.xml:

<dependency>
  <groupId>org.springframework.security.oauth.boot</groupId>
  <artifactId>spring-security-oauth2-autoconfigure</artifactId>
  <version>2.0.0.RELEASE</version>
</dependency>

Mari kita ubah konfigurasi Keamanan Musim Semi kita di file SecurityConfig. Pertama, mari tambahkan anotasi @EnableOAuth2Client. Ini secara otomatis akan menarik apa yang Anda perlukan untuk masuk melalui jejaring sosial.

Filter konfigurasi dan properti aplikasi

Mari masukkan OAuth2ClientContext untuk digunakan dalam konfigurasi keamanan kita.

@Autowired
private OAuth2ClientContext oAuth2ClientContext;

OAuth2ClientContext digunakan saat membuat filter yang memvalidasi permintaan login sosial pengguna. Filter tersedia berkat anotasi @EnableOAuth2Client. Yang perlu kita lakukan hanyalah memanggilnya dalam urutan yang benar, sebelum filter utama Keamanan Musim Semi. Hanya dengan begitu kita dapat menangkap pengalihan selama proses login dengan OAuth2. Untuk melakukan ini, kami menggunakan FilterRegistrationBean, di mana kami menetapkan prioritas filter kami ke -100.

@Bean
public FilterRegistrationBean oAuth2ClientFilterRegistration(OAuth2ClientContextFilter oAuth2ClientContextFilter)
{
  FilterRegistrationBean registration = new FilterRegistrationBean();
  registration.setFilter(oAuth2ClientContextFilter);
  registration.setOrder(-100);
  return registration;
}

private Filter ssoFilter()
{
  OAuth2ClientAuthenticationProcessingFilter googleFilter = new OAuth2ClientAuthenticationProcessingFilter("/login/google");
  OAuth2RestTemplate googleTemplate = new OAuth2RestTemplate(google(), oAuth2ClientContext);
  googleFilter.setRestTemplate(googleTemplate);
  CustomUserInfoTokenServices tokenServices = new CustomUserInfoTokenServices(googleResource().getUserInfoUri(), google().getClientId());
  tokenServices.setRestTemplate(googleTemplate);
  googleFilter.setTokenServices(tokenServices);
  tokenServices.setUserRepo(userRepo);
  tokenServices.setPasswordEncoder(passwordEncoder);
  return googleFilter;
}

Anda juga perlu menambahkan filter baru ke fungsi konfigurasi (HttpSecurity http):

http.addFilterBefore(ssoFilter(), UsernamePasswordAuthenticationFilter.class);

Filter juga perlu mengetahui bahwa klien telah mendaftar melalui Google. Anotasi @ConfigurationProperties menentukan properti konfigurasi mana yang harus dicari di application.properties.

@Bean
@ConfigurationProperties("google.client")
public AuthorizationCodeResourceDetails google()
{
  return new AuthorizationCodeResourceDetails();
}

Untuk menyelesaikan autentikasi, Anda perlu menentukan titik akhir informasi pengguna Google:

@Bean
@ConfigurationProperties("google.resource")
public ResourceServerProperties googleResource()
{
  return new ResourceServerProperties();
}

Setelah mendaftarkan aplikasi kami di Google Cloud Platform , kami akan menambahkan properti dengan awalan yang sesuai ke application.properties:

google.client.clientId=yourClientId
google.client.clientSecret=yourClientSecret
google.client.accessTokenUri=https://www.googleapis.com/oauth2/v4/token
google.client.userAuthorizationUri=https://accounts.google.com/o/oauth2/v2/auth
google.client.clientAuthenticationScheme=form
google.client.scope=openid,email,profile
google.resource.userInfoUri=https://www.googleapis.com/oauth2/v3/userinfo
google.resource.preferTokenInfo=true

Sorotan mendaftarkan aplikasi ke Google Cloud Platform

Jalur: API dan Layanan -> Kredensial Jendela Permintaan Akses OAuth:

• Nama aplikasi: Formulir login pegas dan tutorial OAuth2
• Alamat email dukungan: email Anda
• Cakupan untuk Google API: email, profil, openid
• Domain resmi: me.org
• Tautan ke halaman utama aplikasi: http://me.org:8080
• Tautan ke kebijakan privasi aplikasi: http://me.org:8080
• Tautan ke ketentuan penggunaan aplikasi: http://me.org:8080

Kredensial:

• Jenis: Aplikasi Web
• Judul: Formulir login musim semi dan tutorial OAuth2
• Sumber JavaScript yang diizinkan: http://me.org, http://me.org:8080
• URI pengalihan yang diizinkan: http://me.org:8080/login, http://me.org:8080/login/google

Catatan: karena Google tidak ingin bekerja dengan alamat localhost:8080, tambahkan baris “127.0.0.1 me.org” atau sesuatu yang mirip dengan file C:\Windows\System32\drivers\etc\hosts di akhir. Yang penting domainnya dalam bentuk klasik.

Layanan CustomUserInfoToken

Apakah Anda memperhatikan kata Custom dalam deskripsi fungsi filter? Kelas CustomUserInfoTokenServices. Ya, kami akan membuat kelas kami sendiri dengan blackjack dan kemampuan untuk menyimpan pengguna di database! Menggunakan pintasan keyboard Ctrl-N di IntelliJ IDEA, Anda dapat menemukan dan melihat bagaimana UserInfoTokenServicesdefault diterapkan. Mari salin kodenya ke kelas yang baru dibuat CustomUserInfoTokenServices. Sebagian besar dapat dibiarkan tidak berubah. Sebelum mengubah logika fungsi, mari tambahkan UserRepodan sebagai bidang privat kelas PasswordEncoder. Mari buat setter untuk mereka. Mari tambahkan @Autowired UserRepo userRepo ke kelas SecurityConfig. Kami melihat bagaimana penunjuk kesalahan dalam metode pembuatan filter menghilang, dan kami bersukacita. Mengapa @Autowired tidak dapat diterapkan langsung ke CustomUserInfoTokenServices? Karena kelas ini tidak akan mengambil ketergantungan, karena kelas itu sendiri tidak ditandai dengan anotasi Spring apa pun, dan konstruktornya dibuat secara eksplisit ketika filter dideklarasikan. Oleh karena itu, mekanisme DI Spring tidak mengetahuinya. Jika kita memberi anotasi @Autowired pada apa pun di kelas ini, kita akan mendapatkan NullPointerException saat digunakan. Namun melalui penyetel eksplisit semuanya bekerja dengan sangat baik. Setelah mengimplementasikan komponen-komponen yang diperlukan, objek utama yang menarik adalah fungsi loadAuthentication, yang mana Map<String, Object> dengan informasi tentang pengguna diambil. Dalam proyek inilah saya menerapkan penyimpanan pengguna yang masuk melalui jejaring sosial ke dalam database. Karena kami menggunakan akun Google sebagai penyedia OAuth2, kami memeriksa apakah peta berisi bidang "sub" yang umum untuk Google. Jika ada, berarti informasi tentang pengguna telah diterima dengan benar. Kami membuat pengguna baru dan menyimpannya ke database.

@Override
public OAuth2Authentication loadAuthentication(String accessToken)
     throws AuthenticationException, InvalidTokenException
{
  Map<String, Object> map = getMap(this.userInfoEndpointUrl, accessToken);

  if(map.containsKey("sub"))
  {
     String googleName = (String) map.get("name");
     String googleUsername = (String) map.get("email");

     User user = userRepo.findByGoogleUsername(googleUsername);

     if(user == null)
     {
        user = new User();
        user.setActive(true);
        user.setRoles(Collections.singleton(Role.USER));
     }

     user.setName(googleName);
     user.setUsername(googleUsername);
     user.setGoogleName(googleName);
     user.setGoogleUsername(googleUsername);
     user.setPassword(passwordEncoder.encode("oauth2user"));

     userRepo.save(user);
  }

  if (map.containsKey("error"))
  {
     this.logger.debug("userinfo returned error: " + map.get("error"));
     throw new InvalidTokenException(accessToken);
  }
  return extractAuthentication(map);
}

Saat menggunakan beberapa penyedia, Anda dapat menentukan opsi berbeda dalam satu CustomUserInfoTokenServices, dan mendaftarkan kelas layanan serupa yang berbeda dalam metode deklarasi filter. Sekarang Pengguna dan OAuth2Authentication dapat bertindak sebagai Prinsipal. Karena kami memperhitungkan terlebih dahulu di UserService pemuatan pengguna melalui data Google, aplikasi akan berfungsi untuk kedua jenis pengguna. Kami memodifikasi pengontrol halaman utama proyek sehingga mengarahkan pengguna yang login menggunakan OAuth2 ke halaman catatan.

@GetMapping("/")
public String index(Principal principal)
{
  if(principal != null)
  {
     return "redirect:/notes";
  }
  return "index";
}

Peluncuran akhir proyek

Setelah sedikit perubahan tampilan dan penambahan tombol keluar, kami melakukan peluncuran akhir proyek. Pengguna berhasil login baik melalui formulir biasa maupun melalui akun Google. Inilah yang kami inginkan! Saya harap artikel ini menjelaskan beberapa poin tentang membuat aplikasi web, mengamankannya dengan Spring Security, dan menggabungkan metode login yang berbeda. Dengan kode proyek lengkap Anda bisa