[OAUTH-WG] draft-bradley-stateless-oauth-client-00

[Hannes Tschofenig <[e-mail]>]

Hi John,
Hi all,

I read your document and here a few remarks.

In the dynamic client registration conference calls the topic of the 
stateless client was raised since there was the argument in the air that 
the current OAuth 2.0 RFC requires clients to be stateless due to the 
nature of the client identifier.

It seems that you have found a way to make the client stateless with 
regard to the client identifier (i.e., that the authorization server 
does not need to store information about the client) by dumping state 
information in the client identifier itself. In your case you use a JWT, 
which is clever.

Since RFC 6749 explicitly says that the client identifier string size is 
left undefined  and that the client should avoid making assumptions 
about the identifier size I don't see a problem with the proposed approach.

Now, there is one issue that I am wondering about. The client identifier 
itself is not sufficient for authorizing the client (for confidential 
clients). Instead, there is typically the need to have a secret. Now, 
the secret is not conveyed in the JWT, at least not in the way you have 
define it. You could of course do that and there is a document that 
provides prior art, see http://www.ietf.org/rfc/rfc5077
The story essentially is that the structure (JWT in your case) includes 
the key but of course then you have to encrypt the entire blob.

In the case of public clients wouldn't you want to mandate at least a 
digital signature or a keyed message digest for the JWT since otherwise 
there is the risk that the client changes some of the parameters to 
impersonate someone?

A few other questions:

* You write:
"The issuer SHOULD sign the JWT with JWS in such a way that the 
signature can be verified by the authorization server.
"

I believe what you want to say is the following: The authorization 
creates the client identifier (using the JWT) and the client does not 
parse the received content since it treats it as opaque. However, the 
authorization server MUST be able to process and verify received client 
identifiers it previously created, which requires to apply cryptographic 
processing when a JWT is signed (using a JWS) and when a JWT is 
encrypted (using a JWE).

(I ignore the issue that I believe the JWT needs to be signed [for 
public clients] and encrypted [for confidential clients].)

* You should submit the document as draft-bradley-oauth; this makes it 
easier to find the document.

* You write:
"
The issuer MAY encrypt the JWT with JWE.
"

I think you want to be stronger by saying that JWE MUST be used when the 
authorization server wants to apply confidentiality protection of the 
JWT. While the authorization server could use other techniques as well 
the purpose of the document is to describe one way to accomplish the 
goal and therefore it makes sense to be specific.

I would even go as far as suggesting specific algorithms to use, as an 
example.

* Although not stated directly I believe you allow the client identifier 
to be created by a party other than the authorization server. While this 
would theoretically make sense wouldn't it be useful to just assume that 
the issuer is the authorization server?

Ciao
Hannes