Anh Trần Tuấn

Posted on Dec 23 • Originally published at tuanh.net on Dec 22

Understanding JWE: Structure, Operations, Advantages, Disadvantages, and How to Create One

#codeproject #java #securityjwt

1. What is JWE (JSON Web Encryption)?

JSON Web Encryption (JWE) is a standard defined by RFC 7516 that represents encrypted content using JSON-based data structures. It allows you to encrypt arbitrary payloads to ensure confidentiality and, if needed, integrity. This encrypted content can include any kind of data, such as sensitive user information, security tokens, or even files.

1.1 Why Use JWE?

JWE is widely used in web applications and APIs to securely transmit sensitive data such as tokens, user information, and financial details. It ensures that the information cannot be read by unauthorized entities, even if intercepted. The encrypted payload can only be decrypted and used by the intended recipient who possesses the correct decryption key.

1.2 Key Features of JWE

Confidentiality : The primary goal of JWE is to ensure the confidentiality of the content.
Integrity : It guarantees that the data has not been tampered with during transit.
Interoperability : JWE is compatible with different cryptographic algorithms and environments.
Compactness : JWE provides a compact representation that is easy to transport over HTTP.

2. Structure of JWE

JSON Web Encryption (JWE) is a standard for securely transmitting information between parties as a JSON object. JWE uses encryption to ensure the confidentiality and integrity of the data it protects. A typical JWE structure consists of five parts that are concatenated together and separated by periods (.). The five parts are:

Header (JOSE Header)
Encrypted Key
Initialization Vector
Ciphertext
Authentication Tag

Each part of a JWE plays a specific role in the encryption and decryption process. Let's delve into each part in detail.

2.1 JOSE Header (JSON Object Signing and Encryption Header)

The JOSE (JSON Object Signing and Encryption) Header is the first part of the JWE and contains metadata about the encryption process. It is a base64url-encoded JSON object that includes:

alg (Algorithm): Specifies the algorithm used to encrypt the Content Encryption Key (CEK). Common algorithms include RSA-OAEP , RSA1_5 , A128KW , A256KW , etc.
enc (Encryption Algorithm): Indicates the encryption algorithm used to encrypt the payload (plaintext). Examples include A128GCM , A256GCM , A128CBC-HS256 , etc.
typ (Type): Optionally indicates the type of the token, typically JWT.
cty (Content Type): Optionally indicates the content type of the encrypted payload if it is something other than the default application/json.

Example:

{
  "alg": "RSA-OAEP",
  "enc": "A256GCM"
}

This header specifies that the content encryption key is encrypted using the RSA-OAEP algorithm and the payload is encrypted using AES GCM with a 256-bit key.

2.2 Encrypted Key

The second part of a JWE is the Encrypted Key, which is the key used to encrypt the actual data (payload). This key is encrypted using the algorithm specified in the alg parameter of the JOSE Header.

If the alg is RSA-OAEP , the Content Encryption Key (CEK) is encrypted using the RSA-OAEP algorithm with the recipient’s public key.
If the alg is A128KW or A256KW , a symmetric key wrap is used.

The Encrypted Key is base64url-encoded.

2.3 Initialization Vector (IV)

The Initialization Vector (IV) is the third component in the JWE structure. It is a base64url-encoded, random value that is used along with the encryption algorithm to ensure that the same plaintext will encrypt differently each time. The IV prevents patterns in the encrypted data, enhancing security.

For AES GCM mode, the IV is typically 96 bits (12 bytes) long.

2.4 Ciphertext

The Ciphertext is the result of encrypting the plaintext (the payload data) with the content encryption key (CEK) and the encryption algorithm (enc parameter). The Ciphertext is base64url-encoded and is the core part of the JWE, as it holds the protected content.

The encryption process involves padding, encryption, and converting the encrypted output to base64url format.
If additional authenticated data (AAD) is included, it is used to ensure the authenticity and integrity of both the JOSE Header and the Ciphertext.

2.5 Authentication Tag

The Authentication Tag (also known as the Tag ) is a base64url-encoded value that provides integrity and authenticity to the Ciphertext, Initialization Vector (IV), and Additional Authenticated Data (AAD). It is generated during the encryption process using algorithms like AES GCM.

If any part of the JWE structure is altered after encryption, the decryption process will fail because the Authentication Tag will not match.

3. Example of a JWE

Consider a scenario where we want to encrypt a message "Hello, World!" using JWE. Here is a simplified breakdown:

Protected Header : {"alg":"RSA-OAEP","enc":"A256GCM"}
Encrypted Key : Base64Url(encrypt(symmetric key with recipient's public key))
Initialization Vector (IV): Base64Url(randomly generated IV)
Ciphertext : Base64Url(encrypt("Hello, World!" with the symmetric key))
Authentication Tag : Base64Url(GCM Tag)

The final JWE might look something like this:

eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ.
g_hE3pPLiSs9C60_WFQ-VP_mQ1BU00Z7Xg.
48V1_ALb6US04U3b.
5eym8mytxoXCBlYkhjBtkmmI.
XFBoMYUZodetZdvTiFvSkQ

4. How Does JWE Work?

JWE works by using a combination of public-key cryptography (for encrypting the symmetric key) and symmetric encryption (for encrypting the actual payload). Here’s how the process works:

Key Generation and Management

The sender and receiver agree on a public-key cryptography standard (e.g., RSA or Elliptic Curve).
The sender generates a random symmetric key to encrypt the message.
The symmetric key is then encrypted using the receiver's public key.

Encryption Process

The sender creates the JWE Header that specifies the encryption algorithms.
The payload (data) is encrypted using the symmetric key and an Initialization Vector (IV).
The symmetric key is encrypted using the recipient’s public key.
The resulting components are concatenated to form the final JWE.

Decryption Process

The recipient uses their private key to decrypt the encrypted symmetric key.
The decrypted symmetric key is then used to decrypt the ciphertext.
The recipient verifies the integrity of the data using the authentication tag.

5. Advantages and Disadvantages of JWE

5.1 Advantages

Confidentiality : Provides end-to-end encryption, ensuring data privacy.
Interoperability : Compatible across different systems and platforms.
Integrity and Security : Ensures data is protected from tampering.
Supports Multiple Recipients : Allows for encrypting data to multiple recipients using different keys.

5.2 Disadvantages

Complexity : The process of encryption and decryption can be complex and error-prone.
Performance Overhead : The encryption/decryption process adds computational overhead.
Larger Payload Size : JWE payloads are larger compared to plain data or JWT due to the encryption metadata.

6. How to Create a JWE in Java

Creating a JWE involves choosing libraries that support JWE standards. One of the most popular libraries in Java is Nimbus JOSE + JWT. Below is a simple example demonstrating how to create a JWE:

Setting Up Dependencies

Add the following dependency to your pom.xml if you are using Maven:

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

Creating and Encrypting a JWE

Here’s a Java code snippet that demonstrates the creation of a JWE:

import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.*;
import com.nimbusds.jose.jwk.*;
import com.nimbusds.jose.jwk.gen.*;
import com.nimbusds.jwt.*;

public class JWEExample {
    public static void main(String[] args) throws Exception {
        // Generate an RSA key pair
        RSAKey rsaJWK = new RSAKeyGenerator(2048).keyID("123").generate();
        RSAKey rsaPublicJWK = rsaJWK.toPublicJWK();

        // Create the JWE header
        JWEHeader header = new JWEHeader(JWEAlgorithm.RSA_OAEP_256, EncryptionMethod.A256GCM);

        // Set the payload
        Payload payload = new Payload("Hello, World!");

        // Create the JWE object
        JWEObject jweObject = new JWEObject(header, payload);

        // Encrypt the JWE with the recipient's RSA public key
        jweObject.encrypt(new RSAEncrypter(rsaPublicJWK));

        // Output JWE string
        String jweString = jweObject.serialize();
        System.out.println("Encrypted JWE: " + jweString);

        // Decrypt the JWE with the recipient's RSA private key
        jweObject = JWEObject.parse(jweString);
        jweObject.decrypt(new RSADecrypter(rsaJWK));

        // Output the decrypted payload
        System.out.println("Decrypted Payload: " + jweObject.getPayload().toString());
    }
}

Explanation of the Code

Key Generation : An RSA key pair is generated to encrypt and decrypt the JWE.
Header and Payload : The header specifies the encryption algorithms, and the payload contains the data to be encrypted.
Encryption : The RSAEncrypter is used to encrypt the payload.
Decryption : The RSADecrypter decrypts the payload back to its original form.

Result

Running the above code will generate an encrypted JWE string and then decrypt it back to the original message:

Decrypted Payload: Hello, World!

7. Conclusion

JSON Web Encryption (JWE) is an essential tool for secure data transmission in modern web applications. Understanding its structure, how it works, and its pros and cons will help you make informed decisions on when and how to use it in your applications. If you have any questions or need further clarification, feel free to leave a comment below!

Read posts more at : Understanding JWE: Structure, Operations, Advantages, Disadvantages, and How to Create One

DEV Community