JWT vs JWE: Understanding JSON Web Encryption

The Fundamental Difference

While JWT (JSON Web Tokens) and JWE (JSON Web Encryption) are both part of the JOSE (JSON Object Signing and Encryption) framework, they serve different security purposes:

JWT (JSON Web Tokens)

JWE (JSON Web Encryption)

JWT Structure & Security

Standard JWT Format

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Three parts separated by dots:

JWT Security Properties

• Integrity: Signature prevents tampering
• Authenticity: Signature verifies the issuer
• No Confidentiality: Payload is Base64-encoded (not encrypted)

// Anyone can decode the payload
const payload = JSON.parse(atob('eyJzdWIiOiIxMjM0...'));
console.log(payload.name); // "John Doe" - visible to anyone!

JWE Structure & Security

JWE Format

eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ.
OKOawDo13gRp2ojaHV7LFpZcgV7T6DVZKTyKOMTYUmKoTCVJRgckCL9kiMT03JGe...
48V1_ALb6US04U3b.
5eym8TW_c8SuK0ltJ3rpYIzOeDQz7TALvtu6UG9oMo4vpzs9tX_EFShS8iB7j6ji...
XFBoag

Five parts separated by dots:

JWE Security Properties

• Confidentiality: Payload is encrypted and unreadable
• Integrity: Authentication tag prevents tampering
• Authenticity: Verifies the encryptor

When to Use JWT vs JWE

Use JWT When:

• Identity tokens: User authentication and basic claims
• Public information: User roles, permissions, non-sensitive data
• Performance priority: Lower overhead than encryption
• Stateless authentication: Microservices, APIs
• Client-side processing: JavaScript can read claims without server calls

Use JWE When:

• Sensitive data: Personal information, financial data
• Compliance requirements: GDPR, HIPAA, PCI-DSS
• Zero-trust networks: Data transits untrusted infrastructure
• Temporary credentials: API keys, temporary passwords
• Cross-domain data sharing: Encrypted data exchange

Implementation Examples

Creating a JWT

const jwt = require('jsonwebtoken');

// Create a standard JWT
const token = jwt.sign(
  {
    sub: '1234567890',
    name: 'John Doe',
    role: 'admin',
    exp: Math.floor(Date.now() / 1000) + (60 * 60) // 1 hour
  },
  'your-secret-key',
  { algorithm: 'HS256' }
);

// Token payload is readable by anyone
console.log(jwt.decode(token)); // Shows payload without verification

Creating a JWE

const jose = require('jose');

async function createJWE() {
  const secret = new TextEncoder().encode('your-256-bit-secret');

  const jwt = await new jose.EncryptJWT({
    sub: '1234567890',
    sensitive_data: 'confidential information',
    ssn: '123-45-6789'
  })
    .setProtectedHeader({ alg: 'dir', enc: 'A256GCM' })
    .setIssuedAt()
    .setExpirationTime('1h')
    .encrypt(secret);

  return jwt; // Encrypted - payload not readable
}

// Decryption requires the secret
async function decryptJWE(token, secret) {
  const { payload } = await jose.jwtDecrypt(token, secret);
  return payload;
}

Hybrid Approach: Nested JWT

You can combine both by creating a JWT and then encrypting it with JWE:

async function createNestedToken() {
  // Step 1: Create a signed JWT
  const innerJWT = jwt.sign(
    { sub: '123', role: 'admin', sensitive: 'data' },
    'signing-secret',
    { algorithm: 'HS256' }
  );

  // Step 2: Encrypt the JWT with JWE
  const encryptedJWT = await new jose.EncryptJWT({ jwt: innerJWT })
    .setProtectedHeader({ alg: 'dir', enc: 'A256GCM' })
    .encrypt(encryptionSecret);

  return encryptedJWT; // Both signed AND encrypted
}

Algorithm Choices

JWT Signing Algorithms

JWE Encryption Algorithms

Key Management:

Content Encryption:

Performance Considerations

Computational Overhead

Size Comparison

Security Best Practices

JWT Security

• Use strong signing keys (256+ bits for HMAC)
• Always validate signatures before trusting payload
• Set appropriate expiration times
• Never store sensitive data in JWT payloads
• Validate all standard claims (exp, iss, aud)

JWE Security

• Use authenticated encryption modes (GCM, CCM)
• Generate unique initialization vectors for each encryption
• Protect encryption keys with the same rigor as signing keys
• Consider key rotation for long-term deployments
• Validate authentication tags before processing plaintext

Common Pitfalls

Decision Framework

Quick Decision Tree

Does your payload contain sensitive data?

• ✅ Yes → Use JWE
• ❌ No → Continue...

Do you need client-side access to claims?

• ✅ Yes → Use JWT
• ❌ No → Continue...

Is maximum performance critical?

• ✅ Yes → Use JWT
• ❌ No → Consider JWE for defense in depth

Hybrid Scenarios

• Public claims in JWT + sensitive data in JWE: Separate tokens for different purposes
• JWT in JWE: Sign first, encrypt second for both integrity and confidentiality
• Different algorithms per environment: JWE in production, JWT in development