Spring Boot Security මුල සිට: Basic Auth SC Guide | Lankan Dev Guide

ආයුබෝවන් කොහොමද යාලුවනේ! අද අපි කතා කරන්නේ අපේ software වලට ආරක්ෂාව කොහොමද දෙන්නේ කියලා. ඒ කියන්නේ, Security. දැන් බලන්න, apps හැදුවට විතරක් මදි. ඒවට ආරක්ෂාවක් නැත්නම්, හැමදේම අවුල් යනවා. අපේ data ටික හොරු අතට යන්න පුළුවන්, අනවසරෙන් system එකට ඇතුල් වෙන්න පුළුවන්. මේ වගේ අවදානම් වලක්වගන්න තමයි අපි Security ගැන හිතන්නේ.

මේකට තමයි Spring Boot Security අපිට ලොකු හයියක් වෙන්නේ. Spring Boot Security කියන්නේ Java developers ලා අතරේ ගොඩක් ජනප්‍රිය framework එකක්, ඒක අපේ applications වලට authentication (කවුද මේ user කියල හඳුනාගන්න එක) සහ authorization (user ට මොන මොන දේවල් කරන්න පුලුවන්ද කියල තීරණය කරන එක) වගේ පහසුකම් ඉතාම සරලව එකතු කරන්න උදව් වෙනවා. ඒ කියන්නේ, ඔයාගේ app එකට login page එකක් හදන්න, users ලට විවිධ access levels දෙන්න, වගේ දේවල් පහසුවෙන්ම කරන්න පුළුවන්.

අද අපි බලමු Spring Boot Security පාවිච්චි කරලා කොහොමද Basic Authentication එකක් අපේ project එකට දාගන්නේ කියලා. මේක තමයි security වල මූලිකම පියවර.

Spring Boot Security කියන්නේ මොකක්ද?

Spring Boot Security කියන්නේ Spring Framework එකේම කොටසක්. අපේ applications වලට ආරක්ෂක පහසුකම් ඉක්මනින් හා පහසුවෙන් එකතු කරන්න පුලුවන් විදිහට තමයි මේක design කරලා තියෙන්නේ. මේකේ ප්‍රධානම කොටස් දෙකක් තියෙනවා:

• Authentication: මේකෙන් කරන්නේ system එකට ඇතුල් වෙන්න හදන user කවුද කියලා හඳුනාගන්න එක. ඒ කියන්නේ, username එකයි password එකයි හරියට දීලා තියෙනවද කියලා බලන එක.
• Authorization: Authentication සාර්ථක වුණාට පස්සේ, ඒ user ට system එකේ මොන මොන දේවල් කරන්න පුලුවන්ද කියලා තීරණය කරන්නේ මේකෙන්. උදාහරණයක් විදිහට, admin කෙනෙක්ට විතරක් user details වෙනස් කරන්න පුළුවන් වෙන්න, සාමාන්‍ය user කෙනෙක්ට data බලන්න විතරක් පුළුවන් වෙන්න වගේ දේවල්.

Spring Boot Security පාවිච්චි කරන එකේ වාසි ගොඩක් තියෙනවා:

• ඉක්මන් ක්‍රියාත්මක කිරීම: dependency එකක් add කරලා configuration ටිකක් කරගත්තම ඇති.
• බහුල පහසුකම්: Basic Auth වල ඉඳලා JWT, OAuth2 වගේ advanced දේවල් දක්වා හැමදේටම support කරනවා.
• පහසු customization: අපිට ඕන විදිහට security logic එක customize කරන්න පුළුවන්.
• ශක්තිමත් community support: මොනවා හරි ප්‍රශ්නයක් ආවොත් උදව් ඉල්ලන්න විශාල developer community එකක් ඉන්නවා.

පටන් ගමු!

හරි, දැන් අපි අපේ project එකට Spring Boot Security එකතු කරගමු. ඔයාට දැනටමත් Spring Boot project එකක් තියෙන්න ඕනේ. නැත්නම්, Spring Initializr පාවිච්චි කරලා අලුත් project එකක් හදාගන්න පුළුවන්. ඒකට "Spring Web" dependency එක add කරගන්න අමතක කරන්න එපා.

පළවෙනියටම අපේ pom.xml (Maven project එකක් නම්) එහෙමත් නැත්නම් build.gradle (Gradle project එකක් නම්) එකට මේ dependency එක එකතු කරගන්න ඕනේ:

Maven (pom.xml)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Gradle (build.gradle)

implementation 'org.springframework.boot:spring-boot-starter-security'

මේ dependency එක add කරලා project එක rebuild කරපු ගමන්ම, Spring Boot Security active වෙනවා. ඔයාගේ application එක run කරලා බලන්න. දැන් ඕනෑම endpoint එකකට request එකක් යැව්වොත් 401 Unauthorized response එකක් එනවා දකින්න පුළුවන්.

ඒ වගේම, console එකේ random password එකක් generate වෙනවා. Default username එක user. ඒ password එක පාවිච්චි කරලා ඔයාට මුලින්ම system එකට login වෙන්න පුළුවන්.

Using generated security password: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX

Basic Authentication ක්‍රියාත්මක කරමු

Basic Authentication කියන්නේ username එකයි password එකයි HTTP request එකේ Header එකේ encode කරලා යවන සරලම authentication ක්‍රමයක්. මේක HTTP standard එකේම තියෙන දෙයක්.

අපි දැන් බලමු කොහොමද අපිට ඕන username එකයි password එකයි පාවිච්චි කරලා Basic Authentication active කරගන්නේ කියලා.

1. application.properties වලින් Configure කිරීම

සරලම විදිහ තමයි application.properties (නැත්නම් application.yml) file එකේ security properties එකතු කරන එක. මේක development කරනකොට පහසුයි වුණාට, production වලටනම් මේක පාවිච්චි කරන්න හොඳ නැහැ. මොකද password එක plain text විදිහට තියෙන නිසා.

spring.security.user.name=admin
spring.security.user.password={noop}mysecretpassword
spring.security.user.roles=ADMIN

මතක තියාගන්න, {noop} කියන්නේ Password Encoder එකක් නැතුව plain text password එකක් පාවිච්චි කරන්න කියලා Spring Security ට කියන එක. Production environment එකකදී හැමවිටම strong password encoders (ex: BCrypt) පාවිච්චි කරන්න.

2. Java Configuration (Recommended)

වැඩියෙන්ම recommend කරන්නේ Java Configuration පාවිච්චි කරන එක. මේකෙන් අපිට security logic එක ගැන සම්පූර්ණ control එකක් ලැබෙනවා.

මුලින්ම අපි SecurityConfig කියන class එකක් හදාගමු. මේක @Configuration සහ @EnableWebSecurity annotations වලින් decorate කරන්න ඕනේ.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

import static org.springframework.security.config.Customizer.withDefaults;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    // Spring Security 6.x and above recommends SecurityFilterChain bean
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((requests) -> requests
                .anyRequest().authenticated() // Any request requires authentication
            )
            .httpBasic(withDefaults()); // Enable Basic Authentication

        return http.build();
    }

    // Define in-memory user for demonstration
    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
        UserDetails user = User.builder()
            .username("devuser")
            .password(passwordEncoder.encode("devpassword")) // Encode the password
            .roles("USER")
            .build();

        UserDetails admin = User.builder()
            .username("devadmin")
            .password(passwordEncoder.encode("adminpassword"))
            .roles("ADMIN", "USER")
            .build();

        return new InMemoryUserDetailsManager(user, admin);
    }

    // Password Encoder bean - essential for encoding passwords
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

මේ Code එකේ තියෙන වැදගත් කොටස් ටිකක් බලමු:

• @Configuration: මේකෙන් Spring Framework එකට කියනවා මේ class එකේ Bean definitions තියෙනවා කියලා.
• @EnableWebSecurity: මේකෙන් Spring Security configuration enable කරනවා.
• securityFilterChain(HttpSecurity http):
  • authorizeHttpRequests((requests) -> requests.anyRequest().authenticated()): මේකෙන් කියන්නේ අපේ application එකේ ඕනෑම URL එකකට (anyRequest()) access කරන්න නම් authentication (authenticated()) අවශ්‍යයි කියලා.
  • httpBasic(withDefaults()): මේකෙන් Basic Authentication enable කරනවා.
• userDetailsService(PasswordEncoder passwordEncoder):
  • මේ Bean එකෙන් අපිට පුළුවන් අපේ users ලා define කරන්න. උදාහරණයක් විදිහට, අපි devuser සහ devadmin කියන users ලා දෙන්නෙක්ව හදලා තියෙනවා.
  • InMemoryUserDetailsManager: මේකෙන් users ලා memory එකේ තියාගන්නවා. Real-world applications වලදී මේකට database එකක් (JPA, JDBC) පාවිච්චි කරනවා.
  • passwordEncoder.encode("devpassword"): මේක ගොඩක් වැදගත්. Password එක හැමවිටම encode කරන්න ඕනේ. මෙතන අපි BCryptPasswordEncoder එකක් පාවිච්චි කරනවා.
• passwordEncoder(): මේ Bean එකෙන් Password Encoder එක define කරනවා. BCryptPasswordEncoder කියන්නේ passwords encode කරන්න recommend කරන එකක්.

Test කරලා බලමු

හරි, දැන් security configuration එක හදලා ඉවරයි. දැන් අපි test කරලා බලමු අපේ security එක වැඩද කියලා.

මුලින්ම අපි සරල REST Controller එකක් හදාගමු.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Spring Boot Security!";
    }
}

දැන් ඔයාගේ Spring Boot application එක run කරන්න.

Postman, cURL, නැත්නම් browser එකක් පාවිච්චි කරලා http://localhost:8080/hello URL එකට request එකක් යවන්න. ඔයාට 401 Unauthorized response එකක් ලැබෙයි. ඒ කියන්නේ අපේ security එක වැඩ.

දැන් Postman වගේ tool එකක් පාවිච්චි කරලා Basic Auth credentials එක්ක request එකක් යවන්න. Postman වල Auth tab එකට ගිහින් Basic Auth තෝරලා, අපි SecurityConfig එකේ හදපු devuser username එකයි devpassword එකයි දෙන්න. නැත්නම් devadmin username එකයි adminpassword එකයි දෙන්න.

දැන් request එක send කරපු ගමන්, ඔයාට Hello from Spring Boot Security! කියන message එකයි 200 OK status එකයි ලැබෙයි. සුපිරි නේද?

අවසන් වචන

අද අපි Spring Boot Security පාවිච්චි කරලා කොහොමද Basic Authentication එකක් අපේ project එකට දාගන්නේ කියලා බැලුවා. මේක Security වල මුල විතරයි. නමුත් ඔයාගේ application එක ආරක්ෂා කරන්න මේක ගොඩක් වැදගත් පියවරක්. අපි application.properties පාවිච්චි කරලා සරලව user details define කරන විදිහයි, ඒ වගේම Java Configuration පාවිච්චි කරලා වඩාත් secure විදිහට customize කරන විදිහයි ඉගෙනගත්තා.

ඊලඟ ලිපි වලින් අපි JWT (JSON Web Tokens), OAuth2, Form-based authentication වගේ advanced topics ගැන කතා කරමු. ඒ වගේම, production environment එකකදී security එකට අදාළව තවත් හොඳ practices ගැනත් බලමු.

ඔයාලත් මේක try කරලා බලන්න. මොනාහරි ප්‍රශ්න තියෙනවා නම්, comment section එකේ අහන්න. මේ ලිපිය ඔයාලට වැදගත් වුණා නම් share කරන්නත් අමතක කරන්න එපා. එහෙනම් ආයෙත් අලුත් ලිපියකින් හම්බවෙමු! සුභ දවසක්!