CROSS is a system that allows client web applications (such as JavaScript code) loaded on one domain to interact with resources located on a different domain.
Origin: An "Origin" (or source) URL consists of three parts: Protocol (scheme): Such as http or https. Domain (host): Such as a143mk.blogspot.com or localhost. Port (port number): Such as 8080 or 3000. If any of these three parts are different in a request, it is called a Cross-Origin request.
Example:
If your frontend (endpoints.com) sends a request to a backend API (api.com), it is Cross-Origin and will be intercepted by the browser. CORS is a way to relax this security restriction in a controlled manner, allowing legitimate cross-origin communication.

 
import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.RestController; @RestController @CrossOrigin(origins = "http://localhost:3000") // Example: Allow only this Origin public class MyController { // ... methods }
Configuring CORS globally in Spring Boot is the preferred approach, as it saves you from having to apply the @CrossOrigin annotation to every controller or method and keeps the configuration centralized.
Example: This method defines global CORS settings 

package com.example.demo.config; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.CorsRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration public class CorsConfig implements WebMvcConfigurer { @Override public void addCorsMappings(CorsRegistry registry) { registry.addMapping("/**").allowedOrigins("http://localhost:3000", "https://your-client-app.com") .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS").allowedHeaders("*") .allowCredentials(true).maxAge(3600); } }

Implementing JWT (JSON Web Token) in Java typically involves creating a secure authentication mechanism for your web applications. Below is a basic guide to implement JWT using Java, Spring MVC, and jjwt (a popular Java JWT library).

The lifecycle of a JSON Web Token (JWT) typically involves several stages, from creation to expiration and validation. JWTs are widely used for securely transmitting information between parties in the form of a signed and optionally encrypted token. Here’s an overview of the typical lifecycle: Token Creation
Authentication: When a user logs in, they typically provide credentials (e.g., username and password).
Server Validation: The server validates these credentials (e.g., checks the database for the user’s password).
JWT Creation: If the credentials are correct, the server generates a JWT. The token contains:
Header: Describes the signing algorithm (e.g., HS256, RS256) and token type (JWT).
Payload: Contains the claims. Claims are pieces of information (e.g., user ID, expiration time) that are encoded in the token.
Signature: The header and payload are signed with a secret key (HMAC) or a private key (RSA or ECDSA) to ensure integrity.

 
Download Jar file: jjwt-api-0.10.5.jar

To create a A143mk.JWTAPIConfig, we first need to define a package that will be handled in the configuration.
Create classes name in the A143mk.JWTAPIConfig package. 

1. JwtRequestFilter package a143mk.JWTAPIConfig; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.web.filter.OncePerRequestFilter; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebFilter; import javax.servlet.http.HttpServletRequest; import java.io.IOException; @SuppressWarnings("unused") @WebFilter(urlPatterns = "/api/*") public class JwtRequestFilter extends OncePerRequestFilter { private JwtUtil jwtUtil = new JwtUtil(); @Override protected void doFilterInternal(HttpServletRequest request, javax.servlet.http.HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { final String token = request.getHeader("Authorization"); if (token != null && token.startsWith("Bearer ")) { String username = jwtUtil.extractUsername(token.substring(7)); if (username != null && jwtUtil.validateToken(token, username)) { // Set user authentication here } } filterChain.doFilter(request, response); } }
2.JwtUtil package a143mk.JWTAPIConfig; import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import io.jsonwebtoken.security.Keys; import java.security.Key; import java.util.Date; public class JwtUtil { private String secretKey = "a143mkJWT3API"; // use a more secure key in production! // private Key secretKey = Keys.secretKeyFor(SignatureAlgorithm.HS256); // Generate token public String generateToken(String username) { return Jwts.builder() .setSubject(username) .setIssuedAt(new Date()) .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60)) // Token expires in 1 hour .signWith(SignatureAlgorithm.HS256, secretKey) .compact(); } // Extract username from token public String extractUsername(String token) { return extractClaims(token).getSubject(); } // Extract claims (payload) private Claims extractClaims(String token) { return Jwts.parser() .setSigningKey(secretKey) .parseClaimsJws(token) .getBody(); } // Validate token public boolean validateToken(String token, String username) { return (username.equals(extractUsername(token)) && !isTokenExpired(token)); } // Check if token is expired private boolean isTokenExpired(String token) { return extractClaims(token).getExpiration().before(new Date()); } }
3. SecurityConfig package a143mk.JWTAPIConfig; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable() // Disable CSRF .authorizeRequests() .antMatchers("/api/authenticate").permitAll() // Allow unauthenticated access to login endpoint .anyRequest().authenticated() // All other requests require authentication .and() .addFilterBefore(new JwtRequestFilter(), UsernamePasswordAuthenticationFilter.class); // Add JWT filter } }
4. AuthRequest/PayloderBeanClass package a143mk.JWTAPIConfig; public class AuthRequest { private String username; private String password; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } }
Create a Controller class create a simple controller name is AuthController an endpoint is accessed.
package a143mk.JWTAPIController; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.directwebremoting.export.Data; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RestController; import a143mk.JWTAPIConfig.AuthRequest; import a143mk.JWTAPIConfig.JwtUtil; import a143mk.service.InterTransferOutWardService; @RestController public class AuthController { private static final Logger logger = LogManager.getLogger(AuthController.class); private JwtUtil jwtUtil = new JwtUtil(); @Autowired InterTransferOutWardService interOutward; @PostMapping("/api/authenticate") public String createToken(@RequestBody AuthRequest authRequest) { String token=jwtUtil.generateToken(authRequest.getUsername()); logger.info("DATE_Time:"+new Data()+" Token Ganrate: "+token ); interOutward.tokenSave(token); return jwtUtil.generateToken(authRequest.getUsername()); } }
Steps to Test JWT Token in Postman:
Obtain the JWT Token: First, you need to obtain the JWT token from your authentication endpoint. Typically, this is done by making a POST request to your login endpoint with the correct user credentials (username, password, etc.). 

Result :

LDAP
(Lightweight Directory Access Protocol) authentication in a Spring Boot application typically involves using Spring Security to configure LDAP authentication properly, ensuring that sensitive data like passwords is protected and communication with the LDAP server is secure.
Here’s a basic guide to securing LDAP authentication in a Spring Boot application:
Add Dependencies:In your pom.xml, add the following dependencies for Spring Security and LDAP:
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-ldap</artifactId> </dependency> </dependencies>
LDAP Configuration: In your application.properties or application.yml, configure the LDAP server details:

Spring Security Configuration :You can configure Spring Security to authenticate using LDAP by defining a SecurityConfig class.
Here is an example: 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.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.ldap.authentication.LdapAuthenticationProvider; import org.springframework.security.ldap.authentication.LdapAuthoritiesPopulator; import org.springframework.security.ldap.authentication.LdapAuthenticationProviderConfigurer; import org.springframework.security.ldap.core.LdapTemplate; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Override protected void configure(HttpSecurity http) throws Exception { http .authorizeRequests() .antMatchers("/login", "/error").permitAll() // Allowing login and error pages .anyRequest().authenticated() // Other requests require authentication .and() .formLogin() // Enable form login .loginPage("/login") .permitAll() .and() .logout().permitAll(); // Allow logout } @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { // LDAP Authentication configuration auth .ldapAuthentication() .userDnPatterns("uid={0},ou=users") .groupSearchBase("ou=groups") .contextSource() .url("ldap://localhost:389/dc=example,dc=com") .managerDn("cn=admin,dc=example,dc=com") .managerPassword("adminpassword") .and() .passwordCompare() .passwordEncoder(new org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder()) .passwordAttribute("userPassword"); } }
Enable Secure LDAP Connections:
If you are using LDAP over TLS/SSL (LDAPS), it’s critical to ensure that your LDAP communication is secured. Change the URL to:
spring.ldap.urls=ldaps://localhost:636
Ensure that your LDAP server supports LDAPS and that proper certificates are installed on the server. If you are using SSL, you can also import the certificate into your Java Keystore (JKS).
Secure Password Handling:In the above configuration, passwords are compared using passwordCompare(). It's recommended to use a hashed password encoder like BCryptPasswordEncoder, which is configured in the example to secure the passwords.
Customizing the Login Page:You can customize your login page if needed by creating a controller for the login and error handling views:
@Controller public class LoginController { @RequestMapping("/login") public String loginPage() { return "login"; } @RequestMapping("/error") public String errorPage() { return "error"; } }

Role Mapping (Optional):If you want to map roles from LDAP groups or other attributes, you can use LdapAuthoritiesPopulator to fetch roles.

For example: @Bean public LdapAuthoritiesPopulator authoritiesPopulator(LdapTemplate ldapTemplate) { return new DefaultLdapAuthoritiesPopulator(ldapTemplate, "ou=groups"); }
This will ensure the roles are properly populated from LDAP.
Test the Application:Start your Spring Boot application, and it should authenticate users against the LDAP server. Make sure you test with the proper credentials to confirm everything is working securely.

Summary of Key Points:

1.  LDAP Configuration: Use spring.ldap properties to configure the LDAP server details. 
2.  Spring Security: Configure Spring Security to handle LDAP authentication with ldapAuthentication(). 
3.  SSL/TLS: Ensure the LDAP communication is encrypted (use ldaps://). 
4.  Password Encoding: Use a secure password encoder like BCryptPasswordEncoder. 
5.  Role Mapping: Map roles from LDAP as needed using LdapAuthoritiesPopulator. This setup will help you integrate LDAP securely in your Spring Boot application.