jwt in springboot

In the realm of web security, JSON Web Tokens (JWT) have become a cornerstone for securing RESTful APIs. This article delves into the theoretical foundation of JWTs, their integration within Spring Boot applications, and offers code snippets with thorough explanations to empower your security implementations.

Introduction to JWT

JSON Web Tokens (JWTs) are a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is used as the payload of a JSON Web Signature (JWS) structure or as the plaintext of a JSON Web Encryption (JWE) structure, enabling the claims to be digitally signed or integrity-protected with a Message Authentication Code (MAC) and/or encrypted.

JWT Structure:

A JWT typically consists of three parts: Header, Payload, and Signature.

Header: The header typically consists of two parts: the type of the token, which is JWT, and the signing algorithm being used, such as HMAC SHA256 or RSA.
Payload: The payload contains the claims. Claims are statements about an entity (typically, the user) and additional data. There are three types of claims: registered, public, and private claims.
Signature: To create the signature part you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that.

What is Stateful and Stateless ?

Stateful :

In stateful applications, cookies are commonly used to maintain session state across multiple requests from the same client.

When a client first accesses a stateful application, the server generates a unique session identifier (session ID) for that client. This session ID is then sent back to the client and stored in a cookie.

With each subsequent request to the server, the client automatically sends the cookie containing the session ID. The server reads this cookie to retrieve the session ID, allowing it to access the stored session data corresponding to that client.

This mechanism enables the server to remember information about the client's previous interactions, providing a continuous and personalized user experience across multiple requests. Cookies are essential for identifying individual clients in stateful applications, facilitating features like user logins, shopping carts, and personalized content.

Stateless :

In stateless architectures, tokens, often in the form of JWTs (JSON Web Tokens), are used to manage user sessions and authentication. Unlike traditional session-based authentication, where session information is stored on the server, stateless authentication relies on clients sending a token with each request, which contains all the necessary information to authenticate the request.

This token is typically generated by the server after a successful login and then sent to the client, which will store it and include it in the header of subsequent requests. The server, upon receiving a request with a token, validates the token's integrity and authenticity, typically by verifying a digital signature and checking the token's expiration.

This approach enables the server to authenticate requests without needing to maintain session state, making it ideal for scalable, distributed applications where maintaining session state across multiple servers can be challenging.

Setting Up Spring Boot for JWT Authentication

Dependency Management

Provide the Maven or Gradle dependencies needed for JWT implementation in Spring Boot.

<!-- Example Maven dependency -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

Generating a JWT Token

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public String generateToken(String username) {
    long now = System.currentTimeMillis();
    return Jwts.builder()
            .setSubject(username)
            .setIssuedAt(new Date(now))
            .setExpiration(new Date(now + 900000)) // 15 minutes expiration time
            .signWith(SignatureAlgorithm.HS512, "SecretKeyToGenJWTs")
            .compact();
}

This code defines a method named generateToken that takes a username as input and generates a JSON Web Token (JWT) for that user.

It uses the Jwts builder to create the token, setting the subject to the provided username, issuing time to the current time, and expiration time to 15 minutes from the current time.

The token is signed with the HMAC SHA-512 algorithm using a predefined secret key, "SecretKeyToGenJWTs".

Finally, the method returns the compact, URL-safe string representation of the JWT.

Parsing and Validating a JWT Token

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureException;

public Claims parseToken(String token) {
    try {
        return Jwts.parser()
                .setSigningKey("SecretKeyToGenJWTs")
                .parseClaimsJws(token)
                .getBody();
    } catch (SignatureException ex) {
        throw new RuntimeException("Invalid JWT signature");
    }
}

This code snippet defines a method named parseToken that takes a JWT token as a parameter and attempts to parse it to extract its claims (payload).

It uses the Jwts.parser() method, setting the signing key to "SecretKeyToGenJWTs", which must match the key used to sign the token initially.

If the token is valid and the signature matches, it returns the claims. If the signature does not match, indicating the token may have been tampered with or is invalid, it throws a RuntimeException with the message "Invalid JWT signature".

Advantages of JWT:

Compactness: JWTs are compact, making them easily transmissible through URLs, POST request bodies, or HTTP headers.
Statelessness: JWTs are self-contained, carrying all necessary information within themselves. This stateless nature allows for scalability as servers don't need to maintain session state.
Security: JWTs can be digitally signed, ensuring that the tokens are authentic and have not been tampered with.
Cross-Domain Authentication: The compactness and self-contained nature of JWTs facilitate easy implementation of cross-domain authentication schemes.
Performance: Using JWT for authentication reduces the need to query the database for user verification on every request, leading to improved performance.
Ease of Use: A wide range of libraries available across various programming languages makes it easy to implement JWT authentication.

Conclusion:

JSON Web Tokens (JWT) offer a compact and self-contained way for securely transmitting information between parties as a JSON object. They are widely used in web applications to manage user sessions and authenticate API requests.

JWTs facilitate secure data exchange with their ability to be signed and encrypted. The simplicity of their implementation, coupled with their versatility in terms of usage across different types of applications, makes them a popular choice for modern web security solutions. However, it's crucial to implement JWTs correctly, by ensuring tokens are securely stored, properly validated, and efficiently managed, to mitigate potential security risks.

Venkata Thanooj's Blog