S03L05 - स्प्रिंग बूट ऑथ कंट्रोलर, उपयोगकर्ताओं की सूची, सुरक्षा जोड़ें

html

Spring Boot APIs को Spring Security और JWT Authentication के साथ सुरक्षित करना
सामग्री तालिका

परिचय ................................................................. 1
Spring Security को समझना ................. 3
JWT के साथ टोकन-आधारित प्रमाणीकरण ..... 7
सिक्योरिटी कॉन्फ़िगरेशन लागू करना ..... 12
Auth Controller बनाना ................... 18
उपयोगकर्ता भूमिकाओं और अधिकारों का प्रबंधन ... 25
सिक्योरिटी अपवादों को संभालना .................... 30
सुरक्षित API का परीक्षण करना ............................ 35
निष्कर्ष ......................................................................... 42


परिचय
वेब विकास के आधुनिक परिदृश्य में, APIs को सुरक्षित करना अति महत्वपूर्ण है। जैसे-जैसे अनुप्रयोगों की जटिलता बढ़ती है और वे संवेदनशील डेटा को संभालते हैं, मजबूत प्रमाणीकरण और प्राधिकरण तंत्र सुनिश्चित करना अनिवार्य हो जाता है। यह eBook Spring Boot APIs को Spring Security के साथ JSON Web Tokens (JWT) का उपयोग करके टोकन-आधारित प्रमाणीकरण के माध्यम से सुरक्षित करने में गहराई से डुबकी लगाता है। हम Spring Security की जटिलताओं का अन्वेषण करेंगे, JWT-आधारित प्रमाणीकरण लागू करेंगे, उपयोगकर्ता भूमिकाओं का प्रबंधन करेंगे, सिक्योरिटी अपवादों को संभालेंगे, और हमारी सुरक्षित API का परीक्षण करेंगे ताकि अटूट सुरक्षा सुनिश्चित हो सके।
APIs को सुरक्षित करने का महत्व
APIs अक्सर आधुनिक अनुप्रयोगों की रीढ़ के रूप में कार्य करते हैं, विभिन्न सेवाओं और क्लाइंट्स के बीच संचार को सुविधाजनक बनाते हैं। उचित सुरक्षा उपायों के बिना, APIs अवैध पहुंच, डेटा उल्लंघन और संसाधनों के दुरुपयोग जैसे विभिन्न खतरों के प्रति संवेदनशील होते हैं। मजबूत सुरक्षा को लागू करने से यह सुनिश्चित होता है कि केवल प्रमाणीकरण प्राप्त और अधिकृत उपयोगकर्ता आपके API के साथ इंटरैक्ट कर सकते हैं, आपके डेटा और उपयोगकर्ताओं दोनों की सुरक्षा करते हैं।
इस eBook का उद्देश्य
यह eBook शुरुआती और बुनियादी ज्ञान वाले डेवलपर्स के लिए Spring Boot APIs को प्रभावी ढंग से सुरक्षित करने के लिए एक व्यापक मार्गदर्शिका प्रदान करने का लक्ष्य रखता है। विस्तृत व्याख्याओं, कोड स्निपेट्स, और व्यावहारिक उदाहरणों के माध्यम से, आप उन कौशलों को प्राप्त करेंगे जो आपको आत्मविश्वास के साथ अपने अनुप्रयोगों में सुरक्षा को लागू और प्रबंधित करने में मदद करेंगे।
तालिका अवलोकन


विषय
विवरण


Spring Security
Spring Boot प्रोजेक्ट्स में Spring Security का अवलोकन और सेटअप


JWT Authentication
टोकन-आधारित प्रमाणीकरण को समझना और लागू करना


Security Configurations
APIs के लिए सुरक्षा सेटिंग्स कॉन्फ़िगर करना


Auth Controller
प्रमाणीकरण प्रक्रियाओं को संभालने के लिए कंट्रोलर्स बनाना


User Roles and Authorities
उपयोगकर्ता भूमिकाओं और अनुमतियों का प्रबंधन


Security Exceptions
सिक्योरिटी अपवादों को संभालना और अनुकूलित करना


Testing Secured APIs
सुरक्षा उपायों के कार्यान्वयन की पुष्टि करना


JWT Authentication का उपयोग कब और कहाँ करें
JWT-आधारित प्रमाणीकरण बिना राज्य के अनुप्रयोगों, माइक्रोसेवाओं, और उन परिदृश्यों के लिए उपयुक्त है जहाँ स्केलेबिलिटी महत्वपूर्ण है। यह पार्टियों के बीच जानकारी के सुरक्षित संचार की अनुमति देता है और प्रमाणीकरण और प्राधिकरण को संभालने में इसकी सरलता और प्रभावकारिता के कारण व्यापक रूप से अपनाया जाता है।

Spring Security को समझना
Spring Security एक शक्तिशाली और अत्यधिक अनुकूलन योग्य फ्रेमवर्क है जिसे Java अनुप्रयोगों में प्रमाणीकरण और प्राधिकरण को संभालने के लिए डिज़ाइन किया गया है। यह Spring Boot के साथ सहजता से एकीकृत होता है, Comprehensive सुरक्षा सुविधाएं प्रदान करता है।
Spring Security की मुख्य विशेषताएँ

Authentication and Authorization: उपयोगकर्ता लॉगिन प्रक्रियाओं और संसाधन अभिगम नियंत्रण को संभालता है।
Comprehensive Support: विभिन्न प्रमाणीकरण तंत्रों का समर्थन करता है, जैसे फॉर्म-आधारित, OAuth2, और LDAP।
Extensibility: विशिष्ट सुरक्षा आवश्यकताओं को पूरा करने के लिए आसानी से अनुकूलित किया जा सकता है।
Protection Against Common Threats: CSRF, session fixation, और अन्य हमलों से सुरक्षा करता है।

Spring Boot में Spring Security सेटअप करना
अपने Spring Boot प्रोजेक्ट में Spring Security को एकीकृत करने के लिए, इन चरणों का पालन करें:

Add Dependency: अपने pom.xml में Spring Security डिपेंडेंसी शामिल करें।





		
		
			
			
Java
			
			&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;

			
				
					
				
					1
2
3
4
5
				
						&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-security&lt;/artifactId&gt;
&lt;/dependency&gt;
 
					
				
			
		



Configure Security Settings: सुरक्षा व्यवहारों को परिभाषित करने के लिए एक सुरक्षा कॉन्फ़िगरेशन क्लास बनाएं।





		
		
			
			
Java
			
			@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .anyRequest().authenticated();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .anyRequest().authenticated();
    }
}
 
					
				
			
		



Define User Details Service: उपयोगकर्ता-विशिष्ट डेटा को लोड करने के लिए एक सेवा को लागू करें।





		
		
			
			
Java
			
			@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), new ArrayList&lt;&gt;());
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						@Service
public class MyUserDetailsService implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }
        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), new ArrayList&lt;&gt;());
    }
}
 
					
				
			
		


Spring Security का उपयोग करने के लाभ

Comprehensive Security: आउट ऑफ द बॉक्स व्यापक सुरक्षा सुविधाएं प्रदान करता है।
Ease of Integration: आसानी से Spring Boot अनुप्रयोगों के साथ एकीकृत होता है।
Customizable: विशिष्ट सुरक्षा आवश्यकताओं को पूरा करने के लिए उच्च अनुकूलन योग्य।
Active Community and Support: अच्छी तरह से प्रलेखित और मजबूत समुदाय समर्थन के साथ।


JWT के साथ टोकन-आधारित प्रमाणीकरण
JSON Web Tokens (JWT) प्रमाणीकरण और प्राधिकरण को संभालने के लिए एक बिना राज्य वाला और स्केलेबल विधि प्रदान करते हैं। पारंपरिक सत्र-आधारित प्रमाणीकरण के विपरीत, JWT सर्वर-साइड सत्रों की आवश्यकता को समाप्त करता है, प्रदर्शन और स्केलेबिलिटी को बढ़ाता है।
JWT क्या है?
JWT दो पार्टियों के बीच स्थानांतरित किए जाने वाले दावों का प्रतिनिधित्व करने का एक संक्षिप्त, URL-सुरक्षित माध्यम है। टोकन तीन भागों में विभाजित होता है:

Header: टोकन प्रकार और हैशिंग एल्गोरिद्म को निर्दिष्ट करता है।
Payload: दावे या डेटा को शामिल करता है।
Signature: टोकन की अखंडता को सुनिश्चित करता है।

Authentication में JWT कैसे काम करता है

User Login: उपयोगकर्ता सर्वर को क्रेडेंशियल्स भेजता है।
Token Generation: सफल प्रमाणीकरण पर, सर्वर JWT उत्पन्न करता है और उसे उपयोगकर्ता को भेजता है।
Token Storage: क्लाइंट JWT को स्टोर करता है (आमतौर पर लोकल स्टोरेज या कुकिज में)।
Authenticated Requests: क्लाइंट आगे के अनुरोधों के लिए Authorization हेडर में JWT शामिल करता है।
Token Verification: सर्वर JWT की वैधता की पुष्टि करता है और टोकन के दावों के आधार पर एक्सेस प्रदान या अस्वीकार करता है।

JWT के उपयोग के लाभ

Stateless: सर्वर पर सत्र जानकारी स्टोर करने की आवश्यकता नहीं।
Scalable: वितरित प्रणालियों और माइक्रोसेवाओं के लिए उपयुक्त।
Secure: डेटा की अखंडता और गोपनीयता सुनिश्चित करने के लिए हस्ताक्षरित और एन्क्रिप्ट किया जा सकता है।
Flexible: विभिन्न उपयोग के मामलों के लिए विभिन्न पेलोड संरचनाओं का समर्थन करता है।

Spring Boot में JWT को लागू करना
Spring Boot में JWT-आधारित प्रमाणीकरण को लागू करने के लिए:

Generate JWT: सफल प्रमाणीकरण पर टोकन बनाएं।





		
		
			
			
Java
			
			public class JwtUtil {
    private String secret = "mysecretkey";

    public String generateToken(UserDetails userDetails) {
        Map&lt;String, Object&gt; claims = new HashMap&lt;&gt;();
        return createToken(claims, userDetails.getUsername());
    }

    private String createToken(Map&lt;String, Object&gt; claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						public class JwtUtil {
    private String secret = "mysecretkey";
 
    public String generateToken(UserDetails userDetails) {
        Map&lt;String, Object&gt; claims = new HashMap&lt;&gt;();
        return createToken(claims, userDetails.getUsername());
    }
 
    private String createToken(Map&lt;String, Object&gt; claims, String subject) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
}
 
					
				
			
		



Validate JWT: टोकन की अखंडता और समाप्ति की पुष्टि करें।





		
		
			
			
Java
			
			public boolean validateToken(String token, UserDetails userDetails) {
    final String username = extractUsername(token);
    return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
}

			
				
					
				
					1
2
3
4
5
				
						public boolean validateToken(String token, UserDetails userDetails) {
    final String username = extractUsername(token);
    return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
}
 
					
				
			
		



Use JWT in Requests: टोकन को Authorization हेडर में शामिल करें।





		
		
			
			
Java
			
			Authorization: Bearer &lt;token&gt;

			
				
					
				
					1
2
				
						Authorization: Bearer &lt;token&gt;
 
					
				
			
		



सिक्योरिटी कॉन्फ़िगरेशन लागू करना
Spring Security को कॉन्फ़िगर करना महत्वपूर्ण है ताकि यह निर्धारित किया जा सके कि आपका आवेदन सुरक्षा संबंधी चिंताओं को कैसे संभालता है। यह अनुभाग JWT-आधारित प्रमाणीकरण सक्षम करने के लिए सुरक्षा कॉन्फ़िगरेशनों की सेटअप को रेखांकित करता है।
Security Configuration Class बनाना
सिक्योरिटी कॉन्फ़िगरेशन क्लास WebSecurityConfigurerAdapter को विस्तारित करता है ताकि सुरक्षा व्यवहारों को अनुकूलित किया जा सके।




		
		
			
			
Java
			
			@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Autowired
    private MyUserDetailsService myUserDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .antMatchers("/users/**").hasAuthority("USER")
            .anyRequest().authenticated()
            .and().sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
				
						@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Autowired
    private JwtRequestFilter jwtRequestFilter;
 
    @Autowired
    private MyUserDetailsService myUserDetailsService;
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService);
    }
 
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .antMatchers("/users/**").hasAuthority("USER")
            .anyRequest().authenticated()
            .and().sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
}
 
					
				
			
		


JWT Request Filter को परिभाषित करना
JWT request filter आने वाले अनुरोधों को अवरुद्ध करता है ताकि JWT को मान्य किया जा सके।




		
		
			
			
Java
			
			@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private MyUserDetailsService myUserDetailsService;

    @Autowired
    private JwtUtil jwtUtil;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
 
        final String authorizationHeader = request.getHeader("Authorization");
 
        String username = null;
        String jwt = null;
 
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
 
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
 
            UserDetails userDetails = this.myUserDetailsService.loadUserByUsername(username);
 
            if (jwtUtil.validateToken(jwt, userDetails)) {
 
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
				
						@Component
public class JwtRequestFilter extends OncePerRequestFilter {
 
    @Autowired
    private MyUserDetailsService myUserDetailsService;
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
 
        final String authorizationHeader = request.getHeader("Authorization");
 
        String username = null;
        String jwt = null;
 
        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
 
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
 
            UserDetails userDetails = this.myUserDetailsService.loadUserByUsername(username);
 
            if (jwtUtil.validateToken(jwt, userDetails)) {
 
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}
 
					
				
			
		


Session Management को कॉन्फ़िगर करना
Session creation policy को stateless पर सेट करना सुनिश्चित करता है कि सर्वर कोई भी session जानकारी स्टोर नहीं करता है, जो JWT के stateless स्वभाव के साथ मेल खाता है।




		
		
			
			
Java
			
			.and().sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.STATELESS);

			
				
					
				
					1
2
3
				
						.and().sessionManagement()
.sessionCreationPolicy(SessionCreationPolicy.STATELESS);
 
					
				
			
		


Security Configurations का सारांश

Disable CSRF: चूंकि JWT CSRF हमलों के प्रति प्रतिरक्षित है, यह सामान्य है कि APIs के लिए CSRF सुरक्षा को अक्षम किया जाए।
Permit All for Auth Endpoints: प्रमाणीकरण एंडपॉइंट्स जैसे /auth/login और /auth/signup के लिए खुला अभिगम अनुमति देता है।
Authorize Requests Based on Roles/Authorities: उपयोगकर्ता भूमिकाओं या अधिकारों के आधार पर विशिष्ट एंडपॉइंट्स तक पहुंच को प्रतिबंधित करता है।
Add JWT Filter: आने वाले अनुरोधों के लिए टोकन को मान्य करने के लिए JWT request filter को एकीकृत करता है।
Set Session Policy to Stateless: सुनिश्चित करता है कि सर्वर पर कोई session डेटा स्टोर नहीं किया जाता है, JWT के stateless स्वभाव को बनाए रखते हुए।


Auth Controller बनाना
Auth Controller उपयोगकर्ता प्रमाणीकरण प्रक्रियाओं को संभालता है, जिसमें लॉगिन और टोकन जनरेशन शामिल है। यह उपयोगकर्ताओं को सफल प्रमाणीकरण पर JWT प्राप्त करने के लिए प्रवेश बिंदु के रूप में कार्य करता है।
AuthController को लागू करना




		
		
			
			
Java
			
			@RestController
@RequestMapping("/auth")
public class AuthController {

    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Autowired
    private MyUserDetailsService userDetailsService;
 
    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public ResponseEntity&lt;?&gt; createAuthenticationToken(@RequestBody UserLoginDTO authenticationRequest) throws Exception {
        try {
            authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(authenticationRequest.getUsername(), authenticationRequest.getPassword())
            );
        }
        catch (BadCredentialsException e) {
            throw new Exception("Incorrect username or password", e);
        }
 
        final UserDetails userDetails = userDetailsService
                .loadUserByUsername(authenticationRequest.getUsername());
 
        final String jwt = jwtUtil.generateToken(userDetails);
 
        return ResponseEntity.ok(new TokenDTO(jwt));
    }

    @PostMapping("/signup")
    public ResponseEntity&lt;?&gt; signup(@RequestBody AccountDTO accountDTO) {
        // Logic to create a new user
        return ResponseEntity.ok("User registered successfully");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
				
						@RestController
@RequestMapping("/auth")
public class AuthController {
 
    @Autowired
    private AuthenticationManager authenticationManager;
 
    @Autowired
    private MyUserDetailsService userDetailsService;
 
    @Autowired
    private JwtUtil jwtUtil;
 
    @PostMapping("/login")
    public ResponseEntity&lt;?&gt; createAuthenticationToken(@RequestBody UserLoginDTO authenticationRequest) throws Exception {
        try {
            authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(authenticationRequest.getUsername(), authenticationRequest.getPassword())
            );
        }
        catch (BadCredentialsException e) {
            throw new Exception("Incorrect username or password", e);
        }
 
        final UserDetails userDetails = userDetailsService
                .loadUserByUsername(authenticationRequest.getUsername());
 
        final String jwt = jwtUtil.generateToken(userDetails);
 
        return ResponseEntity.ok(new TokenDTO(jwt));
    }
 
    @PostMapping("/signup")
    public ResponseEntity&lt;?&gt; signup(@RequestBody AccountDTO accountDTO) {
        // Logic to create a new user
        return ResponseEntity.ok("User registered successfully");
    }
}
 
					
				
			
		


AuthController का स्पष्टीकरण

Login Endpoint (/auth/login):

  - Authentication: AuthenticationManager का उपयोग करके उपयोगकर्ता के क्रेडेंशियल्स को मान्य करता है।

  - JWT Generation: सफल प्रमाणीकरण पर, JwtUtil क्लास का उपयोग करके JWT उत्पन्न करता है।

  - Response: JWT को TokenDTO ऑब्जेक्ट में संलग्न करके लौटाता है।
Signup Endpoint (/auth/signup):

  - User Registration: एक नए उपयोगकर्ता के पंजीकरण के लिए लॉजिक को संभालता है।

  - Response: सफल पंजीकरण की पुष्टि करता है।

DTO क्लासेस
UserLoginDTO




		
		
			
			
Java
			
			public class UserLoginDTO {
    private String username;
    private String password;

    // Getters and Setters
}

			
				
					
				
					1
2
3
4
5
6
7
				
						public class UserLoginDTO {
    private String username;
    private String password;
 
    // Getters and Setters
}
 
					
				
			
		


TokenDTO




		
		
			
			
Java
			
			public class TokenDTO {
    private String token;

    public TokenDTO(String token) {
        this.token = token;
    }

    // Getter
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public class TokenDTO {
    private String token;
 
    public TokenDTO(String token) {
        this.token = token;
    }
 
    // Getter
}
 
					
				
			
		


AccountDTO




		
		
			
			
Java
			
			public class AccountDTO {
    private String username;
    private String password;
    private String role;

    // Getters and Setters
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						public class AccountDTO {
    private String username;
    private String password;
    private String role;
 
    // Getters and Setters
}
 
					
				
			
		


Authentication Exceptions को संभालना
Authentication Exceptions को कस्टमाइज़ करना एरर संदेशों की स्पष्टता को बढ़ाता है और उपयोगकर्ता अनुभव में सुधार करता है।




		
		
			
			
Java
			
			@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(BadCredentialsException.class)
    public ResponseEntity&lt;?&gt; handleBadCredentialsException(BadCredentialsException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid username or password");
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;?&gt; handleGlobalException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@ControllerAdvice
public class CustomExceptionHandler {
 
    @ExceptionHandler(BadCredentialsException.class)
    public ResponseEntity&lt;?&gt; handleBadCredentialsException(BadCredentialsException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid username or password");
    }
 
    @ExceptionHandler(Exception.class)
    public ResponseEntity&lt;?&gt; handleGlobalException(Exception ex) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred");
    }
}
 
					
				
			
		



उपयोगकर्ता भूमिकाओं और अधिकारों का प्रबंधन
उपयोगकर्ता भूमिकाओं और अधिकारों का प्रभावी प्रबंधन यह सुनिश्चित करता है कि उपयोगकर्ताओं के पास आवेदन के भीतर उपयुक्त अभिगम स्तर हों। Spring Security भूमिकाओं और अधिकारों के बीच अंतर करता है, संसाधन अभिगम पर ग्रैन्युलर नियंत्रण प्रदान करता है।
Roles और Authorities को समझना

Roles: उपयोगकर्ताओं का व्यापक वर्गीकरण (जैसे, USER, ADMIN)। आमतौर पर ROLE_ से प्रीफिक्स किए जाते हैं।
Authorities: उपयोगकर्ताओं को असाइन किए गए विशिष्ट अनुमतियाँ (जैसे, READ_PRIVILEGES, WRITE_PRIVILEGES)।

Spring Security में Roles और Authorities को कॉन्फ़िगर करना




		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


उपयोगकर्ताओं को Roles असाइन करना
उपयोगकर्ता खातों को बनाते या अपडेट करते समय, उपयुक्त भूमिकाएँ असाइन करें।




		
		
			
			
Java
			
			public Account createNewUser(AccountDTO accountDTO) {
    Account account = new Account();
    account.setUsername(accountDTO.getUsername());
    account.setPassword(passwordEncoder.encode(accountDTO.getPassword()));
    account.setRoles(Arrays.asList(new Role(accountDTO.getRole())));
    return accountRepository.save(account);
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						public Account createNewUser(AccountDTO accountDTO) {
    Account account = new Account();
    account.setUsername(accountDTO.getUsername());
    account.setPassword(passwordEncoder.encode(accountDTO.getPassword()));
    account.setRoles(Arrays.asList(new Role(accountDTO.getRole())));
    return accountRepository.save(account);
}
 
					
				
			
		


Seed Data कॉन्फ़िगरेशन
Seed data डेटाबेस को पूर्वनिर्धारित उपयोगकर्ताओं और भूमिकाओं के साथ प्रारंभ करता है।




		
		
			
			
Java
			
			@Component
public class SeedData implements CommandLineRunner {

    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public void run(String... args) throws Exception {
        Account admin = new Account();
        admin.setUsername("admin");
        admin.setPassword(passwordEncoder.encode("admin123"));
        admin.setRoles(Arrays.asList(new Role("ADMIN")));

        Account user = new Account();
        user.setUsername("user");
        user.setPassword(passwordEncoder.encode("user123"));
        user.setRoles(Arrays.asList(new Role("USER")));

        accountRepository.save(admin);
        accountRepository.save(user);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
				
						@Component
public class SeedData implements CommandLineRunner {
 
    @Autowired
    private AccountRepository accountRepository;
 
    @Autowired
    private PasswordEncoder passwordEncoder;
 
    @Override
    public void run(String... args) throws Exception {
        Account admin = new Account();
        admin.setUsername("admin");
        admin.setPassword(passwordEncoder.encode("admin123"));
        admin.setRoles(Arrays.asList(new Role("ADMIN")));
 
        Account user = new Account();
        user.setUsername("user");
        user.setPassword(passwordEncoder.encode("user123"));
        user.setRoles(Arrays.asList(new Role("USER")));
 
        accountRepository.save(admin);
        accountRepository.save(user);
    }
}
 
					
				
			
		


Multiple Authorities को संभालना
उपयोगकर्ताओं के पास कई अधिकार हो सकते हैं, जो लचीले अभिगम नियंत्रण को प्रदान करते हैं।




		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/reports/**").hasAnyAuthority("USER", "ADMIN")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/reports/**").hasAnyAuthority("USER", "ADMIN")
        .anyRequest().authenticated()
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


सारांश

Roles and Authorities: व्यापक अभिगम के लिए भूमिकाओं का उपयोग करें और विशिष्ट अनुमतियों के लिए अधिकारों का उपयोग करें।
Assignment: उपयोगकर्ता निर्माण या अपडेट के दौरान भूमिकाओं और अधिकारों को असाइन करें।
Configuration: सुरक्षा कॉन्फ़िगरेशन में भूमिकाओं और अधिकारों के आधार पर अभिगम नियम निर्धारित करें।
Flexibility: जटिल अभिगम नियंत्रण आवश्यकताओं को पूरा करने के लिए कई अधिकारों को लागू करें।


सिक्योरिटी अपवादों को संभालना
सिक्योरिटी अपवादों को सही ढंग से संभालना आपके आवेदन की मजबूती को बढ़ाता है, उपयोगकर्ताओं को स्पष्ट प्रतिक्रिया प्रदान करता है और आवेदन की अखंडता बनाए रखता है।
सामान्य सिक्योरिटी अपवाद

401 Unauthorized: यह संकेत देता है कि अनुरोध में मान्य प्रमाणीकरण क्रेडेंशियल्स की कमी है।
403 Forbidden: यह संकेत देता है कि सर्वर अनुरोध को समझता है लेकिन इसे अधिकृत करने से इंकार करता है।

अपवाद प्रतिक्रियाओं को कस्टमाइज़ करना




		
		
			
			
Java
			
			@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(UnauthorizedException.class)
    public ResponseEntity&lt;?&gt; handleUnauthorizedException(UnauthorizedException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Please check your access token");
    }

    @ExceptionHandler(ForbiddenException.class)
    public ResponseEntity&lt;?&gt; handleForbiddenException(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Insufficient scope or permissions");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						@ControllerAdvice
public class CustomExceptionHandler {
 
    @ExceptionHandler(UnauthorizedException.class)
    public ResponseEntity&lt;?&gt; handleUnauthorizedException(UnauthorizedException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Please check your access token");
    }
 
    @ExceptionHandler(ForbiddenException.class)
    public ResponseEntity&lt;?&gt; handleForbiddenException(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("Insufficient scope or permissions");
    }
}
 
					
				
			
		


Exceptions को संभालने के लिए Security Configurations को अपडेट करना




		
		
			
			
Java
			
			@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and()
        .exceptionHandling()
        .authenticationEntryPoint((request, response, authException) -> {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Please check your access token");
        })
        .accessDeniedHandler((request, response, accessDeniedException) -> {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Insufficient scope or permissions");
        })
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/auth/**").permitAll()
        .antMatchers("/admin/**").hasAuthority("ADMIN")
        .antMatchers("/users/**").hasAuthority("USER")
        .anyRequest().authenticated()
        .and()
        .exceptionHandling()
        .authenticationEntryPoint((request, response, authException) -> {
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Please check your access token");
        })
        .accessDeniedHandler((request, response, accessDeniedException) -> {
            response.sendError(HttpServletResponse.SC_FORBIDDEN, "Insufficient scope or permissions");
        })
        .and().sessionManagement()
        .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    
    http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
}
 
					
				
			
		


Swagger Documentation को Security Responses के साथ बढ़ाना
जब Swagger का उपयोग करके APIs का दस्तावेजीकरण कर रहे हों, तो उपयोगकर्ताओं को संभावित त्रुटि स्थितियों की जानकारी देने के लिए सिक्योरिटी-संबंधी प्रतिक्रियाओं को शामिल करें।




		
		
			
			
Java
			
			@Operation(summary = "List all users", responses = {
    @ApiResponse(responseCode = "200", description = "Successfully retrieved list"),
    @ApiResponse(responseCode = "401", description = "Unauthorized - Please check your access token"),
    @ApiResponse(responseCode = "403", description = "Forbidden - Insufficient scope or permissions")
})
@GetMapping("/users")
public List&lt;User&gt; getAllUsers() {
    return userService.getAllUsers();
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						@Operation(summary = "List all users", responses = {
    @ApiResponse(responseCode = "200", description = "Successfully retrieved list"),
    @ApiResponse(responseCode = "401", description = "Unauthorized - Please check your access token"),
    @ApiResponse(responseCode = "403", description = "Forbidden - Insufficient scope or permissions")
})
@GetMapping("/users")
public List&lt;User&gt; getAllUsers() {
    return userService.getAllUsers();
}
 
					
				
			
		


Exception Handling का सारांश

Clear Messages: विभिन्न प्रकार के अपवादों के लिए उपयोगकर्ता-अनुकूल त्रुटि संदेश प्रदान करें।
Centralized Handling: @ControllerAdvice का उपयोग करके अपवादों को वैश्विक रूप से प्रबंधित करें।
Swagger Integration: API दस्तावेजीकरण में संभावित सिक्योरिटी अपवादों को दस्तावेजित करें।
Maintain Security: त्रुटि संदेशों के माध्यम से संवेदनशील जानकारी उजागर करने से बचें।


सुरक्षित API का परीक्षण करना
यह सुनिश्चित करना कि आपकी सुरक्षा कॉन्फ़िगरेशन अपेक्षित रूप से कार्य करती है, महत्वपूर्ण है। यह अनुभाग प्रमाणीकरण और प्राधिकरण तंत्रों को मान्य करने के लिए परीक्षण रणनीतियों को कवर करता है।
Authentication Flow का परीक्षण करना

Attempt Unauthorized Access:

  - Action: बिना टोकन के एक सुरक्षित एंडपॉइंट तक पहुंचें।

  - Expected Result: 401 Unauthorized प्रतिक्रिया प्राप्त करें।
Login with Valid Credentials:

  - Action: मान्य क्रेडेंशियल्स के साथ /auth/login पर एक POST अनुरोध भेजें।

  - Expected Result: प्रतिक्रिया में JWT प्राप्त करें।
Login with Invalid Credentials:

  - Action: अवैध क्रेडेंशियल्स के साथ /auth/login पर एक POST अनुरोध भेजें।

  - Expected Result: 401 Unauthorized प्रतिक्रिया के साथ एक त्रुटि संदेश प्राप्त करें।

Authorization Flow का परीक्षण करना

Access with Valid Token:

  - Action: प्राप्त JWT का उपयोग करके एक सुरक्षित एंडपॉइंट तक पहुंचें।

  - Expected Result: उचित डेटा के साथ सफल अभिगम।
Access with Invalid Token:

  - Action: एक अवैध या छेड़छाड़ किए गए JWT का उपयोग करें।

  - Expected Result: 401 Unauthorized प्रतिक्रिया प्राप्त करें।
Access with Insufficient Permissions:

  - Action: प्रतिबंधित एंडपॉइंट तक पहुंचने के लिए आवश्यक अधिकारों के बिना JWT का उपयोग करें।

  - Expected Result: 403 Forbidden प्रतिक्रिया प्राप्त करें।

Swagger का उपयोग करके परीक्षण करना
Swagger UI आपकी APIs को इंटरैक्टिव रूप से परीक्षण करने के लिए एक उत्कृष्ट उपकरण है।

Generate Token:

  - /auth/login एंडपॉइंट पर जाएं।

  - मान्य क्रेडेंशियल्स प्रदान करके JWT प्राप्त करें।
Authorize in Swagger:

  - Swagger में "Authorize" बटन पर क्लिक करें।

  - JWT को Bearer <token> के रूप में दर्ज करें।
Access Secured Endpoints:

  - /users या /admin जैसे एंडपॉइंट्स तक पहुंचने का प्रयास करें।

  - टोकन की वैधता और अनुमतियों के आधार पर प्रतिक्रियाओं का निरीक्षण करें।

Postman के साथ Automated Testing
Postman API परीक्षण को स्वचालित और सरल बना सकता है।

Set Up Collections:

  - लॉगिन, सुरक्षित एंडपॉइंट्स तक पहुंचने आदि के लिए अनुरोध बनाएं।
Use Environment Variables:

  - अनुरोधों के बीच टोकन को स्टोर और पुन: उपयोग करें।
Assert Responses:

  - विभिन्न परिदृश्यों के लिए अपेक्षित प्रतिक्रियाओं को परिभाषित करें।

Testing के लिए Sample Code Snippets
Unauthorized Access का परीक्षण करना




		
		
			
			
Java
			
			curl -X GET http://localhost:8080/users

			
				
					
				
					1
2
				
						curl -X GET http://localhost:8080/users
 
					
				
			
		


Expected Response:




		
		
			
			
Java
			
			401 Unauthorized - Please check your access token

			
				
					
				
					1
2
				
						401 Unauthorized - Please check your access token
 
					
				
			
		


Authorized Access का परीक्षण करना




		
		
			
			
Java
			
			curl -X GET http://localhost:8080/users -H "Authorization: Bearer &lt;valid_token&gt;"

			
				
					
				
					1
2
				
						curl -X GET http://localhost:8080/users -H "Authorization: Bearer &lt;valid_token&gt;"
 
					
				
			
		


Expected Response:




		
		
			
			
Java
			
			[
    {
        "id": 1,
        "username": "user1",
        "email": "user1@example.com"
    },
    {
        "id": 2,
        "username": "admin",
        "email": "admin@example.com"
    }
]

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						[
    {
        "id": 1,
        "username": "user1",
        "email": "user1@example.com"
    },
    {
        "id": 2,
        "username": "admin",
        "email": "admin@example.com"
    }
]
 
					
				
			
		


सारांश

Comprehensive Testing: प्रमाणीकरण और प्राधिकरण दोनों फ्लोज़ को मान्य करें।
Use Tools Effectively: Swagger और Postman का उपयोग करके परीक्षण को सुगम बनाएं।
Automate Where Possible: लगातार सुरक्षा जांच सुनिश्चित करने के लिए automated tests लागू करें।
Monitor Responses: यह सुनिश्चित करें कि प्रतिक्रियाएं अपेक्षित सिक्योरिटी व्यवहारों के अनुरूप हैं।


निष्कर्ष
APIs को सुरक्षित करना आधुनिक अनुप्रयोग विकास का एक मौलिक पहलू है, जो संवेदनशील डेटा की सुरक्षा करता है और यह सुनिश्चित करता है कि केवल अधिकृत उपयोगकर्ता ही संरक्षित संसाधनों तक पहुंच सकते हैं। Spring Security को JWT-आधारित टोकन प्रमाणीकरण के साथ एकीकृत करके, डेवलपर्स अपने Spring Boot अनुप्रयोगों में मजबूत, स्केलेबल, और कुशल सुरक्षा तंत्र लागू कर सकते हैं।
इस eBook में, हमने Spring Security की बुनियादी अवधारणाओं, JWT प्रमाणीकरण के यांत्रिकी, सुरक्षा सेटिंग्स को कॉन्फ़िगर करने की जटिलताएं, उपयोगकर्ता भूमिकाओं और अधिकारों का प्रबंधन, सिक्योरिटी अपवादों को संभालना, और प्रभावी ढंग से सुरक्षित APIs का परीक्षण करना खोजा है। प्रत्येक घटक एक सुरक्षित API इकोसिस्टम के निर्माण में महत्वपूर्ण भूमिका निभाता है।
मुख्य निष्कर्ष

Spring Security Integration: Spring Boot के साथ सहजता से एकीकृत होता है ताकि व्यापक सुरक्षा सुविधाएं प्रदान की जा सकें।
JWT Authentication: उपयोगकर्ता प्रमाणीकरण और प्राधिकरण को संभालने के लिए एक stateless और स्केलेबल विधि प्रदान करता है।
Role and Authority Management: उपयोगकर्ता अनुमतियों और अभिगम स्तरों पर सूक्ष्म नियंत्रण सक्षम करता है।
Exception Handling: सुनिश्चित करता है कि सिक्योरिटी-संबंधी त्रुटियों को सहज और जानकारीपूर्ण ढंग से प्रबंधित किया जाता है।
Thorough Testing: सुरक्षा कार्यान्वयन की प्रभावकारिता को मान्य करता है, संभावित कमजोरियों को रोकता है।

जैसे-जैसे अनुप्रयोग आगे बढ़ते हैं, सुरक्षा उपायों को बनाए रखना और बढ़ाना एक निरंतर प्रयास बना रहेगा। डेवलपर्स के लिए सुरक्षित और विश्वसनीय अनुप्रयोग बनाने के लिए सर्वोत्तम प्रथाओं, उभरते खतरों, और अभिनव समाधानों के बारे में सूचित रहना आवश्यक है।
Call to Action
Spring Security और JWT को अपने Spring Boot प्रोजेक्ट्स में एकीकृत करके अपने विकास कार्यप्रवाह को सशक्त बनाएं, और सुरक्षा के बढ़ते चुनौतियों के अनुकूल अपनी सुरक्षा स्थिति को निरंतर परिष्कृत करें। आगे की शिक्षा के लिए, OAuth2 एकीकरण, मल्टी-फैक्टर प्रमाणीकरण, और सिक्योरिटी ऑडिटिंग जैसे उन्नत विषयों का पता लगाएं ताकि API सिक्योरिटी में अपनी विशेषज्ञता को गहरा किया जा सके।

Note: यह लेख AI द्वारा उत्पन्न किया गया है।
विषय	विवरण
Spring Security	Spring Boot प्रोजेक्ट्स में Spring Security का अवलोकन और सेटअप
JWT Authentication	टोकन-आधारित प्रमाणीकरण को समझना और लागू करना
Security Configurations	APIs के लिए सुरक्षा सेटिंग्स कॉन्फ़िगर करना
Auth Controller	प्रमाणीकरण प्रक्रियाओं को संभालने के लिए कंट्रोलर्स बनाना
User Roles and Authorities	उपयोगकर्ता भूमिकाओं और अनुमतियों का प्रबंधन
Security Exceptions	सिक्योरिटी अपवादों को संभालना और अनुकूलित करना
Testing Secured APIs	सुरक्षा उपायों के कार्यान्वयन की पुष्टि करना