andrea-chiarelli

I have over 20 years of experience as a software engineer and technical author. Throughout my career, I've used several programming languages and technologies for the projects I was involved in, ranging from C# to JavaScript, ASP.NET to Node.js, Angular to React, SOAP to REST APIs, etc.

In the last few years, I've been focusing on simplifying the developer experience with Identity and related topics, especially in the .NET ecosystem.

Principal Developer Advocate

Andrea Chiarelli

Break down the differences and relationships between JOSE, JWT, JWS, JWE, JWA, and JWK with clear explanations and examples.

If you've worked with modern authentication or secure data exchange, you've undoubtedly encountered JSON Web Tokens, or JWTs. However, if you dig deeper, you may encounter a series of confusing acronyms: JWS, JWE, JWK, JWA, and the umbrella term, JOSE. What do they all mean? How do they relate to each other?

It's easy to get lost, but these concepts are actually designed to work together in a logical system. Think of it like **a secure shipping company**. You have the package, the tamper-proof seal, the locked box, the keys, and the set of rules for how to handle everything. This article will unpack each of these components, trying to clarify their roles and how they come together to create the secure tokens we rely on.

## What Is JOSE (JSON Object Signing and Encryption)?

Let's start with the big picture: **JOSE**.

JOSE isn't a single technology you can install or a specific format. Instead, it's a **framework** or [a collection of IETF (Internet Engineering Task Force) standards](https://datatracker.ietf.org/wg/jose/documents/). Its purpose is to provide a standardized way to securely transfer [claims](https://auth0.com/docs/secure/tokens/json-web-tokens/json-web-token-claims) between parties.

Think of **JOSE as the entire shipping and logistics company**. It doesn't represent a single box or key, but rather the complete set of rules, tools, and specifications for shipping things securely. It defines how to create signed messages (JWS), encrypted messages (JWE), the keys to use (JWK), and the algorithms allowed (JWA).

The JOSE framework is composed of several key specifications, which we will explore next.

## JWS (JSON Web Signature)

[JWS](https://datatracker.ietf.org/doc/html/rfc7515) is a standard for signing data. Its primary goals are to ensure **integrity** and **authenticity**:

* **Integrity:** Guarantees that the data has not been tampered with in transit.  
* **Authenticity:** Verifies that the sender is who they claim to be.

A JWS object doesn't hide the data; it just adds a signature that the recipient can verify. It's like putting a letter in a clear envelope and sealing it with a unique, tamper-proof wax seal. Anyone can read the letter, but the seal proves it came from the right person and hasn't been opened.

A JWS object, or more simply a JWS, can be represented in a compact, URL-safe string composed of three parts, separated by dots (`.`):

![Diagram showing the three-part structure of a JWS (JSON Web Signature): a Base64Url encoded Header, Payload, and Signature, each separated by a dot.](https://images.ctfassets.net/23aumh6u8s0i/4mDvsqLEA5NtlrbD6hVap5/c6b0a8f7d4eb8ecd53188f9fa0969adb/jws-parts.png)  This representation is called [JWS Compact Serialization](https://datatracker.ietf.org/doc/html/rfc7515#section-7.1).

> A JWS can also be represented as a JSON object in two different flavors:  [General JWS JSON Serialization](https://datatracker.ietf.org/doc/html/rfc7515#section-7.2.1) and [Flattened JWS JSON Serialization](https://datatracker.ietf.org/doc/html/rfc7515#section-7.2.2). 

Here is an example of a JWS object represented through JWS Compact Serialization:

```shell
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
```

Decoding each of these parts, you’ll get the following:

* **Header:** Metadata about the signature, such as the signing algorithm used:

```json
{
  "alg": "HS256",
  "typ": "JWT"
}
```

* **Payload:** The actual data being secured (the claims):

```json
{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}
```

* **Signature:** Created by signing the encoded header and payload with a secret key.

## JWE (JSON Web Encryption)

[JWE](https://datatracker.ietf.org/doc/html/rfc7516) is a standard for encrypting data. Its primary goal is **confidentiality**.

Unlike JWS, which leaves the data readable, JWE makes it unreadable to anyone without the correct keys. This is like putting your letter inside a locked metal box before shipping it. Only the person with the key can open it and see the contents.

A JWE object, or more simply a JWE, can also be represented in a compact string, but it has five parts separated by dots (`.`):

![Diagram illustrating the five-part structure of a JWE (JSON Web Encryption): JOSE Header, Encrypted Key, Initialization Vector, Ciphertext, and Authentication Tag.](https://images.ctfassets.net/23aumh6u8s0i/5iLpAkZozPYVkbQkxYFPfD/1e839dd26ce2637c2e52c9657b88efd5/jwe-parts.png)  This is the [JWE Compact Serialization](https://datatracker.ietf.org/doc/html/rfc7516#section-3.1) representation. 

> As for a JWS, a JWE can also be represented as a JSON object in two different flavors:  [General JWE JSON Serialization](https://datatracker.ietf.org/doc/html/rfc7516#section-7.2.1) and [Flattened JWE JSON Serialization](https://datatracker.ietf.org/doc/html/rfc7516#section-7.2.2). 

Here is an example of the JWE Compact Serialization representation:

```shell
eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ.OKOawDo13gRp2v6GZfDqztYe70eG6o0f6ZlH5_yl1TjSGhbyT2KVdD2iM0ik2aO_hJAFy8uMwk2nN25OJaSqa1L58U9b2JTJmYnE9LzE6W1-nZz1tQ1tY4C8z4p2v6G.AxY8DCtDaGlsbGljb3RoZQ.KDlT9LgK3-tV3hVucpYh_g.GawgguFyGrWKav7AX4VKUg
```

Breaking it down, you will find the following parts:

* **JOSE Header:** Contains metadata about the encryption algorithms.  
* **JWE Encrypted Key:** The key used to encrypt the content, which itself is encrypted with the recipient's public key.  
* **JWE Initialization Vector:** A random value to ensure the encryption is unique. If an algorithm does not utilize an Initialization Vector, this value will be an empty octet sequence..  
* **JWE Ciphertext:** The encrypted payload.  
* **JWE Authentication Tag:** A value used to verify the integrity of the encrypted data. In case an algorithm does not use an Authentication Tag, this value will be an empty octet sequence.

## JWA and JWK

Now, both JWS and JWE use algorithms and keys to sign and encrypt data. How do they know *which* algorithms and *which* keys to use? That's where JWA and JWK come in. They represent the tools for sealing, locking, and unlocking in our metaphorical shipping company.

### JWA (JSON Web Algorithms)

[JWA](https://datatracker.ietf.org/doc/html/rfc7518) is simply a specification that defines the cryptographic algorithms that can be used for signing and encryption within the JOSE framework. It doesn't contain any code; it's a registry of identifiers.

For example, when the JWS header contains `"alg": "HS256"`, it's referring to the [HMAC](https://en.wikipedia.org/wiki/HMAC) algorithm using SHA-256 algorithm. Other examples include `"RS256"` for RSA signatures or `"A256GCM"` for [AES-GCM](https://en.wikipedia.org/wiki/Galois/Counter_Mode) encryption.

### JWK (JSON Web Key)

[JWK](https://datatracker.ietf.org/doc/html/rfc7517) is a standard for representing cryptographic keys in a JSON format. Instead of passing around key files in different formats (like [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) or [DER](https://en.wikipedia.org/wiki/X.690#DER_encoding)), you can represent them as a JSON object. This is especially useful for web-based applications where JSON is the native language.

A JWK contains metadata about the key, such as its type, usage (signing or encryption), and the key values themselves.

Here is an example of an RSA Public JWK:

```json
{
  "kty": "RSA",
  "use": "sig",
  "kid": "my-rsa-key-1",
  "n": "u4V_...",
  "e": "AQAB"
}
```

*   
  `kty` (Key Type): Identifies the crypto family (e.g., "RSA", "EC").  
* `use` (Public Key Use): Defines the intended use (e.g., "sig" for signature, "enc" for encryption).  
* `kid` (Key ID): A unique identifier for the key, useful when an application has multiple keys.  
* `n` and `e`: The modulus and exponent values for the RSA public key.

### JWKS (JWK SET)

You may have heard about [JWKS](https://datatracker.ietf.org/doc/html/rfc7517#section-5). This is a standard specification to represent a set of JWK objects. The following is an example of JWKS object containing two JWK objects:

```json
{
  "keys": [
    {
      "kty": "RSA",
      "use": "sig",
      "n": "sySYvu...",
      "e": "AQAB",
      "kid": "MDc...",
    },
    {
      "kty": "RSA",
      "use": "sig",
      "n": "rxFxz...",
      "e": "AQAB",
      "kid": "_dqx...",
      "x5t": "IwL...",
      "x5c": [
        "MIIDAz..."
      ],
      "alg": "RS256"
    }
  ]
}
```

The JWKS object must have a `keys` member, which is an array of JWKs.

> Auth0 provides a JWKS endpoint for each tenant at `https://<YOUR-DOMAIN>/.well-known/jwks.json`. This endpoint returns the JWK objects associated with that specific tenant. Applications use this endpoint to dynamically fetch the public keys needed to verify JWTs issued by your Auth0 tenant.

## What About JWT?

Finally, we arrive at the most well-known acronym: [JWT (JSON Web Token)](https://datatracker.ietf.org/doc/html/rfc7519).

A JWT is **not** a new technology separate from the others. A JWT is a specific **type of payload** or a set of claims that is transported *using* JWS or JWE. It's the "what" that goes inside the secure container.

Referring once again to the metaphor of the shipping company, if JWS is the sealed envelope, the **JWT is the letter inside it**. The JWT standard defines a compact, self-contained way for representing information between two parties. It specifies a set of standard claim names like `iss` (issuer), `exp` (expiration time), `sub` (subject), and `aud` (audience).

Here is an example of a JWT Payload (Claims Set):

```json
{
  "iss": "https://my-auth-server.com",
  "sub": "user-123",
  "aud": "my-api",
  "exp": 1664532000,
  "name": "Jane Doe",
  "isAdmin": true
}
```

## Why Is a JWT Often Called a JWS or JWE?

This is the most common point of confusion. People often use "JWT" and "JWS" interchangeably. Is that correct?

Mostly, yes. A JWT is just the set of claims. To be useful, it must be securely transmitted. The way you make it secure is by signing it (creating a JWS) or encrypting it (creating a JWE).

* When you **sign** a JWT payload, the resulting token is technically a **JWS**. This is the most common form of JWT.  
* When you **encrypt** a JWT payload, the resulting token is technically a **JWE**.  
* It's also possible to have a **nested JWT**, where a JWT payload is signed (JWS) and then the entire JWS is encrypted (JWE).

So, when someone says "here is my JWT," they are almost always handing you a **JWS whose payload is a set of JWT claims**. The term "JWT" has become a colloquial shortcut for "a JWS containing JWT claims."

> You learned earlier that JWS and JWE objects can be represented as JSON objects. However, these representations can’t be used for JWTs. As [the specifications say](https://datatracker.ietf.org/doc/html/rfc7519#section-1), a JWT is always represented through JWS or JWE Compact Serialization.

## Recap

Although the JOSE acronyms may seem intimidating, the underlying concepts are actually distinct and logical once understood correctly. So, to summarize:

* **JOSE** is the overarching framework.  
* **JWS** and **JWE** are the secure containers—one is signed, the other is encrypted.  
* **JWA** and **JWK** are the tools—the algorithms and keys used to secure the containers.  
* **JWT** is the content—the standardized set of claims you put inside the container.

For your convenience, here is a summary table that recaps the differences between the items of the JOSE framework, including the references to the secure shipping company’s metaphor:

![A comparison table summarizing the JOSE framework. It defines JWT, JWS, JWE, JWK, and JWA, explaining the purpose and analogy for each specification.](https://images.ctfassets.net/23aumh6u8s0i/1a5zCuR79251Uk5c4JkTIa/98ab9ad626ded2850e3c5b0bed646746/jose-acronyms-table.png)

Demystifying JOSE, the JWT Family: JWS, JWE, JWA, and JWK Explained

56227bdd539c480cc054eaa72eb1885d?s=200 avatar

56227bdd539c480cc054eaa72eb1885d?s=200

Guest Author

Antonio Sanso

JSON Web Encryption is vulnerable to a classic Invalid Curve Attack. Learn how this may affect you and what to do about it.



---

**TL;DR** If you are using [go-jose](https://github.com/square/go-jose), [node-jose](https://github.com/cisco/node-jose), [jose2go](https://github.com/dvsekhvalnov/jose2go), [Nimbus JOSE+JWT](https://bitbucket.org/connect2id/nimbus-jose-jwt/wiki/Home) or [jose4](https://bitbucket.org/b_c/jose4j/wiki/Home) with [ECDH-ES](https://tools.ietf.org/html/rfc7518) please update to the latest version. [RFC 7516 aka JSON Web Encryption (JWE)](https://tools.ietf.org/html/rfc7516) and software libraries implementing this specification used to suffer from a classic [Invalid Curve Attack](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.107.3920&rep=rep1&type=pdf). This can allow an attacker to recover the secret key of a party using JWE with [Key Agreement with Elliptic Curve Diffie-Hellman Ephemeral Static (ECDH-ES)](https://tools.ietf.org/html/rfc7518), where the sender could extract receiver’s private key.

---

## Premise

In this blog post I assume you are already knowledgeable about elliptic curves and their use in cryptography. If not [Nick Sullivan](https://twitter.com/grittygrease)'s  [A (Relatively Easy To Understand) Primer on Elliptic Curve Cryptography](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/) or Andrea Corbellini's series [Elliptic Curve Cryptography: finite fields and discrete logarithms](https://andrea.corbellini.name/2015/05/23/elliptic-curve-cryptography-finite-fields-and-discrete-logarithms/) are great starting points. Then if you further want to [climb the elliptic learning curve](https://moderncrypto.org/mail-archive/curves/2016/000784.html) including the related attacks you might also want to visit [https://safecurves.cr.yp.to/](https://safecurves.cr.yp.to/). Also the [DJB and Tanja talk at 31c3](https://www.youtube.com/watch?v=y_YxRUTI-xU) comes with an explanation of this very attack (see minute 43) or  [Juraj Somorovsky et al's research](https://web-in-security.blogspot.com/2015/09/practical-invalid-curve-attacks.html) can become handy for learners.

Note that this research was started and inspired by [Quan Nguyen from Google](https://research.google.com/pubs/pub45790.html) and then refined by [Antonio Sanso from Adobe](https://twitter.com/asanso).

## Introduction

JSON Web Token (JWT) is a JSON-based open standard ([RFC 7519](https://tools.ietf.org/html/rfc7519)) defined in the [OAuth specification family](https://tools.ietf.org/wg/oauth/) used for creating access tokens. The [Javascript Object Signing and Encryption (JOSE) IETF expert group](https://tools.ietf.org/wg/jose/) was then formed to formalize a set of signing and encryption methods for JWT that led to the release of  [RFC 7515 aka JSON Web Signature (JWS)](https://tools.ietf.org/html/rfc7515) and [RFC 7516 aka JSON Web Encryption (JWE)](https://tools.ietf.org/html/rfc7516). In this post we are going to focus on JWE.

A typical JWE is dot separated string that contains five parts:

* The JWE Protected Header
* The JWE Encrypted Key
* The JWE Initialization Vector
* The JWE Ciphertext
* The JWE Authentication Tag

An example of a JWE taken from the [specification](https://tools.ietf.org/html/rfc7516) would look like:

```
eyJhbGciOiJSU0EtT0FFUCIsImVuYyI6IkEyNTZHQ00ifQ.OKOawDo13gRp2ojaHV7LFpZcgV7T6DVZKTyKOMTYUmKoTCVJRgckCL9kiMT03JGeipsEdY3mx_etLbbWSrFr05kLzcSr4qKAq7YN7e9jwQRb23nfa6c9d-StnImGyFDbSv04uVuxIp5Zms1gNxKKK2Da14B8S4rzVRltdYwam_lDp5XnZAYpQdb76FdIKLaVmqgfwX7XWRxv2322i-vDxRfqNzo_tETKzpVLzfiwQyeyPGLBIO56YJ7eObdv0je81860ppamavo35UgoRdbYaBcoh9QcfylQr66oc6vFWXRcZ_ZT2LawVCWTIy3brGPi6UklfCpIMfIjf7iGdXKHzg.
48V1_ALb6US04U3b.5eym8TW_c8SuK0ltJ3rpYIzOeDQz7TALvtu6UG9oMo4vpzs9tX_EFShS8iB7j6ji      SdiwkIr3ajwQzaBtQD_A.XFBoMYUZodetZdvTiFvSkQ
```

This JWE employs RSA-OAEP for key encryption and A256GCM for content encryption :

![JWE Token](https://images.ctfassets.net/23aumh6u8s0i/1dyW4IOQJ2ho2Awh683SGM/88808f9284793e4f0d2f553793149e88/header0)

This is only one of the many possibilities JWE provides. A separate specification called [RFC 7518 aka JSON Web Algorithms (JWA)](https://tools.ietf.org/html/rfc7518) lists all the possible available algorithms that can be used. The one we are discussing today is the [Key Agreement with Elliptic Curve Diffie-Hellman Ephemeral Static (ECDH-ES)](https://tools.ietf.org/html/rfc7518).  This algorithm allows deriving an ephemeral shared secret ([this blog post from Neil Madden](https://neilmadden.wordpress.com/2016/05/20/ephemeral-elliptic-curve-diffie-hellman-key-agreement-in-java/) shows a concrete example on how to do ephemeral key agreement).

In this case the *JWE Protected Header* lists as well the used elliptic curve used for  the key agreement:

![JWE Decoded](https://images.ctfassets.net/23aumh6u8s0i/5noTU8YY54mWlpUKyi2Ozq/88c9228b62e82608553b669cde0197b2/header)

Once the shared secret is calculated the key agreement result can be used in one of two ways:

1. Directly as the Content Encryption Key (CEK) for the "enc" algorithm, in the Direct Key Agreement mode, or

2. As a symmetric key used to wrap the CEK with the A128KW, A192KW, or A256KW algorithms, in the Key Agreement with Key Wrapping mode.

This is out of scope for this post but as for the other algorithms the [JOSE Cookbook](https://tools.ietf.org/html/rfc7520) contains example of usage for ECDH-ES in combination with AES-GCM or AES-CBC plus HMAC.

## Observation

As highlighted by Quan during his talk at [RWC 2017](https://www.realworldcrypto.com/rwc2017):

>Decryption/Signature verification input is always under attacker’s control

As we will see thorough this post this simple observation will be enough to recover the receiver’s private key. But first we need to dig a bit into elliptic curve bits and pieces.

## Elliptic Curves

An elliptic curve is the set of solutions defined by an equation of the form:

**y^2 = x^3 + ax + b**

Equations of this type are called *Weierstrass equations*. An elliptic curve would look like:

![Elliptic Curve](https://images.ctfassets.net/23aumh6u8s0i/3JMVwOaOP8hav8C2MS8N74/e52a69e348548f4b51730cfd23defc2b/EC)

**y^2 = x^3 + 4x + 20**

In order to apply the theory of elliptic curves to cryptography we need to look at elliptic curves whose points have coordinates in a finite field Fq. The same curve will then look like below over Finite Field of size 191:

![Field Size](https://images.ctfassets.net/23aumh6u8s0i/2HBFINrYLGCVLAu5XTPzY1/829e76c4db6c3e059cdbcaad63b369ac/ECFP)

**y^2 = x^3 + 4x + 20 over Finite Field of size 191**

For JWE the elliptic curves in scope are the one defined in [Suite B](https://www.nsa.gov/ia/programs/suiteb_cryptography/index.shtml) and ([only recently](https://www.rfc-editor.org/rfc/rfc8037.txt)) [DJB](https://cr.yp.to/djb.html)'s curve.
Between those, the curve that so far has reached the higher amount of usage is the famous P-256.

Time to open [Sage](https://www.sagemath.org/). Let's define P-256:

![P-256](https://images.ctfassets.net/23aumh6u8s0i/1w5nccSNZHZy9uMtZiscOi/1b644b3c53c2740ab5e0364630ebef38/p256)

The order of the curve is a really huge number hence there isn't much an attacker can do with this curve (if the software implements ECDH correctly) in order to guess the private key used in the agreement. This brings us to the next section:

## The Attack

The attack described here is really the classical [Invalid Curve Attack](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.107.3920&rep=rep1&type=pdf). The attack is simple and powerful and takes advantage from the mere fact that Weierstrass's formula for scalar multiplication does not take in consideration the coefficient b of the curve equation:

**y^2 = ax^3 + ax + b**.

The original's P-256 equation is:

![P-256](https://images.ctfassets.net/23aumh6u8s0i/1w5nccSNZHZy9uMtZiscOi/1b644b3c53c2740ab5e0364630ebef38/p256)

As we mention above, the order of this curve is really big. So we need now to find a more convenient curve for the attacker. Easy peasy with Sage:

![Sage](https://images.ctfassets.net/23aumh6u8s0i/7wF06Ez5NZQpbcDNVqTzDL/c86e6f9a18d6954588b623f181859b61/lift)

As you can see from the image above we just found a nicer curve (from the attacker point of view) that has an order with many small factors. Then we found a point P on the curve that has a really small order (2447 in this example).

Now we can build malicious JWEs (see the **Demo Time section** below) and extract the value of the secret key modulo 2447 with complexity in constant time.

A crucial part for the attack to succeed is to have the victim to repeat his own contribution to the resulting shared key. In other words this means that the victim should have his private key to be the same for each key agreement. Conveniently enough this is how the [Key Agreement with Elliptic Curve Diffie-Hellman Ephemeral Static (ECDH-ES)](https://tools.ietf.org/html/rfc7518) works. Indeed ES stands for Ephemeral-Static were Static is the contribution of the victim!

At this stage we can repeat these operations (find a new curve, craft malicious JWEs, recover the secret key modulo the small order) many many times and collecting information about the secret key modulo many many small orders.

And finally [Chinese Remainder Theorem](https://en.wikipedia.org/wiki/Chinese_remainder_theorem) for the win!

At the end of the day the issue here is that the specification and consequently all the libraries I checked missed validating that the received public key (contained in the JWE Protected Header is on the curve), You can see the Vulnerable Libraries section below to check how the various libraries fixed the issue.

Again you can find details of the attack in the [original paper](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.107.3920&rep=rep1&type=pdf).

## Demo Time

**[INSTANT DEMO CLICK HERE](https://afternoon-fortress-81941.herokuapp.com/)**

![Demo](https://images.ctfassets.net/23aumh6u8s0i/5X3r9P3BfAM4MJr0pLjxW6/ad911b7bc91929f77e4919d7a542f1e7/attacker)

### Explanation

In order to show how the attack would work in practice I set up a live demo in Heroku. In [https://obscure-everglades-31759.herokuapp.com/](https://obscure-everglades-31759.herokuapp.com/) is up and running one Node.js server app that will act as a victim in this case. The assumption is this: in order to communicate with this web application you need to encrypt a token using the [Key Agreement with Elliptic Curve Diffie-Hellman Ephemeral Static (ECDH-ES)](https://tools.ietf.org/html/rfc7518). The static public key from the server needed for the key agreement is in [https://obscure-everglades-31759.herokuapp.com/ecdh-es-public.json](https://obscure-everglades-31759.herokuapp.com/ecdh-es-public.json):

![Demo explanation](https://images.ctfassets.net/23aumh6u8s0i/6hUUsH3W5njnGY5NTNKkl1/852801c26b71b9cbf87db67f8fdaf027/ecdh)

An application that wants to POST data to this server needs first to do a key agreement using the server's public key above and then encrypt the payload using the derived shared key using the JWE format. Once the JWE is in place this can be posted to [https://obscure-everglades-31759.herokuapp.com/secret](https://obscure-everglades-31759.herokuapp.com/secret). The web app will respond with a response status 200 if all went well (namely if it can decrypt the payload content) and with a response status 400 if for some reason the received token is missing or invalid. This will act as an oracle for any potential attacker in the way shown in the previous The Attack section.

I set up an attacker application in [https://afternoon-fortress-81941.herokuapp.com/](https://afternoon-fortress-81941.herokuapp.com/).

You can visit it and click the 'Recover Key' button and observe how the attacker is able to recover the secret key from the server piece by piece. Note that this is only a demo application so the recovered secret key is really small in order to reduce the waiting time. In practice the secret key will be significantly larger (hence it will take a bit more to recover the key).

In case you experience problem with the live demo, or simply if  want to see the code under the hood, you can find the demo code in Github:

* [https://github.com/asanso/jwe-receiver](https://github.com/asanso/jwe-receiver) contains the code of the vulnerable server.
* [https://github.com/asanso/jwe-sender](https://github.com/asanso/jwe-sender) contains the code of the attacker.

## Vulnerable Libraries

Here you can find a list of libraries that were vulnerable to this particular attack so far:

* [node-jose](https://github.com/cisco/node-jose) v0.9.3 include the fixes necessary, which was [published few weeks ago](https://github.com/cisco/node-jose/blob/master/CHANGELOG.md). Here the [Gist](https://gist.github.com/asanso/fa25685348051ef6a28d49aa0f27a4ae) of the original proof of concept.*
* [jose2go](https://github.com/dvsekhvalnov/jose2go)'s fix landed in [version 1.3](https://groups.google.com/forum/).
* [Nimbus JOSE+JWT](https://bitbucket.org/connect2id/nimbus-jose-jwt/wiki/Home) pushed out a fixed artifact to Maven central as v4.34.2. Here the [Gist](https://gist.github.com/asanso/5b8cabb862e6f730e00a97d8565dc325) of the original proof of concept.**
* [jose4](https://bitbucket.org/b_c/jose4j/wiki/Home) now comes with a [fix](https://bitbucket.org/b_c/jose4j/commits/0517896170af8d5c057407c70a7b08dae454829e) for this problem since v0.5.5. Here the [Gist](https://gist.github.com/asanso/350e3ce993e44d0509c6023aa77fc6af) of the original proof of concept.**
* [go-jose](https://github.com/square/go-jose) (this is the original library found vulnerable by [Quan Nguyen](https://research.google.com/pubs/pub45790.html))

Some of the libraries were implemented in a programming language that already protects against this attack checking that the result of the scalar multiplication is on the curve:

\* Latest version of Node.js appears to be immune to this attack. It was still possible to be vulnerable when using browsers without web crypto support.

** Affected was the default Java SUN JCA provider that comes with Java prior to version 1.8.0_51. Later Java versions and the BouncyCastle JCA provider do not seem to be affected.  

## Improving the JWE Standard

I reported this issue to the JOSE working group via [mail to the appropriate mailing list](https://www.ietf.org/mail-archive/web/jose/current/msg05612.html). We all seem to agree that an errata where the problem is listed is at least welcomed. This post is a direct attempt to raise awareness about this specific problem.

## Aside: Securing Applications with Auth0

Are you building a [B2C](https://auth0.com/b2c-customer-identity-management), [B2B](https://auth0.com/b2b-enterprise-identity-management), or [B2E](https://auth0.com/b2e-identity-management-for-employees) tool? Auth0, can help you focus on what matters the most to you, the special features of your product. [Auth0](https://auth0.com/) can help you make your product secure with state-of-the-art features like [passwordless](https://auth0.com/passwordless), [breached password surveillance](https://auth0.com/breached-passwords), and [multifactor authentication](https://auth0.com/multifactor-authentication).

[We offer a generous **free tier**](https://auth0.com/pricing) to get started with modern authentication.

## Acknowledgement

The author would like to thanks the maintainers of [go-jose](https://github.com/square/go-jose), [node-jose](https://github.com/cisco/node-jose),[jose2go](https://github.com/dvsekhvalnov/jose2go), [Nimbus JOSE+JWT](https://bitbucket.org/connect2id/nimbus-jose-jwt/wiki/Home) and [jose4](https://bitbucket.org/b_c/jose4j/wiki/Home) for the responsiveness on fixing the issue. [Francesco Mari](https://twitter.com/francescomari) for helping out with the development of the demo application. Tommaso Teofili and Simone Tripodi for troubleshooting. Finally as mentioned above I would like to thank [Quan Nguyen from Google](https://research.google.com/pubs/pub45790.html), indeed this research could not be possible without his initial incipit.

That's all folks. For more crypto goodies, follow me on [Twitter](https://twitter.com/asanso/).

<div class="alert alert-info">
<strong>About Antonio Sanso:</strong><br />
Antonio works as Senior Software Engineer at Adobe Research Switzerland where he is part of the Adobe Experience Manager security team. Antonio is co-author of "OAuth 2 in Action" book. He found vulnerabilities in popular software such as OpenSSL, Google Chrome, Apple Safari and is included in the Google, Facebook, Microsoft, Paypal and Github security hall of fame. He is an avid open source contributor, being the Vice President (chair) for Apache Oltu and PMC member for Apache Sling. His working interests span from web application security to cryptography. Antonio is also the author of more than a dozen computer security patents and applied cryptography academic papers. He holds an MSc in Computer Science.
</div>


"JWE"