Proof Key for Code Exchange by OAuth Public Clients
draft-ietf-oauth-spop-15

[Ballot comment]
Version -14 resolves my DISCUSS (and also some of my non-blocking comments).  Thanks very much for considering these and working with me on them!

  =========================================
My comment about the IANA Considerations remains.  While it's non-blocking, I still hope you will accept the change I suggest:

-- Section 6.2 --
I have the same comment here as in the other OAuth document: please shift the focus away from telling IANA how to handle tracking of the expert review, and make the mailing list something that the designated expert(s) keep track of.  Also, please give more instructions to the DEs about what they should consider when they're evaluating a request (for example, should they approve all requests, or are there criteria they should apply?).

For the first, here's a text change that I suggest we move toward for this sort of thing:

OLD


NEW
  Additional code_challenge_method types for use with the authorization
  endpoint are registered using the Specification Required policy
  [RFC5226], which includes review of the request by one or more
  Designated Experts.  The DEs will ensure there is at least a two-week
  review of the request on the oauth-ext-review@ietf.org mailing list,
  and that any discussion on that list converges before they respond to
  the request.  To allow for the allocation of values prior to
  publication, the Designated Expert(s) may approve registration once
  they are satisfied that an acceptable specification will be published.

  Discussion on the oauth-ext-review@ietf.org mailing list should use
  an appropriate subject, such as "Request for PKCE
  code_challenge_method: example").

  The Designated Expert(s) should consider the discussion on the
  mailing list, as well as <> when evaluating
  registration requests.  Denials should include an explanation
  and, if applicable, suggestions as to how to make the request
  successful.
END

  =========================================
-- Section 7.2 --
I find the first first paragraph confusingly worded, and after discussion with the author I suggest this:

NEW
Clients MUST NOT downgrade to "plain" after trying the S256 method.
Because servers are required to support S256, an error when S256 is
presented can only mean that the server does not support PKCE at all.
Otherwise, such an error could be indicative of a MITM attacker trying
a downgrade attack.
END

  =========================================
Finally, there is this comment, which is not a big deal and you should proceed as you think best:

-- Section 2 --
There is no real distinction between STRING and ASCII(STRING), because STRING is already defined to be ASCII.  Using "ASCII(xxx)" only adds clutter, and a suggest removing it.

So, for example, that would result in changes such as this:

OLD
BASE64URL-ENCODE(SHA256(ASCII(code_verifier))) == code_challenge
NEW
BASE64URL-ENCODE(SHA256(code_verifier)) == code_challenge
END

[Ballot discuss]
After getting John's explanation of the background and details of the attack (and the different communications paths involved, I still would prefer that we build this protocol as a more robust one (with only S256 and not "plain"), but I understand the reasons to have it this way, and I think it will be acceptable with some changes to the text to make the situation clearer.

To that end, I suggest this:

In the introduction, I think the explanation of Figure 1 (the fourth paragraph) should be changed to make it clear what communication paths are used in each step, and where the vulnerable piece is.  Something like this:

OLD
  In step (1) the native app
  running on the end device, such as a smart phone, issues an
  authorization request via the browser/operating system, which then
  gets forwarded to the OAuth 2.0 authorization server in step (2).
  The authorization server returns the authorization code in step (3).
  The malicious app is able to observe the authorization code in step
  (4) since it is registered to the custom URI scheme used by the
  legitimate app.  This allows the attacker to reguest and obtain an
  access token in step (5) and step (6), respectively.
NEW
  In step (1) the native app
  running on the end device, such as a smart phone, issues an
  authorization request via the browser/operating system.  The
  request includes a URI by which the response will be returned,
  and that uses a custom URI scheme.  Step (1) happens through a
  secure API that cannot be intercepted.  The request then gets
  forwarded to the OAuth 2.0 authorization server in step (2).
  Because OAuth requires the use of TLS, this communication is
  protected by TLS, and also cannot be intercepted. The
  authorization server returns the authorization code over the
  same TLS connection in step (3). In step (4), the Authorization
  Code is returned to the requester via the URI that was provided
  in step (1).
 
  A malicious app that has been designed to attack this native
  app has previously registered itself as a handler for the custom
  URI scheme, and is now able to observe the Authorization Code in
  step (4).  This allows the attacker to request and obtain an
  access token in steps (5) and (6).
END

That (or something like it) makes it clear that only one step is vulnerable, and explicitly tells us that the other communication paths are already protected.

In the list of pre-conditions, I suggest changing (1) to make "another application" be "a legitimate application that uses OAuth".

*** IMPORTANT *** I am still puzzled by this, in pre-condition (4), which seems to contradict what John said and what I proposed above:

  4) The attacker (via the installed app) is able to observe responses
      from the authorization endpoint.  As a more sophisticated attack
      scenario the attacker is also able to observe requests (in
      addition to responses) to the authorization endpoint.

Can you please explain the "more sophisticated attack", and how the attacker can observe the request?  Because "plain" will NOT work in such a situation.

I suggest changing the last paragraph in the Introduction like this:

OLD
  To mitigate this attack, this extension utilizes a dynamically
  created cryptographically random key called 'code verifier'.  A
  unique code verifier is created for every authorization request and
  its transformed value, called 'code challenge', is sent to the
  authorization server to obtain the authorization code.
NEW
  To mitigate this attack, this extension utilizes a dynamically
  created cryptographically random key called 'code verifier'.  A
  unique code verifier is created for every authorization request and
  its transformed value, called 'code challenge', is sent to the
  authorization server to obtain the authorization code.  This
  transmission is sent through a secure API, and cannot be
  intercepted.
END

I know it repeats what was said in the explanation above, but it's an important enough point to merit repetition.

I suggest changing Section 4.4.1 like this (because of a misuse of "MAY" that I missed before):

OLD
  If the client is capable of using "S256", it MUST use "S256", as
  "S256" is Mandatory To Implement (MTI) on the server.  Clients MAY
  use "plain" only if they cannot support "S256" for some technical
  reason and knows that the server supports "plain".
NEW
  If the client is capable of using "S256", it MUST use "S256", as
  "S256" is Mandatory To Implement (MTI) on the server.  Clients are
  permitted to use "plain" only if they cannot support "S256" for
  some technical reason and know that the server supports "plain".
END

Finally, I suggest changing this in Section 7.2:

OLD
  "S256" method protects against eavesdroppers observing or
  intercepting the "code_challenge".  If the "plain" method is used,
  there is a chance that it will be observed by the attacker on the
  device.  The use of "S256" protects against it.
NEW
  The "S256" method protects against eavesdroppers observing or
  intercepting the "code_challenge", because the challenge cannot
  be used without the verifier.  With the "plain" method, the
  challenge can be directly used during the verification step,
  so "plain" does not protect against interception of the initial
  request.
 
  Because of this, "plain" SHOULD NOT be used, and exists only for
  compatibility with deployed implementations where the request
  path is already protected.  The "plain" method MUST NOT be used
  in new implementations.
END

With that set of changes, or something like them (feel free to re-write, and certainly correct anything I got wrong!), I will clear this DISCUSS and we can move ahead.

If you find anything fundamentally messed up in any of that, please do discuss it with me, and let's sort it out.  And, again, thanks for the explanation that made this all clear.

[Ballot comment]
Putting quotation marks around "code_verifier" and "code_challenge" in the formulas is confusing: it makes it look as if you're putting in those strings themselves, rather than the values of the variables.  It's probably unlikely that anyone would make that mistake, but I nevertheless suggest removing the quotation marks when you mean to refer to the values.

-- Section 2 --
There is no real distinction between STRING and ASCII(STRING), because STRING is already defined to be ASCII.  Using "ASCII(xxx)" only adds clutter, and a suggest removing it.

So, for example, these last two comments would make changes such as this one:

OLD
BASE64URL-ENCODE(SHA256(ASCII("code_verifier" ))) == "code_challenge"
NEW
BASE64URL-ENCODE(SHA256(code_verifier)) == code_challenge
END

-- Section 4.3 --
I would very strongly prefer that S256 be the default, not "plain"... or that the method be required, with no default.  I understand that this makes existing implementations break.

-- Section 4.4 --
The word "code" is used for too many things, and "Authorization Code" is already the right name for what we're talking about here.  I suggest that in both the section title and body you use that term, to make it clear what you mean by the "code".  Similarly, in Section 4.5 please say "code_verifier" rather than "secret".  (Nat plans to make these changes.)

-- Section 4.4.1 --
Please expand "PKCE", which is, at the moment, only expanded in the document title.  (Nat plans to make a change for this.)

-- Section 5 --
The SHOULD in the first paragraph is wrong.  You already have a MAY covering the general behavior.  You should just take out the "SHOULD", and just say that severs supporting backwards compatibility revert to the normal OAuth protocol.  (Nat plans to make a change for this.)

-- Section 6.2 --
I have the same comment here as in the other OAuth document: please shift the focus away from telling IANA how to handle tracking of the expert review, and make the mailing list something that the designated expert(s) keep track of.  Also, please give more instructions to the DEs about what they should consider when they're evaluating a request (for example, should they approve all requests, or are there criteria they should apply?).

For the first, here's a text change that I suggest we move toward for this sort of thing:

OLD


NEW
  Additional code_challenge_method types for use with the authorization
  endpoint are registered using the Specification Required policy
  [RFC5226], which includes review of the request by one or more
  Designated Experts.  The DEs will ensure there is at least a two-week
  review of the request on the oauth-ext-review@ietf.org mailing list,
  and that any discussion on that list converges before they respond to
  the request.  To allow for the allocation of values prior to
  publication, the Designated Expert(s) may approve registration once
  they are satisfied that an acceptable specification will be published.

  Discussion on the oauth-ext-review@ietf.org mailing list should use
  an appropriate subject, such as "Request for PKCE
  code_challenge_method: example").

  The Designated Expert(s) should consider the discussion on the
  mailing list, as well as <> when evaluating
  registration requests.  Denials should include an explanation
  and, if applicable, suggestions as to how to make the request
  successful.
END

(Nat plans to make a change for this.)

-- Section 7.2 --
For the first paragraph, after discussion with the author I suggest this:

NEW
Clients MUST NOT downgrade to "plain" after trying the S256 method.
Because servers are required to support S256, an error when S256 is
presented can only mean that the server does not support PKCE at all.
Otherwise, such an error could be indicative of a MITM attacker trying
a downgrade attack.
END

[Ballot comment]
From Melinda Shore's OPSdir review:

I have reviewed this document as part of the Operational directorate's
ongoing effort to review all IETF documents being processed by the
IESG.  These  comments were written with the intent of improving the
operational aspects of the  IETF drafts. Comments that are not
addressed in last call may be included in AD reviews
during the IESG review.  Document editors and WG chairs should treat
these comments just like any other last call comments.

Summary:

This document is ready, with very minor issues.  It does not appear to
introduce new management/manageability considerations.

This document describes a challenge-response mechanism to protect
against an OAuth authorization code being intercepted by an attacker,
when that authorization code is sent in the clear.  The authorization
code is used to acquire an access token and must be protected.  This
attack (an attacker using an intercepted authz code to acquire an
access token) has been observed in the wild.

We are astonished to learn that OAuth is being run over an
unencrypted channel.

However, given that it is, this is a reasonable defense mechanism.

Questions:

Why is S256 RECOMMENDED and not a MUST?

Nits:

ASCII(STRING) does not appear to be used in the protocol grammar?

Melinda

[Ballot comment]
I share Barry's and Alexey's concerns about both allowing "plain" and defaulting to it.  I have some other comments, which may overlap with the comments from others:

Substantive:

-- section 1, pre-condition 3: "All OAuth 2.0 native app client-instances use the same client_id.  Secrets provisioned in client binary applications cannot be considered confidential."

Is that part of the pre-condition per-se, or a general statement? If the former, wouldn't a potential mitigation for this attack be to ensure the precondition doesn't occur?

-- section 1, paragraph after precondition list: "not applicable since they rely on a per-client instance secret or aper client instance
  redirect URI."

I infer that these are not realistic? If so, it might be useful to say why. For instance, would one way to mitigate this attack be to make sure you have per-client secrets and redirect URIs?

-- 4.4.1, last sentence:

Does this advice change if people register new challenge methods?  That is, what if the client supports "plain", and "foo" but not S256, where foo is more secure than plain. Can it still use "plain"?

-- 6.2:

Does the ability to register new challenge methods introduce bid-down attacks? (Assuming that any such method is more secure than "plain", and that the server might not support it.)

Also, I share Barry's concern that the registration procedures require quite a bit of special treatment from IANA.

-- 7.4:

This seems to need a normative reference to 6819.

-- 7.5: How does the guidance in section 10.8 of 6479 apply to the code_verifier? Also, I think the last sentence requires this draft (or some other) to update 6749.

Editorial:

-- 4.4, 2nd to last paragraph: "The server MUST NOT include the "code_challenge" value in client requests in a form that other entities can extract."

should "client requests" be "responses to clients"? (I assume the server does not send client requests--or do I have the terminology wrong?)

-- 4.4.1, first paragraph:
Please expand PKCE on first mention. (It might help to declare PKCE in the introduction.)

[Ballot discuss]
How does "plain" do anything at all to mitigate this attack?  Wouldn't anyone who could snag the grant also be able to snag the code verifier as well?  Why is "plain" even here?

[Ballot comment]
General:
I would think that this mechanism should never be a substitute for using TLS, and that this document should be explicit about that, and should say that the proper mitigation for situations where TLS can be used... is to use TLS.  Is there a reason we should NOT say that?

Putting quotation marks around "code_verifier" and "code_challenge" in the formulas is confusing: it makes it look as if you're putting in those strings themselves, rather than the values of the variables.  It's probably unlikely that anyone would make that mistake, but I nevertheless suggest removing the quotation marks when you mean to refer to the values.

-- Section 2 --
I don't understand the distinction between STRING and ASCII(STRING).  Can you please explain it?

-- Section 4.3 --
If "plain" does stay, why on Earth is it the default?  Even if just for form's sake, shouldn't S256 be the default?

-- Section 4.4 --
The word "code" is used for too many things, and "Authorization Grant" is already the right name for what we're talking about here.  I suggest that in both the section title and body you use that term, to make it clear what you mean by the "code".  Similarly, in Section 4.5 please say "code_verifier" rather than "secret".

-- Section 4.4.1 --
Please expand "PKCE", which is, at the moment, only expanded in the document title.

-- Section 5 --
The SHOULD in the first paragraph is wrong.  You already have a MAY covering the general behavior.  You should just take out the "SHOULD", and just say that severs supporting backwards compatibility revert to the normal OAuth protocol.

-- Section 6.2 --
I have the same comment here as in the other OAuth document: please shift the focus away from telling IANA how to handle tracking of the expert review, and make the mailing list something that the designated expert(s) keep track of.  Also, please give more instructions to the DEs about what they should consider when they're evaluating a request (for example, should they approve all requests, or are there criteria they should apply?).

For the first, here's a text change that I suggest we move toward for this sort of thing:

OLD


NEW
  Additional code_challenge_method types for use with the authorization
  endpoint are registered using the Specification Required policy
  [RFC5226], which includes review of the request by one or more
  Designated Experts.  The DEs will ensure there is at least a two-week
  review of the request on the oauth-ext-review@ietf.org mailing list,
  and that any discussion on that list converges before they respond to
  the request.  To allow for the allocation of values prior to
  publication, the Designated Expert(s) may approve registration once
  they are satisfied that an acceptable specification will be published.

  Discussion on the oauth-ext-review@ietf.org mailing list should use
  an appropriate subject, such as "Request for PKCE
  code_challenge_method: example").

  The Designated Expert(s) should consider the discussion on the
  mailing list, as well as <> when evaluating
  registration requests.  Denials should include an explanation
  and, if applicable, suggestions as to how to make the request
  successful.
END

-- Section 7.2 --
Please rewrite the first paragraph.  Please do not leave it for the RFC Editor, as they may inadvertently get it technically wrong when they try.

(Via drafts-lastcall@iana.org): IESG/Authors/WG Chairs:

[Revised IANA Last Call Comments: added one missing new OAuth Parameter.]

IANA has reviewed draft-ietf-oauth-spop-11. Authors should review the comments and/or questions below. Please report any inaccuracies and respond to any questions as soon as possible.

We received the following comments/questions from the IANA's reviewer:

IANA has a question about one of the actions requested in the IANA Considerations section of this document.

IANA understands that, upon approval of [ RFC-to-be ], there is are two actions which must be completed.

First, in the OAuth Parameters subregistry of the OAuth Parameters registry located at:

http://www.iana.org/assignments/oauth-parameters/

'three' new OAuth Parameters will be registered as follows:

Parameter name: code_verifier
Parameter usage location: Access Token Request
Change controller: IESG
Specification document(s): [ RFC-to-be ]

Parameter name: code_challenge
Parameter usage location: Authorization Request
Change controller: IESG
Specification document(s): [ RFC-to-be ]

Parameter name: code_challenge_method
Parameter usage location: Authorization Request
Change controller: IESG
Specification document(s): [ RFC-to-be ]

As this document requests registrations in a Specification Required (see RFC 5226) registry, we will initiate the required Expert Review via a separate request. Expert review will need to be completed before your document can be approved for publication as an RFC.

Second, a new registry is to be created called the PKCE Code Challenge Method Registry. This registry will be maintained via Specification Required as defined in RFC 5226.

IANA QUESTION -> Where should this new registry be located? Is it a néw registry on the IANA Matrix (http://www.iana.org/protocols) or is it a subregistry of an existing registry? If it is a subregistry of an existing registry, in which registry will it be contained? Is the new registry under this existing heading OAuth Parameters located at http://www.iana.org/protocols?

In a location to be determined (see question above), there will be initial registrations in the new registry as follows:

Code Challenge Method Parameter Name: plain
Change Controller: IESG
Specification Document(s): Section 4.2 of [ RFC-to-be ]

Code Challenge Method Parameter Name: S256
Change Controller: IESG
Specification Document(s): Section 4.2 of [ RFC-to-be ]

IANA understands taht these two actions are the only ones that need to be completed upon approval of this document.

Note: The actions requested in this document will not be completed until the document has been approved for publication as an RFC. This message is only to confirm what actions will be performed.

(Via drafts-lastcall@iana.org): IESG/Authors/WG Chairs:

IANA has reviewed draft-ietf-oauth-spop-11.  Authors should review the comments and/or questions below.  Please report any inaccuracies and respond to any questions as soon as possible.

We received the following comments/questions from the IANA's reviewer:

IANA has a question about one of the actions requested in the IANA Considerations section of this document.

IANA understands that, upon approval of [ RFC-to-be ], there is are two actions which must be completed.

First, in the OAuth Parameters subregistry of the OAuth Parameters registry located at:

http://www.iana.org/assignments/oauth-parameters/

two new OAuth Parameters will be registered as follows:

Parameter name: code_verifier
Parameter usage location: Access Token Request
Change controller: IESG
Specification document(s): [ RFC-to-be ]

Parameter name: code_challenge
Parameter usage location: Authorization Request
Change controller: IESG
Specification document(s): [ RFC-to-be ]

As this document requests registrations in a Specification Required (see RFC 5226) registry, we will initiate the required Expert Review via a separate request.  Expert review will need to be completed before your document can be approved for publication as an RFC.

Second, a new registry is to be created called the PKCE Code Challenge Method Registry. This registry will be maintained via Specification Required as defined in RFC 5226.

IANA QUESTION -> Where should this new registry be located? Is it a néw registry on the IANA Matrix (http://www.iana.org/protocols) or is it a subregistry of an existing registry? If it is a subregistry of an existing registry, in which registry will it be contained?  Is the new registry under this existing heading OAuth Parameters located at http://www.iana.org/protocols?

In a location to be determined (see question above), there will be initial registrations in the new registry as follows:

Code Challenge Method Parameter Name: plain
Change Controller: IESG
Specification Document(s): Section 4.2 of [ RFC-to-be ]

Code Challenge Method Parameter Name: S256
Change Controller: IESG
Specification Document(s): Section 4.2 of [ RFC-to-be ]

IANA understands taht these two actions are the only ones that need to be completed upon approval of this document.

Note:  The actions requested in this document will not be completed until the document has been approved for publication as an RFC. This message is only to confirm what actions will be performed.

The following Last Call announcement was sent out:

From: The IESG
To: IETF-Announce
CC:
Reply-To: ietf@ietf.org
Sender:
Subject: Last Call:  (Proof Key for Code Exchange by OAuth Public Clients) to Proposed Standard


The IESG has received a request from the Web Authorization Protocol WG
(oauth) to consider the following document:
- 'Proof Key for Code Exchange by OAuth Public Clients'
  as Proposed Standard

The IESG plans to make a decision in the next few weeks, and solicits
final comments on this action. Please send substantive comments to the
ietf@ietf.org mailing lists by 2015-06-01. Exceptionally, comments may be
sent to iesg@ietf.org instead. In either case, please retain the
beginning of the Subject line to allow automated sorting.

Abstract


  OAuth 2.0 public clients utilizing the Authorization Code Grant are
  susceptible to the authorization code interception attack.  This
  specification describes the attack as well as a technique to mitigate
  against the threat.




The file can be obtained via
https://datatracker.ietf.org/doc/draft-ietf-oauth-spop/

IESG discussion can be tracked via
https://datatracker.ietf.org/doc/draft-ietf-oauth-spop/ballot/


No IPR declarations have been submitted directly on this I-D.

Shepherd Write-Up for "Proof Key for Code Exchange by OAuth Public Clients"


(1) What type of RFC is being requested (BCP, Proposed Standard,
Internet Standard, Informational, Experimental, or Historic)?  Why
is this the proper type of RFC?  Is this type of RFC indicated in the
title page header?

This specification is proposed as a 'Standards Track' document. The
type of RFC is indicated and the specification defines new OAuth
protocol parameters.

(2) The IESG approval announcement includes a Document Announcement
Write-Up. Please provide such a Document Announcement Write-Up. Recent
examples can be found in the "Action" announcements for approved
documents. The approval announcement contains the following sections:

Technical Summary

  OAuth 2.0 public clients utilizing the Authorization Code Grant
  are susceptible to the authorization code interception attack. 
  This specification describes the attack as well as a technique
  to mitigate against the threat.

Working Group Summary

  The working group last call for this document was started
  soon after the document was adopted as a WG item. A substantial
  number of comments were received and the subsequent document
  versions addressed those comments. No difficult decisions
  had to be made by the chairs or the group.

Document Quality

  Are there existing implementations of the protocol? Have a
  significant number of vendors indicated their plan to
  implement the specification? Are there any reviewers that
  merit special mention as having done a thorough review,
  e.g., one that resulted in important changes or a
  conclusion that the document had no substantive issues? If
  there was a MIB Doctor, Media Type or other expert review,
  what was its course (briefly)? In the case of a Media Type
  review, on what date was the request posted?

PingIdentity, Google, and Deutsche Telekom have implementations
of the plain code challenge method.

The documentation of the PingIdentity implementation can be
found at
http://documentation.pingidentity.com/pages/viewpage.action?pageId=26706844

The open source phpOIDC implementation contains code for the
S256 and the plain code challenge methods.

Personnel

  Who is the Document Shepherd? Who is the Responsible Area
  Director?

Hannes Tschofenig is the document shepherd and the responsible area
director is Kathleen Moriarty.

(3) Briefly describe the review of this document that was performed by
the Document Shepherd.  If this version of the document is not ready
for publication, please explain why the document is being forwarded to
the IESG.

The document shepherd was involved in the working group review process
and verified the document for correctness.

(4) Does the document Shepherd have any concerns about the depth or
breadth of the reviews that have been performed? 

There are no concerns regarding the document reviews.

(5) Do portions of the document need review from a particular or from
broader perspective, e.g., security, operational complexity, AAA, DNS,
DHCP, XML, or internationalization? If so, describe the review that
took place.

The document contains ABNF. As noted at the end of this shepherd
write-up there might be an issue with the ABNF syntax in the document.

During the review an issue surfaced regarding the incorrect use of
ABNF in various OAuth specifications. This issue was raised on the
OAuth mailing list:
https://www.ietf.org/mail-archive/web/oauth/current/msg14099.html

Review from an ABNF expert would be desirable.

(6) Describe any specific concerns or issues that the Document Shepherd
has with this document that the Responsible Area Director and/or the
IESG should be aware of? For example, perhaps he or she is uncomfortable
with certain parts of the document, or has concerns whether there really
is a need for it. In any event, if the WG has discussed those issues and
has indicated that it still wishes to advance the document, detail those
concerns here.

The document shepherd has no concerns with the document.

(7) Has each author confirmed that any and all appropriate IPR
disclosures required for full conformance with the provisions of BCP 78
and BCP 79 have already been filed. If not, explain why.

The authors have confirmed full conformance with the provisions of BCP 78
and BCP 79:

Nat Sakimura: http://www.ietf.org/mail-archive/web/oauth/current/msg14206.html
John Bradley: http://www.ietf.org/mail-archive/web/oauth/current/msg14207.html
Naveen Agarwal: http://www.ietf.org/mail-archive/web/oauth/current/msg14337.html

(8) Has an IPR disclosure been filed that references this document?
If so, summarize any WG discussion and conclusion regarding the IPR
disclosures.

No IPR disclosures have been filed for this document.

(9) How solid is the WG consensus behind this document? Does it
represent the strong concurrence of a few individuals, with others
being silent, or does the WG as a whole understand and agree with it? 

There is solid consensus in the working group for publishing this
document. This specification addresses a security vulnerability
found in the wild.

(10) Has anyone threatened an appeal or otherwise indicated extreme
discontent? If so, please summarise the areas of conflict in separate
email messages to the Responsible Area Director. (It should be in a
separate email because this questionnaire is publicly available.)

Nobody threatened an appeal or expressed extreme discontent.

(11) Identify any ID nits the Document Shepherd has found in this
document. (See http://www.ietf.org/tools/idnits/ and the Internet-Drafts
Checklist). Boilerplate checks are not enough; this check needs to be
thorough.

The shepherd checked the document.

(12) Describe how the document meets any required formal review
criteria, such as the MIB Doctor, media type, and URI type reviews.

No formal review is needed.

(13) Have all references within this document been identified as
either normative or informative?

Yes. The references are split into normative and informative references.

(14) Are there normative references to documents that are not ready for
advancement or are otherwise in an unclear state? If such normative
references exist, what is the plan for their completion?

All normative references are published RFCs.

(15) Are there downward normative references references (see RFC 3967)?
If so, list these downward references to support the Area Director in
the Last Call procedure.

The specification has a normative dependency on an informational RFC,
namely "US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)"
(RFC 6234). This is a downward reference.

We reference RFC 20 for the ASCII syntax and that RFC does not have a
status. Maybe there is another reference that could be used instead.

(16) Will publication of this document change the status of any
existing RFCs? Are those RFCs listed on the title page header, listed
in the abstract, and discussed in the introduction? If the RFCs are not
listed in the Abstract and Introduction, explain why, and point to the
part of the document where the relationship of this document to the
other RFCs is discussed. If this information is not in the document,
explain why the WG considers it unnecessary.

This document does not change the status of an existing RFC.

(17) Describe the Document Shepherd's review of the IANA considerations
section, especially with regard to its consistency with the body of the
document. Confirm that all protocol extensions that the document makes
are associated with the appropriate reservations in IANA registries.
Confirm that any referenced IANA registries have been clearly
identified. Confirm that newly created IANA registries include a
detailed specification of the initial contents for the registry, that
allocations procedures for future registrations are defined, and a
reasonable name for the new registry has been suggested (see RFC 5226).

This document allocates three new parameters to the existing OAuth
parameter registry (see Section 6.1) and creates a new registry
called 'PKCE Code Challenge Method' registry. This document adds
two values to the PKCE Code Challenge Method registry, as defined
in Section 6.2.2.

The IANA consideration section correspond to the body of the document.

(18) List any new IANA registries that require Expert Review for future
allocations. Provide any public guidance that the IESG would find
useful in selecting the IANA Experts for these new registries.

The 'PKCE Code Challenge Method' registry requires expert review.
Selecting experts from the OAuth working group might be useful.

(19) Describe reviews and automated checks performed by the Document
Shepherd to validate sections of the document written in a formal
language, such as XML code, BNF rules, MIB definitions, etc.

The document shepherd used 'Bill's ABNF Parser' to verify the
included ABNF code. I get an error from 'Bill's ABNF Parser'.
The tool complains about the use of the "_" in the code_verifier label.

It turns out that this is not an allowed token in ABNF as defined in RFC
5234 (at least that's my current understanding).

Since we have been using the "_" character in labels in various
parameters in OAuth there is nothing that can be done at this
point in time.

The shepherd suggests to ask ABNF experts whether this observation
is actually correct. If incorrect, then there is no problem.

The specification also contains C# code in the appendix. The shepherd
has verified the code against the provided example.