How to Get Secure Token using RS256 Algorithm in Java Springboot?

Introduction: In today’s blog post, we will explore a Java method for generating secure JSON Web Tokens (JWTs) using the RS256 algorithm. JWTs are commonly used for authentication and authorization in web applications. The RS256 algorithm employs asymmetric cryptography, utilizing a private key to sign the token and a public key to verify its authenticity.

Problem Statement: We need a reliable and secure method to generate RS256-signed JWTs for our application, ensuring the tokens are properly formatted with the required claims and signatures.

Solution Overview: The provided Java code is a method named generateRS256SignedToken, which takes three parameters – audience, issuer, and subscriber – and returns a signed JWT as a String.

public static String generateRS256SignedToken(String audience, String issuer, String subscriber) {
    // Initialize an empty string to store the signed token
    String signedToken = "";

    try {
        // Parse the private key in PEM format into a JSON Web Key (JWK) object
        JWK jwk = JWK.parseFromPEMEncodedObjects(PRIVATE_KEY);

        // Initialize a signer with the RS256 algorithm using the RSA private key from the JWK
        JWSSigner signer = new RSASSASigner(jwk.toRSAKey().toRSAPrivateKey());

        // Get the current time and set expiration time to 100 minutes later
        long currentTimeMillis = System.currentTimeMillis();
        Date now = new Date(currentTimeMillis);
        Date expirationTime = new Date(currentTimeMillis + 6000 * 100);

        // Build JWT claims including audience, issuer, subject, and optional claims
        JWTClaimsSet claimsSet = new JWTClaimsSet.Builder()
                .audience(audience)
                .issuer(issuer)
                .subject(subscriber)
                .jwtID(UUID.randomUUID().toString()) // This is optional
                .issueTime(now)
                .expirationTime(expirationTime)
                .build();

        // Create a new SignedJWT with RS256 algorithm and sign it using the initialized signer
        SignedJWT signedJWT = new SignedJWT(new JWSHeader(JWSAlgorithm.RS256), claimsSet);
        signedJWT.sign(signer);

        // Serialize the signed JWT into a string
        signedToken = signedJWT.serialize();

    } catch (Exception e) {
        // Handle exceptions by throwing a custom exception or logging the error
        // CustomException should be thrown to indicate a failure in the token generation process
        // throw new CustomException("Error generating RS256 signed token", e);
    }

    // Return the signed token (may be an empty string if an exception occurred)
    return signedToken;
}

Make sure to add this dependency.

        <dependency>
            <groupId>com.nimbusds</groupId>
            <artifactId>nimbus-jose-jwt</artifactId>
            <version>9.18</version>
        </dependency>

Conclusion: This Java code provides a robust solution for generating RS256-signed JWTs, ensuring secure authentication and authorization in web applications. The method allows customization of audience, issuer, and subscriber, along with optional claims. It’s crucial to handle exceptions appropriately to maintain the reliability and security of the token generation process.