Re: [OAUTH-WG] PKCE: SHA256(WAT?)

[John Bradley <[e-mail]>]

Ok I will push out draft 7 to the doc tracker later today. 

Sent from my iPhone

> On Jan 30, 2015, at 6:06 PM, Brian Campbell <[e-mail]> wrote:
> 
> https://bitbucket.org/Nat/oauth-spop/commits/af9ce76988cd32b334e21c71289721a3bf1c4ff1 looks good to me. Thanks John. 
> 
>> On Fri, Jan 30, 2015 at 1:47 PM, John Bradley <[e-mail]> wrote:
>> OK try that one.
>> 
>>> On Jan 30, 2015, at 5:15 PM, Brian Campbell <[e-mail]> wrote:
>>> 
>>> I agree with Mike here. Though PKCE only needs the ASCII(STRING) one.
>>> 
>>>> On Fri, Jan 30, 2015 at 12:38 PM, Mike Jones <[e-mail]> wrote:
>>>> http://tools.ietf.org/html/draft-ietf-jose-json-web-signature-41#section-1.1 uses this notation:
>>>> 
>>>>  
>>>> 
>>>>    UTF8(STRING) denotes the octets of the UTF-8 [RFC3629] representation
>>>> 
>>>>    of STRING, where STRING is a sequence of zero or more Unicode
>>>> 
>>>>    [UNICODE] characters.
>>>> 
>>>>  
>>>> 
>>>>    ASCII(STRING) denotes the octets of the ASCII [RFC20] representation
>>>> 
>>>>    of STRING, where STRING is a sequence of zero or more ASCII
>>>> 
>>>>    characters.
>>>> 
>>>>  
>>>> 
>>>> This is unambiguous and has already been vetted by the IESG and SecDir, so I would use exactly this wording.
>>>> 
>>>>  
>>>> 
>>>> OCTETS(STRING) is ambiguous, since for the same string there are many possible representations as octets, including ASCII, UTF-8, UTF-16, UTF-32, and EBCDIC.
>>>> 
>>>>  
>>>> 
>>>>                                                                 -- Mike
>>>> 
>>>>  
>>>> 
>>>> From: OAuth [mailto:[e-mail]] On Behalf Of John Bradley
>>>> Sent: Friday, January 30, 2015 11:33 AM
>>>> To: Brian Campbell
>>>> Cc: oauth; Naveen Agarwal
>>>> Subject: Re: [OAUTH-WG] PKCE: SHA256(WAT?)
>>>> 
>>>>  
>>>> 
>>>> Have a look at the latest version I added OCTETS(STRING) to show the conversion.   ASCII(STRING) seemed more confusing by drawing character encoding back in.
>>>> 
>>>>  
>>>> 
>>>> I was tempted to call it a octet array without the terminating NULL of STRING but didn’t want to introduce array.
>>>> 
>>>>  
>>>> 
>>>> Let me know what you think.
>>>> 
>>>>  
>>>> 
>>>> On Jan 30, 2015, at 1:56 PM, Brian Campbell <[e-mail]> wrote:
>>>> 
>>>>  
>>>> 
>>>> But, while it may be clear to you, what I'm saying here is that it's not clear to a reader/implementer.
>>>> 
>>>> Somehow the conversion from a character string to an octet string needs to be clearly and unambiguously stated. It doesn't have to be the text I suggested but it's not sufficient as it is now.
>>>> 
>>>> Something like this might work, if you don't want to touch the parts in 4.2 and 4.6: "SHA256(STRING) denotes a SHA2 256bit hash [RFC6234] of the octets of the ASCII [RFC0020] representation of STRING."
>>>> 
>>>> An "octet sequence using the url and filename safe Alphabet [...], with length less than 128 characters." is ambiguous. Octets and characters are intermixed with no mention of encoding. But they're not interchangeable.
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>> On Fri, Jan 30, 2015 at 7:15 AM, Nat Sakimura <[e-mail]> wrote:
>>>> 
>>>> I do not think we need ASCII(). It is quite clear without it, I suppose. 
>>>> 
>>>>  
>>>> 
>>>> In 4.1, I would rather do like: 
>>>> 
>>>>  
>>>> 
>>>>  code_verifier = high entropy cryptographic random 
>>>>    octet sequence using the url and filename safe Alphabet [A-Z] / [a-z]
>>>>    / [0-9] / "-" / "_" from Sec 5 of RFC 4648 [RFC4648], with length
>>>>    less than 128 characters.
>>>> 
>>>>  
>>>> 
>>>> Nat
>>>> 
>>>>  
>>>> 
>>>> 2015-01-30 22:51 GMT+09:00 Brian Campbell <[e-mail]>:
>>>> 
>>>> That's definitely an improvement (to me anyway).
>>>> 
>>>> Checking that the rest of the document uses those notations appropriately, I think, yields a few other changes. And probably begs for the "ASCII(STRING) denotes the octets of the ASCII representation of STRING" notation/function, or something like it, to be put back in. Those changes might look like the following:
>>>> 
>>>> 
>>>> In 4.1.: 
>>>> 
>>>> OLD:
>>>>    code_verifier = high entropy cryptographic random ASCII [RFC0020]
>>>>    octet sequence using the url and filename safe Alphabet [A-Z] / [a-z]
>>>>    / [0-9] / "-" / "_" from Sec 5 of RFC 4648 [RFC4648], with length
>>>>    less than 128 characters.
>>>> 
>>>> NEW (maybe):
>>>>   code_verifier = high entropy cryptographically strong random STRING
>>>>   using the url and filename safe Alphabet [A-Z] / [a-z]
>>>>    / [0-9] / "-" / "_" from Sec 5 of RFC 4648 [RFC4648], with length
>>>>    less than 128 characters.
>>>> 
>>>> 
>>>> In 4.2.: 
>>>> 
>>>> OLD:
>>>>    S256  "code_challenge" = BASE64URL(SHA256("code_verifier"))
>>>> 
>>>> NEW (maybe):
>>>>    S256  "code_challenge" = BASE64URL(SHA256(ASCII("code_verifier")))
>>>> 
>>>> 
>>>> In 4.6.: 
>>>> 
>>>> OLD:
>>>>    SHA256("code_verifier" ) == BASE64URL-DECODE("code_challenge").
>>>> 
>>>> NEW (maybe):
>>>>    SHA256(ASCII("code_verifier")) == BASE64URL-DECODE("code_challenge").
>>>> 
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>> On Thu, Jan 29, 2015 at 8:37 PM, Nat Sakimura (=nat) <[e-mail]> wrote:
>>>> 
>>>> I take your point, Brian. 
>>>> 
>>>>  
>>>> 
>>>> In our most recent manuscript, STRING is defined inside ASCII(STRING) as 
>>>> 
>>>>  
>>>> 
>>>> STRING is a sequence of zero or more ASCII characters
>>>> 
>>>>  
>>>> 
>>>> but it is kind of circular, and we do not seem to use ASCII(). 
>>>> 
>>>>  
>>>> 
>>>> What about re-writing the section like below? 
>>>> 
>>>>  
>>>> 
>>>> STRING denotes a sequence of zero or more ASCII  [RFC0020] characters. 
>>>> 
>>>> OCTETS denotes a sequence of zero or more octets. 
>>>> 
>>>> BASE64URL(OCTETS) denotes the base64url encoding of OCTETS, per Section 3 producing a ASCII[RFC0020] STRING.
>>>> 
>>>> BASE64URL-DECODE(STRING) denotes the base64url decoding of STRING, per Section 3, producing a sequence of octets.
>>>> 
>>>> SHA256(OCTETS) denotes a SHA2 256bit hash [RFC6234] of OCTETS.
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>> On Jan 30, 2015, at 08:15, Brian Campbell <[e-mail]> wrote:
>>>> 
>>>>  
>>>> 
>>>> In §2 [1] we've got "SHA256(STRING) denotes a SHA2 256bit hash [RFC6234] of STRING."
>>>> 
>>>> But, in the little cow town where I come from anyway, you hash bits/octets not character strings (BTW, "STRING" isn't defined anywhere but it's kind of implied that it's a string of characters). 
>>>> 
>>>> Should it say something more like "SHA256(STRING) denotes a SHA2 256bit hash [RFC6234] of the octets of the ASCII [RFC0020] representation of STRING."?
>>>> 
>>>> I know it's kind of pedantic but I find it kind of confusing because the code_verifier uses the url and filename safe alphabet, which has me second guessing if SHA256(STRING) actually means a hash of the octet produced by base64url decoding the string.
>>>> 
>>>> Maybe it's just me but, when reading the text, I find the transform process to be much more confusing than I think it needs to be. Removing and clarifying some things will help. I hate to suggest this but maybe an example showing the computation steps on both ends would be helpful?
>>>> 
>>>>  
>>>> 
>>>> Also "UTF8(STRING)" and "ASCII(STRING)" notations are defined in §2 but not used anywhere.
>>>> 
>>>> And §2 also says, "BASE64URL-DECODE(STRING) denotes the base64url decoding of STRING, per Section 3, producing a UTF-8 sequence of octets." But what is a UTF-8 sequence of octets? Isn't it just a sequence octets? The [RFC3629] reference, I think, could be removed.
>>>> 
>>>>  
>>>> 
>>>> [1] https://tools.ietf.org/html/draft-ietf-oauth-spop-06#section-2
>>>> 
>>>>  
>>>> 
>>>> Nat Sakimura
>>>> 
>>>> [e-mail]
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>>  
>>>> 
>>>> 
>>>> 
>>>> 
>>>>  
>>>> 
>>>> --
>>>> 
>>>> Nat Sakimura (=nat)
>>>> 
>>>> Chairman, OpenID Foundation
>>>> http://nat.sakimura.org/
>>>> @_nat_en
>>>> 
>