Subject: SCRAM and YAP

From: Nicolas Williams <[email-masked]>
Date: Wed, 30 Jan 2008 15:14:46 -0600

While we're at it, if we'll not have sec layers and we'll expect the use
of TLS and channel bindings, then we might as well add a fast mode to
SCRAM where IF the channel bindings provided are of the "unique" type,
where the channel binding is used as the challenge (this what Kurt's YAP
is premised on).

Jeff H. off-line worries that "unique channel binding" need not be good
enough to replace the challenge.  I believe that it always would be, or
would have to be if the "unique channel binding" be good enough to
detect MITMs.  I don't have proof at this time.

Saving a round-trip the likely-to-be-common case strikes me as good.
(Not using TLS and channel binding while also not having security layers
strikes me as not terribly useful, security-wise, though still something
that should be supported.)

Nico
--

---

From: Philip Guenther <[email-masked]>
Date: Wed, 30 Jan 2008 23:08:28 -0700

On Wed, 30 Jan 2008, Nicolas Williams wrote:
...
> detect MITMs.  I don't have proof at this time.

To me, the definition of unique channel bindings in RFC 5056 implies it:
          +  unique channel bindings:

             channel bindings that name a channel in a cryptographically
             secure manner and uniquely in time;

If either endpoint (or a MITM!) could force a particular channel binding 
value, then that channel binding construction wouldn't "name a channel 
<...> uniquely in time".  A construction that didn't have large enough 
nonces from each endpoint wouldn't be cryptographically secure.  So, if 
its a unique channel binding, then endpoints can neither force a value nor 
reduce the entropy to an insecure level.

Or am I misinterpreting what "cryptographically secure" means there?

> that should be supported.)

Without channel binding _or_ security layers, the athenticated channel 
isn't protected from takeover and arbitrary replacement, right?  The only 
trustable fact would be the authentication itself, if that.  Seems like a 
pointless niche to me.

Philip Guenther

---

From: Nicolas Williams <[email-masked]>
Date: Thu, 31 Jan 2008 09:34:05 -0600

>          +  unique channel bindings:

To me it does as well.  Strongly implies, even.  I've not thought long
enough to decide that there's proof.

---

From: Nicolas Williams <[email-masked]>
Date: Thu, 31 Jan 2008 09:38:03 -0600

> trustable fact would be the authentication itself, if that.  Seems like a 

It's good enough for some valid threat models.  I think we'll end up
having it.  But yeah, _I_ would always want to use channel binding to
TLS or SASL security layers, not neither.

Date: Thu, 31 Jan 2008 09:38:03 -0600
From: Nicolas Williams <[email-masked]>
To: Philip Guenther <[email-masked]>
Cc: [email-masked]
Subject: Re: SCRAM and YAP
Mail-Followup-To: Philip Guenther <[email-masked]>, [email-masked]
Sender: [email-masked]

> trustable fact would be the authentication itself, if that.  Seems like a 

It's good enough for some valid threat models.  I think we'll end up
having it.  But yeah, _I_ would always want to use channel binding to
TLS or SASL security layers, not neither.

Date: Thu, 31 Jan 2008 09:34:05 -0600
From: Nicolas Williams <[email-masked]>
To: Philip Guenther <[email-masked]>
Cc: [email-masked]
Subject: Re: SCRAM and YAP
Mail-Followup-To: Philip Guenther <[email-masked]>, [email-masked]
Sender: [email-masked]

Date: Thu, 31 Jan 2008 10:40:00 +0100
From: Arnt Gulbrandsen <[email-masked]>
To: [email-masked]
Subject: Re: SCRAM with(out) GS2 (was Re: Holding gs2)
Cc: Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Nicolas Williams <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Sender: [email-masked]

Nicolas Williams writes:
> We can deal with this, and we've already agreed to, by providing two 
> descriptions of the mechanism, one without reference to the GSS-API 
> nor GS2, and one with.

That's the plan. Whether the plan is good is another question.

> The simplified GS2 option we've been discussing would make that task 
> much, much easier, and would make the design of SCRAM much simpler 
> also.

Simpler from the vantage point of most WG members. Not simpler to learn 
and to implement for the people I really care about: Those who have 
Cram-MD5 or Digest-MD5 today, and who I want to implement SCRAM.

Arnt

Date: Wed, 30 Jan 2008 23:08:28 -0700
From: Philip Guenther <[email-masked]>
To: Nicolas Williams <[email-masked]>
cc: [email-masked]
Subject: Re: SCRAM and YAP
Sender: [email-masked]

Philip Guenther

Date: Wed, 30 Jan 2008 15:36:15 -0600
From: Nicolas Williams <[email-masked]>
To: Jeffrey Hutzelman <[email-masked]>
Cc: Arnt Gulbrandsen <[email-masked]>, [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Subject: Re: SCRAM with(out) GS2 (was Re: Holding gs2)
Mail-Followup-To: Jeffrey Hutzelman <[email-masked]>, Arnt Gulbrandsen <[email-masked]>, [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Sender: [email-masked]

On Wed, Jan 30, 2008 at 04:28:19PM -0500, Jeffrey Hutzelman wrote:
> --On Wednesday, January 30, 2008 02:55:53 PM -0600 Nicolas Williams 
> <[email-masked]> wrote:
> >Frankly, the more I think about it the more I just want to get rid of
> >the security layers.  Simon?  Others?
> 
> I'm actually beginning to believe that security layers were never the right 
> answer in the first place -- all we ever really needed was channel bindings.

I've known that for a while :)

The problem is we don't get to go back in time, and it may take time to
get folks to deploy TLS libraries that make CBs available.

Nico
-- 

Date: Wed, 30 Jan 2008 16:28:19 -0500
From: Jeffrey Hutzelman <[email-masked]>
To: Nicolas Williams <[email-masked]>, Arnt Gulbrandsen <[email-masked]>, [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
cc: [email-masked]
Subject: Re: SCRAM with(out) GS2 (was Re: Holding gs2)
Sender: [email-masked]

--On Wednesday, January 30, 2008 02:55:53 PM -0600 Nicolas Williams 
<[email-masked]> wrote:

>
> On Wed, Jan 30, 2008 at 10:22:09AM -0600, Nicolas Williams wrote:
>> Thus I am strongly in favor of at least adding the channel-binding-only
>> option to GS2.  I am also leaning towards being in favor of removing
>> support for security layers and security layer negotiation from GS2 as
>> well -- that would another significant simplification.  On the latter
>> point I'd like to hear from Simon and others whether they are OK with
>> GS2 (GS3, whatever) mechanisms not providing any security layers.
>
> Frankly, the more I think about it the more I just want to get rid of
> the security layers.  Simon?  Others?

I'm actually beginning to believe that security layers were never the right 
answer in the first place -- all we ever really needed was channel bindings.

Date: Wed, 30 Jan 2008 15:14:46 -0600
From: Nicolas Williams <[email-masked]>
To: [email-masked]
Subject: SCRAM and YAP
Mail-Followup-To: [email-masked]
Sender: [email-masked]

Nico
-- 

Date: Wed, 30 Jan 2008 14:55:53 -0600
From: Nicolas Williams <[email-masked]>
To: Arnt Gulbrandsen <[email-masked]>, [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Subject: Re: SCRAM with(out) GS2 (was Re: Holding gs2)
Mail-Followup-To: Arnt Gulbrandsen <[email-masked]>, [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Sender: [email-masked]

On Wed, Jan 30, 2008 at 10:22:09AM -0600, Nicolas Williams wrote:
> Thus I am strongly in favor of at least adding the channel-binding-only
> option to GS2.  I am also leaning towards being in favor of removing
> support for security layers and security layer negotiation from GS2 as
> well -- that would another significant simplification.  On the latter
> point I'd like to hear from Simon and others whether they are OK with
> GS2 (GS3, whatever) mechanisms not providing any security layers.

Frankly, the more I think about it the more I just want to get rid of
the security layers.  Simon?  Others?

Date: Wed, 30 Jan 2008 10:22:09 -0600
From: Nicolas Williams <[email-masked]>
To: Arnt Gulbrandsen <[email-masked]>
Cc: [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Subject: Re: SCRAM with(out) GS2 (was Re: Holding gs2)
Mail-Followup-To: Arnt Gulbrandsen <[email-masked]>, [email-masked], Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Sender: [email-masked]

On Wed, Jan 30, 2008 at 12:21:08PM +0100, Arnt Gulbrandsen wrote:
> Chris Newman writes:
> >I would personally have no problem implementing an all-binary SCRAM 
> >regardless of how ugly the ASN.1 and binary encoding happens to be 
> >(it just requires more lines of parsing code since I have to include 
> >all the binary->text logic for debugging).
> 
> My two cents: I want SCRAM as a replacement for Digest-MD5 and to some 
> degree Cram-MD5. That may not be a good reason, but it's mine, and I 
> worry that GS2 hurts rather than helps.
> 
> As I see it, the people I want to implement SCRAM have Cram-MD5 and/or 
> (bad) Digest-MD5 implementations, and most of them don't have 
> GSS-API/GS2 implementations. For these people, basing SCRAM on GS2 
> means that they must read and understand more RFC text and their 
> implementations will be more complex. Chris has no problem with that, 
> but I fear that many people do. More text to read and understand means 
> a greater reluctance to implement, and in turn a slower pace of 
> adoption. More complexity means worse interoperation.

We can deal with this, and we've already agreed to, by providing two
descriptions of the mechanism, one without reference to the GSS-API nor
GS2, and one with.

The simplified GS2 option we've been discussing would make that task
much, much easier, and would make the design of SCRAM much simpler also.

Thus I am strongly in favor of at least adding the channel-binding-only
option to GS2.  I am also leaning towards being in favor of removing
support for security layers and security layer negotiation from GS2 as
well -- that would another significant simplification.  On the latter
point I'd like to hear from Simon and others whether they are OK with
GS2 (GS3, whatever) mechanisms not providing any security layers.

Nico
-- 

Date: Wed, 30 Jan 2008 12:21:08 +0100
From: Arnt Gulbrandsen <[email-masked]>
To: [email-masked]
Subject: SCRAM with(out) GS2 (was Re: Holding gs2)
Cc: Alexey Melnikov <[email-masked]>, Chris Newman <[email-masked]>, Nicolas Williams <[email-masked]>, Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>
Sender: [email-masked]

Chris Newman writes:
> I would personally have no problem implementing an all-binary SCRAM 
> regardless of how ugly the ASN.1 and binary encoding happens to be 
> (it just requires more lines of parsing code since I have to include 
> all the binary->text logic for debugging).

My two cents: I want SCRAM as a replacement for Digest-MD5 and to some 
degree Cram-MD5. That may not be a good reason, but it's mine, and I 
worry that GS2 hurts rather than helps.

As I see it, the people I want to implement SCRAM have Cram-MD5 and/or 
(bad) Digest-MD5 implementations, and most of them don't have 
GSS-API/GS2 implementations. For these people, basing SCRAM on GS2 
means that they must read and understand more RFC text and their 
implementations will be more complex. Chris has no problem with that, 
but I fear that many people do. More text to read and understand means 
a greater reluctance to implement, and in turn a slower pace of 
adoption. More complexity means worse interoperation.

Arnt

Date: Tue, 29 Jan 2008 15:26:05 -0600
From: Nicolas Williams <[email-masked]>
To: Chris Newman <[email-masked]>
Cc: Alexey Melnikov <[email-masked]>, Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Mail-Followup-To: Chris Newman <[email-masked]>, Alexey Melnikov <[email-masked]>, Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>, [email-masked]
Sender: [email-masked]

On Tue, Jan 29, 2008 at 12:16:36PM -0700, Chris Newman wrote:
> Speaking as a technical participant only...
> 
> As a SASL implementer, it is my current intention to not implement the 
> "security layer" feature of SASL.  If I implement GS2, my implementation 
> will always negotiate the GS2 security layer off and will use SSL/TLS 
> channel bindings if there's any reasonable way I can get that working with 
> the Mozilla/NSS library.

Most SASL apps have StartTLS or TLS port options.  I'm inclined to
believe that most SASL implementors would prefer to just do channel
binding to TLS when you want security layers.

So I'm now inclined to believe that Sam is right: we may have gone
overboard with GS2.

The only question left for me then is this: does anyone actually want
SASL security layers with any new mechanisms, or with the replacement
for "GSSAPI"?

If the answer is "noone does" then I say we scrap GS2 and do a new thing
based on GSS-API channel binding semantics and no security layers.

If the answer is "some do" (e.g., Simon), then I think we may want a
light-weight GS2 option, for use when no security layers are desired.

> However, I only plan to implement GS2 if it provides value above the GSSAPI 
> mechanism -- that means it's only worth implementing to me if there are 
> clients that support the combination of GS2, Kerberos 5 and SSL/TLS channel 
> bindings.

OK.  To be sure there exist plenty of protocols that use both, TLS and
SASL.  What doesn't necessarily exist is support for extracting channel
bindings from TLS libraries.

> I would personally have no problem implementing an all-binary SCRAM 
> regardless of how ugly the ASN.1 and binary encoding happens to be (it just 
> requires more lines of parsing code since I have to include all the 
> binary->text logic for debugging).  However, textual protocols are easier 
> to debug, easier to understand and thus easier to deploy.  I'd be concerned 
> about the real-world deployability of an all-binary SCRAM.

Well, ciphertext and MACs won't look like text...  Password-based SASL
mechs with channel binding would make relatively little use of crypto on
the wire -- just some HMACs.  So you might be able to get your wish.

Nico
-- 

Date: Tue, 29 Jan 2008 12:16:36 -0700
From: Chris Newman <[email-masked]>
Subject: Re: Holding gs2
To: Nicolas Williams <[email-masked]>, Alexey Melnikov <[email-masked]>
Cc: Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>, [email-masked]
Sender: [email-masked]

Nicolas Williams wrote on 1/28/08 9:59 -0600:
> Sam is proposing SASL mechanisms that support channel binding but not
> any security layers, which effectively changes the semantics of channel
> binding that we had assumed/concluded we wanted.  This change can
> greatly simplify the design of future SASL mechanisms, and it can
> greatly simplify the design of a SASL/GSS bridge for GSS mechanisms that
> support channel binding.

Speaking as a technical participant only...

As a SASL implementer, it is my current intention to not implement the 
"security layer" feature of SASL.  If I implement GS2, my implementation will 
always negotiate the GS2 security layer off and will use SSL/TLS channel 
bindings if there's any reasonable way I can get that working with the 
Mozilla/NSS library.

However, I only plan to implement GS2 if it provides value above the GSSAPI 
mechanism -- that means it's only worth implementing to me if there are clients 
that support the combination of GS2, Kerberos 5 and SSL/TLS channel bindings.

I would personally have no problem implementing an all-binary SCRAM regardless 
of how ugly the ASN.1 and binary encoding happens to be (it just requires more 
lines of parsing code since I have to include all the binary->text logic for 
debugging).  However, textual protocols are easier to debug, easier to 
understand and thus easier to deploy.  I'd be concerned about the real-world 
deployability of an all-binary SCRAM.

                - Chris

Date: Mon, 28 Jan 2008 17:29:22 -0600
From: Nicolas Williams <[email-masked]>
To: Simon Josefsson <[email-masked]>
Cc: Sam Hartman <[email-masked]>, [email-masked]
Subject: Re: What am I waiting on for gs2?
Mail-Followup-To: Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>, [email-masked]
Sender: [email-masked]

I support this change as well, modulo the what-do-we-do-about-Sam's-
comment thread.

We may still decide to make more changes to gs2.

What would gs2 with an option to support channel-binding-but-no-sec-
layers mechanisms?

I think the packet format would change from this:

                           1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                             length                            |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                                                               /
      /                      GSS_Init_sec_context or                  /
      /                   GSS_Accept_sec_context token,               /
      /                     of given length                           /
      /                                           --------------------/
      /                     ---------------------/                    /
      /--------------------/                                          /
      /                              Optional GSS_Wrap token          /
      /                                                               /
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

to this for the initial one (and, if we want to simplify the spec, for
all of them):

                           1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |                             length                            |
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
      |<gss-channel-binding-in-use>[<authzid>]                        |
      /                                           --------------------/
      /                     ---------------------/                    /
      /--------------------/                                          /
      |                                                               /
      /                      GSS_Init_sec_context or                  /
      /                   GSS_Accept_sec_context token,               /
      /                     of given length                           /
      /                                           --------------------/
      /                     ---------------------/                    /
      /--------------------/                                          /
      /                              Optional GSS_Wrap token          /
      /                                                               /
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Where, if gss-channel-binding-in-use == TRUE then <authzid> is present
and the optional GSS_Wrap token is absent on this and all subsequent
context token exchange packets.  If gss-channel-binding-in-use == FALSE
then everything is just as it used to be.

If gss-channel-binding-in-use == TRUE then the client and the server
MUST both construct the GSS-API channel bindings from the actual channel
bindings passed in by the application and the authzid as well.  Channel
binding failure is critical in the GSS-API, so if channel binding fails
then SASL authentication fails.

gss-channel-binding-in-use can be a single octet, and authzid can be
NUL-terminated UTF-8.  The packet marshalling and unmarshalling is easy
then.  And the channel bindings can be the NUL-terminated authzid in
UTF-8 with the actual channel bindings appended.

Nico
-- 

Date: Mon, 28 Jan 2008 17:32:00 -0500
From: Jeffrey Hutzelman <[email-masked]>
To: Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>
cc: [email-masked], [email-masked]
Subject: Re: What am I waiting on for gs2?
Sender: [email-masked]

--On Thursday, December 20, 2007 05:52:18 PM +0100 Simon Josefsson 
<[email-masked]> wrote:

> I support the change below.  Others?

I support the addition of a security layer bit to indicate channel binding 
negotiation failed, as described in the change in question.

However, the diff you provided also makes a second change, whose effect is 
to number bits with bit '0' being the least-significant bit rather than the 
most-significant bit, as is the convention used in the RFC Series.  Please 
see ID-Checklist section 2.1 item 9, and draft-rfc-editor-rfc2223bis-08.txt 
section 3.4.

-- Jeff

Date: Mon, 28 Jan 2008 09:59:52 -0600
From: Nicolas Williams <[email-masked]>
To: Alexey Melnikov <[email-masked]>
Cc: Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Mail-Followup-To: Alexey Melnikov <[email-masked]>, Simon Josefsson <[email-masked]>, Sam Hartman <[email-masked]>, [email-masked]
Sender: [email-masked]

On Sun, Jan 27, 2008 at 06:27:47PM +0000, Alexey Melnikov wrote:
> I consider reduction of round-trips as the main goal of GS2.

But it doesn't quite meet that goal.  It can cost an extra half
round-trip for some mechanisms, IIRC.  (If your krb5 mech initiator
implementation doesn't support PORT_READY then it can even cost you an
extra half round-trip when using krb5.)

(Of course, channel binding alone can cost you an extra half round-trip
-- think of krb5 w/o mutual authentication: to add channel binding you
must do mutual auth, which means 1 round-trip instead of half.)

However, Sam's objection is not about round-trips, but about complexity
for implementors who wish SASL mechanisms but not GSS mechanisms: the
gs2 approach forces them to implement MIC tokens.

Sam is proposing SASL mechanisms that support channel binding but not
any security layers, which effectively changes the semantics of channel
binding that we had assumed/concluded we wanted.  This change can
greatly simplify the design of future SASL mechanisms, and it can
greatly simplify the design of a SASL/GSS bridge for GSS mechanisms that
support channel binding.

> How about publishing GS2 as Experimental RFC and move it (or replace it, 
> if errors are found) to Standard Track once we have some implementation 
> experience?

We could say that the channel binding semantics that gs2 provides are
experimental...

Or we could do (2b) as I suggested, and maybe profile gs2 for simple,
channel-binding-but-no-security-layers SASL mechanisms.  Or we could
pursue the latter as a separate thing altoghether and separately
describe a SASL/GSS bridge (gs2 extensions or gs3) with the same
properties.  I haven't yet thought enough about which approach will get
us there faster.

If we agree that we don't need any new SASL mechs to provide security
layers, and that we don't care for GSS mechanisms that don't support
channel binding, then we can even abandon gs2 and go for gs3 with a much
simpler design (using GSS-API channel bindings to do the channel binding
work and to protect the authzid -- no MIC tokens needed).

> >If I recall correctly, the use-case of hybrid SASL and GSS-API
> >mechanisms was established after we decided to do GS2.

Sam and I had been wanting a SASL/GSS bridge for a long time, and we
wanted channel binding to be a primary feature.  Sam now suggests that
we selected a channel binding semantic that was too complicated.

Nico
-- 

Date: Sun, 27 Jan 2008 18:33:20 +0000
From: Alexey Melnikov <[email-masked]>
To: Nicolas Williams <[email-masked]>
CC: Sam Hartman <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Sender: [email-masked]

Nicolas Williams wrote:

>OK, I've been thinking about this.
>
>I think we should:
>
>1) Formalize what a SASL mechanism that supports channel binding is.
>
>   This would be an update of RFC4322.
>  
>
 [...]

>2) Decide whether we want:
>
>   a) a new SASL/GSS framework which does not support security layers,
>      and which can be described in terms of GSS-API mechanisms that
>      support channel binding,
>
>   or
>
>   b) extend GS2 to do (a) but within the existing GS2 framework.
>
>      Let's say that (2b) means having a long-form GS2 message exchange
>      for some mechanisms or uses of them, and a short-form GS2 message
>      exchange for others.
>
>   c) We may also decided that we want to pursue a simple GSS-API
>      extension to always support GS2 short-form message exchanges where
>      GSS-API frameworks and mechanisms support that simple extension.
>
>      This simple extension would consist, I think, of a new req_flag,
>      GSS_C_CHANNEL_BINDING_REQ, for GSS_Init_sec_context() and two new
>      ret_flags for GSS_Init_sec_context() and GSS_Accept_sec_context().
>      The req_flag would indicate that the caller wants to know if: a)
>      channel binding is supported by the mechanism, b) this extension
>      is supported, c) whether channel binding succeeds.
>
>      When this req_flag is used and the initiator and acceptor
>      framework and mechanism support this extension then a) channel
>      binding failure does not result in context establishment failuer,
>      b) the new ret_flags are set as follows: GSS_C_CHANNEL_NOT_BOUND
>      is set if channel binding failed, else GSS_C_CHANNEL_BOUND is set.
>  
>
 [...]

>I propose that we adopt (1) and (2b) as the simplest, yet general
>solutions.
>
>New, pure SASL mechanisms that provide channel binding but no security
>layers can then be described that: a) need not be GSS-API mechanisms, b)
>can nonetheless be implemented as SASL/GS2 mechanisms, and c) sport the
>short-form message exchange.
>  
>
Agreed.

I am all in favor of (1). Regarding various (2) choices: I prefer 2b or 2c.

Date: Sun, 27 Jan 2008 18:27:47 +0000
From: Alexey Melnikov <[email-masked]>
To: Simon Josefsson <[email-masked]>
CC: Sam Hartman <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Sender: [email-masked]

Simon Josefsson wrote:

>Sam Hartman <[email-masked]> writes:
>  
>
>>>>>>>"Simon" == Simon Josefsson <[email-masked]> writes:
>>>>>>>              
>>>>>>>
>>    Simon> Sam Hartman <[email-masked]> writes:
>>    >> I have a question for the SASL working group.  With the
>>    >> exception of the question I brought up about optimal round
>>    Simon> I fear this would delay GS2 implementations for Kerberos
>>    Simon> V5, which would give us useful feedback on other aspects of
>>    Simon> the document.
>>    
>>
I have to admit that I share some of the concerns raised by Steve.
I think it would be nice to go through SCRAM-as-GSS-API-mechanism 
exercise before publishing GS2. However I do understand that delaying 
GS2 because of SCRAM might not be fair for people who want to try 
implement GS2.

>>Are there any implementers of SASL or Kerberos stacks who plan to delay?
>>    
>>
>I have started to implement GS2 twice to test the Kerberos V5 reduced
>round-trip mode.  The protocol kept changing, even after passing WGLC,
>so I postponed those efforts pending a stable draft.  I recently planned
>to resume work on GS2 during February, but this discussion suggests to
>me that I need to wait longer.  Publishing GS2, with the limited
>applicability for Kerberos would move my effort forward.
>
>I'd be interested in understanding how other implementers think about
>this too.
>  
>
I [still] plan to implement GS2 once it is stable. But I am unlikely to 
be quicker than you in doing that, due to other commitments.

>I don't see why having three mechanisms to do the same is problematic.
>Ok, it does lead to complexity, but supposedly the complexity is
>_required_ in order to solve some identified problem.  GS2 solves the
>identified problem of unnecessary many round-trips compared to Kerberos
>V5 via GSS-API.  If we don't consider that a valid problem, we should
>say that GS2 should not be used with Kerberos V5 at all,
>
I consider reduction of round-trips as the main goal of GS2.

>and instead say
>that users should use GSS-API for this.  That approach would take away
>all the complexity for Kerberos in GS2.  If we go this route, I would
>support delaying publication of GS2 until we have specifications of the
>GSS-API mechanisms that were designed with GS2 in mind.
>  
>
How about publishing GS2 as Experimental RFC and move it (or replace it, 
if errors are found) to Standard Track once we have some implementation 
experience?

>If I recall correctly, the use-case of hybrid SASL and GSS-API
>mechanisms was established after we decided to do GS2.
>  
>

Date: Sun, 27 Jan 2008 18:15:22 +0000
From: Alexey Melnikov <[email-masked]>
To: Simon Josefsson <[email-masked]>
CC: Sam Hartman <[email-masked]>, [email-masked]
Subject: Re: What am I waiting on for gs2?
Sender: [email-masked]

Simon Josefsson wrote:

>Sam Hartman <[email-masked]> writes:
>  
>
>>However if the WG doesn't have consensus behind this change then it
>>should be backed out.
>>
>I support the change below.  Others?
>  
>
I support it as well.

Date: Fri, 25 Jan 2008 09:21:57 -0600
From: Nicolas Williams <[email-masked]>
To: Sam Hartman <[email-masked]>
Cc: [email-masked]
Subject: Re: Holding gs2
Mail-Followup-To: Sam Hartman <[email-masked]>, [email-masked]
Sender: [email-masked]

OK, I've been thinking about this.

I think we should:

1) Formalize what a SASL mechanism that supports channel binding is.

   This would be an update of RFC4322.

   SASL mechanisms that support channel binding are SASL mechanisms
   whose client and server init/step functions take the following
   additional input parameters:

    - channel binding
    - security layers to be negotiated if channel binding succeeds

   and which perform the channel binding operation as part of the
   mechanism's authentication exchanges.  The security layers selected
   will be either the regular security layers as provided through the
   traditional inputs to these functions (if channel binding fails), or
   the second set of security layers input described above (if channel
   binding succeeds).

   This should suffice as guidance for anyone designing new SASL
   mechanisms that support channel binding.

   With a minor tweak such mechanisms can also be based on what I will
   call GS3 below.

Before I go on to (2) below, note that a SASL/GSS framework for GSS-API
mechanisms that support channel binding but where the framework will NOT
support any security layers is trivial: no MIC tokens are needed,
instead the client sends its initial token and authzid, with authzid ||
channel bindings as the GSS channel bindings, and thereafter it's a
normal, framed GSS-API context token exchange.

2) Decide whether we want:

   a) a new SASL/GSS framework which does not support security layers,
      and which can be described in terms of GSS-API mechanisms that
      support channel binding,

   or

   b) extend GS2 to do (a) but within the existing GS2 framework.

      Let's say that (2b) means having a long-form GS2 message exchange
      for some mechanisms or uses of them, and a short-form GS2 message
      exchange for others.

   c) We may also decided that we want to pursue a simple GSS-API
      extension to always support GS2 short-form message exchanges where
      GSS-API frameworks and mechanisms support that simple extension.

      This simple extension would consist, I think, of a new req_flag,
      GSS_C_CHANNEL_BINDING_REQ, for GSS_Init_sec_context() and two new
      ret_flags for GSS_Init_sec_context() and GSS_Accept_sec_context().
      The req_flag would indicate that the caller wants to know if: a)
      channel binding is supported by the mechanism, b) this extension
      is supported, c) whether channel binding succeeds.

      When this req_flag is used and the initiator and acceptor
      framework and mechanism support this extension then a) channel
      binding failure does not result in context establishment failuer,
      b) the new ret_flags are set as follows: GSS_C_CHANNEL_NOT_BOUND
      is set if channel binding failed, else GSS_C_CHANNEL_BOUND is set.

Let's consider (2b).

   If the application requests no security layers in the channel binding
   failure and success cases then:

   i) channel binding failure -> mechanism failure;

   ii) because of (i) the GSS-API channel semantics will match the SASL
       mechanism's channel binding semantics, therefore GS2 can use
       GSS-API channel bindings and dispense with the MIC token
       exchanges (i.e., GS2 short-form message exchange).

   If the application requests different security layers in the channel
   binding success and failure cases then GS2 must use the long-form
   message exchange.

Let's consider (2a).

   This would look just like the GS2 short-form message exchange
   described above, but would have a different SASL mechanism name
   prefix than GS2.

Let's consider (2c).

   In this case GS2 can automatically select which of the short-form and
   long-form message exchanges to execute based on the capabilities of
   the GSS-API framework and mechanism (on both, the initiator and
   acceptor sides).

I propose that we adopt (1) and (2b) as the simplest, yet general
solutions.

New, pure SASL mechanisms that provide channel binding but no security
layers can then be described that: a) need not be GSS-API mechanisms, b)
can nonetheless be implemented as SASL/GS2 mechanisms, and c) sport the
short-form message exchange.

New, pure SASL mechanisms that provide channel binding and optional
security layers will require the GS2 long-form message exchange (with
MIC tokens) when the application wishes to use security layers in the
case of channel binding failure, but will use the short form when the
applications requests no security layers in either case.

(1) and (2a) would be OK, of course.

(1) and (2c) would be the most general solution, but I wouldn't blame
the WG for not biting!

Nico
-- 

Date: Tue, 22 Jan 2008 09:57:23 -0600
From: Nicolas Williams <[email-masked]>
To: Sam Hartman <[email-masked]>
Cc: Jeffrey Hutzelman <[email-masked]>, Simon Josefsson <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Mail-Followup-To: Sam Hartman <[email-masked]>, Jeffrey Hutzelman <[email-masked]>, Simon Josefsson <[email-masked]>, [email-masked]
Sender: [email-masked]

On Tue, Jan 22, 2008 at 08:14:16AM -0500, Sam Hartman wrote:
> So, no I'm not convinced we know that gs2 can meet our needs.  Of
> course with my leave, we have a month before GS2 could progress
> anyway.  It would be really great if people could actually do the work
> of specifying the mechanism for GS2 during that month.
                ^^^^^^^^^^^^^^^^^^^^^

Which mechanism?

Nico
-- 

From: Simon Josefsson <[email-masked]>
To: Sam Hartman <[email-masked]>
Cc: [email-masked]
Subject: Re: Holding gs2
OpenPGP: id=B565716F; url=http://josefsson.org/key.txt
Date: Tue, 22 Jan 2008 15:53:08 +0100
Sender: [email-masked]

Sam Hartman <[email-masked]> writes:

>>>>>> "Simon" == Simon Josefsson <[email-masked]> writes:
>
>     Simon> Sam Hartman <[email-masked]> writes:
>     >> I have a question for the SASL working group.  With the
>     >> exception of the question I brought up about optimal round
>     Simon> I fear this would delay GS2 implementations for Kerberos
>     Simon> V5, which would give us useful feedback on other aspects of
>     Simon> the document.
>
> Are there any implementers of SASL or Kerberos stacks who plan to delay?

I have started to implement GS2 twice to test the Kerberos V5 reduced
round-trip mode.  The protocol kept changing, even after passing WGLC,
so I postponed those efforts pending a stable draft.  I recently planned
to resume work on GS2 during February, but this discussion suggests to
me that I need to wait longer.  Publishing GS2, with the limited
applicability for Kerberos would move my effort forward.

I'd be interested in understanding how other implementers think about
this too.

I don't see why having three mechanisms to do the same is problematic.
Ok, it does lead to complexity, but supposedly the complexity is
_required_ in order to solve some identified problem.  GS2 solves the
identified problem of unnecessary many round-trips compared to Kerberos
V5 via GSS-API.  If we don't consider that a valid problem, we should
say that GS2 should not be used with Kerberos V5 at all, and instead say
that users should use GSS-API for this.  That approach would take away
all the complexity for Kerberos in GS2.  If we go this route, I would
support delaying publication of GS2 until we have specifications of the
GSS-API mechanisms that were designed with GS2 in mind.

If I recall correctly, the use-case of hybrid SASL and GSS-API
mechanisms was established after we decided to do GS2.

/Simon

From: Sam Hartman <[email-masked]>
To: Jeffrey Hutzelman <[email-masked]>
Cc: Nicolas Williams <[email-masked]>, Simon Josefsson <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Date: Tue, 22 Jan 2008 08:14:16 -0500
Sender: [email-masked]

>>>>> "Jeffrey" == Jeffrey Hutzelman <[email-masked]> writes:

    Jeffrey> The main drawback to this approach is that it means GS2
    Jeffrey> can be used only with GSS-API mechanisms for which such
    Jeffrey> an AS exists.  That's fine if the only mechanisms are
    Jeffrey> standards-track base mechanisms, but things start to get
    Jeffrey> hairy if we want to allow for the use of stackable
    Jeffrey> mechanisms or of privately-defined mechanisms.  Of
    Jeffrey> course, whoever defines a private mechanism could also
    Jeffrey> specify GS2's applicability to that mechanism, at least
    Jeffrey> for anyone for which it matters.
I consider this a very significant drawback.

    Jeffrey> All of that being said, it seems that maybe we're
    Jeffrey> worrying too much.  Last I knew we had an effort underway
    Jeffrey> which it was hoped would produce a non-Kerberos GS2
    Jeffrey> mechanism.  Whether that actually materializes or not, I
    Jeffrey> think we have basically worked out what it needs to look
    Jeffrey> like to work with GS2.  Do we believe that is not
    Jeffrey> sufficient to demonstrate that GS2 can successfully be

I am unconvinced we understand how to apply GS2 to mechanisms beyond
kerberos in a manner such that those mechanisms can easily be coded as
pure sasl mechanisms.  I'm concerned about unnecessary optional
exchanges and complicated control flow.

I suspect that Chris and others will not like the result if using gs2
complicates the potential control flows, adds variable round trips,
etc.

So, no I'm not convinced we know that gs2 can meet our needs.  Of
course with my leave, we have a month before GS2 could progress
anyway.  It would be really great if people could actually do the work
of specifying the mechanism for GS2 during that month.

Date: Mon, 21 Jan 2008 23:35:32 -0500
From: Jeffrey Hutzelman <[email-masked]>
To: Nicolas Williams <[email-masked]>, Sam Hartman <[email-masked]>
cc: Simon Josefsson <[email-masked]>, [email-masked], [email-masked]
Subject: Re: Holding gs2
Sender: [email-masked]

--On Monday, January 21, 2008 10:00:31 PM -0600 Nicolas Williams 
<[email-masked]> wrote:

>  - additional mechanisms based on GS2 can be published as trivial RFCs
>    (requiring IESG protocol action)

I started out agreeing with Sam that limiting GS2 to Kerberos and starting 
over again with "GS3" or whatever was a bad idea, for several reasons.

However, the more I think about this, the more I think that it might not 
actually be necessary to have a fully generic bridge that can be applied to 
any mechanism.  The original goal in doing so was to make sure that it 
would be possible to use SASL not only with existing GSS-API mechanisms but 
also with any new ones that happened to come along.  Achieving that goal 
does not require universal applicability for GS2.  All that is required is 
that when a new GSS-API mechanism is produced which is intended to be used 
with GSS-API, an applicability statement is published (possibly in the same 
document as the new mechanism) which describes GS2's applicability to the 
new mechanism.

The main drawback to this approach is that it means GS2 can be used only 
with GSS-API mechanisms for which such an AS exists.  That's fine if the 
only mechanisms are standards-track base mechanisms, but things start to 
get hairy if we want to allow for the use of stackable mechanisms or of 
privately-defined mechanisms.  Of course, whoever defines a private 
mechanism could also specify GS2's applicability to that mechanism, at 
least for anyone for which it matters.

All of that being said, it seems that maybe we're worrying too much.  Last 
I knew we had an effort underway which it was hoped would produce a 
non-Kerberos GS2 mechanism.  Whether that actually materializes or not, I 
think we have basically worked out what it needs to look like to work with 
GS2.  Do we believe that is not sufficient to demonstrate that GS2 can 
successfully be applied to mechanisms beyond Kerberos?

-- Jeff

Date: Mon, 21 Jan 2008 22:00:31 -0600
From: Nicolas Williams <[email-masked]>
To: Sam Hartman <[email-masked]>
Cc: Simon Josefsson <[email-masked]>, [email-masked]
Subject: Re: Holding gs2
Mail-Followup-To: Sam Hartman <[email-masked]>, Simon Josefsson <[email-masked]>, [email-masked]
Sender: [email-masked]

On Mon, Jan 21, 2008 at 06:24:48PM -0500, Sam Hartman wrote:
> Simon> How about a compromise: publish GS2 soon but specify that
> Simon> it is ONLY to be used with Kerberos V5, i.e., the
> Simon> GS2-QLJHGJLWNPLMQRNK mechanism.  [...]

Sam> I think this is a really bad idea.  It could get us into a situation
Sam> where we have three standards for kerberos and SASL.  Or where we have
Sam> mechanisms that you should not use with GS2 other than negotiation
Sam> mechanisms.  That seems like a bad idea to me.

Well, you opened the can when you suggested delaying publication in the
first place...  :/

I seem to recall you (and others) wishing we could achieve channel
binding [and security layer negotiation] in fewer messages, which we
could do and still have a SASL/GSS bridge if we spent the time on
suitable GSS-API extensions or if we'd abandanded the SASL/GSS bridge
idea.  Were you indirectly suggesting this when you wrote this:

Sam> >                            [...].  I just think it would be better to
Sam> > hold that document until we get a mechanism that is both a GSS and
Sam> > SASL mechanism or we conclude that doesn't work for us.

?

While I agree with the sentiment, if we have implementors who would ship
an implementation in less time than it would take us to re-design GS2,
then I think it's just too late.  There are good reasons why we went
with this design, and we were aware of the trade-offs then.  What, if
anything, has changed to warrant re-designing GS2?

If we really must then I'd offer the following compromise, similar to
Simon's:

 - update RFC4422 to add a normative description of GS2 channel binding
   semantics (actually, we should do this anyways!)

 - limit GS2 to the Kerberos V mechanism

 - additional mechanisms based on GS2 can be published as trivial RFCs
   (requiring IESG protocol action)

 - additional mechanisms with GS2 channel binding semantics but fewer
   messages can also be published, perhaps as a GS3 if we suitably
   extend the GSS-API, or else not generalized (except for the update to
   RFC4422, see above).

If we ever decide that GS2 is good enough then we can update it to say
that any GSS-API mechanism (except SPNEGO...) can be used as a GS2
mechanism without further IESG protocol action.

But first I'd like to see whether, given our AD's doubts, we have WG
consensus to do anything other than forward GS2 to the IESG as is.
Then, if we decide to not forward it as it, we can see if we have
consensus for Sam's approach or Simon's, or something else.

Nico
-- 

From: Sam Hartman <[email-masked]>
To: Simon Josefsson <[email-masked]>
Cc: [email-masked]
Subject: Re: Holding gs2
Date: Mon, 21 Jan 2008 18:24:48 -0500
Sender: [email-masked]

>>>>> "Simon" == Simon Josefsson <[email-masked]> writes:

    Simon> Sam Hartman <[email-masked]> writes:
    >> I have a question for the SASL working group.  With the
    >> exception of the question I brought up about optimal round
    Simon> I fear this would delay GS2 implementations for Kerberos
    Simon> V5, which would give us useful feedback on other aspects of
    Simon> the document.

Are there any implementers of SASL or Kerberos stacks who plan to delay?

    Simon> How about a compromise: publish GS2 soon but specify that
    Simon> it is ONLY to be used with Kerberos V5, i.e., the
    Simon> GS2-QLJHGJLWNPLMQRNK mechanism.  This will lead to
    Simon> implementation experience for this particular use of GS2,
    Simon> while making it possible to make changes that are relevant
    Simon> for non-Kerberos mechanisms, when such experience has
    Simon> established itself.

I think this is a really bad idea.  It could get us into a situation
where we have three standards for kerberos and SASL.  Or where we have
mechanisms that you should not use with GS2 other than negotiation
mechanisms.  That seems like a bad idea to me.

From: Simon Josefsson <[email-masked]>
To: Tom Yu <[email-masked]>
Cc: [email-masked]
Subject: Re: IETF70 SASL summary
OpenPGP: id=B565716F; url=http://josefsson.org/key.txt
Date: Sat, 19 Jan 2008 15:39:53 +0100
Sender: [email-masked]

Tom Yu <[email-masked]> writes:

>>>>>> "Simon" == Simon Josefsson <[email-masked]> writes:
>
> Simon> Tom Yu <[email-masked]> writes:
>>> Simon Josefsson has indicated he is not interested in purusing his
>>> password-based mech draft at this time
>
> Simon> Just to clarify: I will pursue the draft (implementing it now, the draft
> Simon> will change a lot), but due to lack of interest (I haven't seen any
> Simon> feedback), it won't include the SASL/GS2 mappings.  The document will be
> Simon> a strict password-based GSS-API mechanism.
>
> Do you intend for the SASL WG to continue considering this document,
> or are you going to pursue it in Kitten rather than in SASL?  Also, I
> believe that during SASL charter discussion, we had agreement that the
> WG will attempt to produce a password-based mechanism that is a valid
> GS2 mechanism, so there is interest in a mechanism that is valid both
> as a GSS-API mechanism and as a SASL mechanism.
>
> If you do intend for it to continue to be considered within SASL, I
> would like to make sure that people have adequately considered it in
> the context of our password-based mech charter goal.

I did intend for my proposal to be considered by the SASL WG, see:

http://article.gmane.org/gmane.ietf.kitten/1291

Whether the work is actually done in the SASL WG, the Kitten WG, or
elsewhere, seems less important to me.  Alas, I haven't had much time to
improve the document since my initial post of it, though.

What I need is a secure GSS-API mechanism for password authentication;
using it under GS2 was a secondary goal.

I may have missed them, but are there any other concrete proposals for
password based GSS-API mechanisms?

/Simon

From: Simon Josefsson <[email-masked]>
To: Sam Hartman <[email-masked]>
Cc: [email-masked]
Subject: Re: Holding gs2
OpenPGP: id=B565716F; url=http://josefsson.org/key.txt
Date: Sat, 19 Jan 2008 15:28:13 +0100
Sender: [email-masked]

Sam Hartman <[email-masked]> writes:

> I have a question for the SASL working group.  With the exception of
> the question I brought up about optimal round trips, GS2 seems ready
> to last call.
>
>
> However I'd like to ask the WG to consider whether it really wants to send GS2 on its way now.
>
> I think it may be better to hold GS2 until we get experience with a
> SASL+GSS mechanism.  I'd hate for that effort to fail because we are
> unable to make some small change in GS2.
>
> If the WG believes that sending GS2 on its way now is the best thing
> to do I (or my successor) can send it to ietf last call after we
> finish discussion on my comments.  I just think it would be better to
> hold that document until we get a mechanism that is both a GSS and
> SASL mechanism or we conclude that doesn't work for us.

I fear this would delay GS2 implementations for Kerberos V5, which would
give us useful feedback on other aspects of the document.

How about a compromise: publish GS2 soon but specify that it is ONLY to
be used with Kerberos V5, i.e., the GS2-QLJHGJLWNPLMQRNK mechanism.
This will lead to implementation experience for this particular use of
GS2, while making it possible to make changes that are relevant for
non-Kerberos mechanisms, when such experience has established itself.

The GS2 document could later be updated with the fixes needed for
non-Kerberos V5 mechanisms, and say that a bunch of other SASL
mechanisms names are now permitted.

I think how GS2 will work with Kerberos V5 is well understood, since it
has been the only practical example to think about when we designed GS2.
So if there mistakes relevant to Kerberos V5 in GS2, I don't believe we
can hope to find them without implementation feedback at this stage.

The only problem would be if we need to change something in GS2 that
would affect how Kerberos V5 exchanges behave.  That would be
interesting.  If that happens, as a worst scenario, it is always
possible to call the revised protocol GS3 and have it say that if you
use Kerberos V5, you need to use GS2-* instead.  Unless there are
security issues in GS2, then we would need to revise it anyway, in
possible backwards incompatible ways.

What do people think?

/Simon

From: Sam Hartman <[email-masked]>
To: [email-masked]
Subject: Holding gs2
Date: Wed, 16 Jan 2008 19:18:48 -0500
Sender: [email-masked]

I have a question for the SASL working group.  With the exception of
the question I brought up about optimal round trips, GS2 seems ready
to last call.

However I'd like to ask the WG to consider whether it really wants to send GS2 on its way now.

I think it may be better to hold GS2 until we get experience with a
SASL+GSS mechanism.  I'd hate for that effort to fail because we are
unable to make some small change in GS2.

If the WG believes that sending GS2 on its way now is the best thing
to do I (or my successor) can send it to ietf last call after we
finish discussion on my comments.  I just think it would be better to
hold that document until we get a mechanism that is both a GSS and
SASL mechanism or we conclude that doesn't work for us.

--Sam

To: [email-masked]
Subject: draft SASL IETF70 minutes uploaded
From: Tom Yu <[email-masked]>
Date: Fri, 04 Jan 2008 01:05:50 -0500
Lines: 2
Sender: [email-masked]

I've uploaded draft SASL WG session minutes for IETF70 to the meeting
materials site.  Please reply with corrections, etc.

To: Simon Josefsson <[email-masked]>
Cc: [email-masked]
Subject: Re: IETF70 SASL summary
From: Tom Yu <[email-masked]>
Date: Thu, 03 Jan 2008 18:41:14 -0500
Lines: 23
Sender: [email-masked]

>>>>> "Simon" == Simon Josefsson <[email-masked]> writes:

Simon> Tom Yu <[email-masked]> writes:
>> Simon Josefsson has indicated he is not interested in purusing his
>> password-based mech draft at this time

Simon> Just to clarify: I will pursue the draft (implementing it now, the draft
Simon> will change a lot), but due to lack of interest (I haven't seen any
Simon> feedback), it won't include the SASL/GS2 mappings.  The document will be
Simon> a strict password-based GSS-API mechanism.

Do you intend for the SASL WG to continue considering this document,
or are you going to pursue it in Kitten rather than in SASL?  Also, I
believe that during SASL charter discussion, we had agreement that the
WG will attempt to produce a password-based mechanism that is a valid
GS2 mechanism, so there is interest in a mechanism that is valid both
as a GSS-API mechanism and as a SASL mechanism.

If you do intend for it to continue to be considered within SASL, I
would like to make sure that people have adequately considered it in
the context of our password-based mech charter goal.

---Tom

To: Alexey Melnikov <[email-masked]>
Cc: [email-masked]
Subject: Re: new milestones for charter update
From: Tom Yu <[email-masked]>
Date: Thu, 03 Jan 2008 18:12:47 -0500
Lines: 12
Sender: [email-masked]

>>>>> "Alexey" == Alexey Melnikov <[email-masked]> writes:

Alexey> But I would really like to have more or less solid SCRAM
Alexey> document before we obsolete DIGEST-MD5.

How solid does the DIGEST-MD5 successor document need to be?  Does
anyone else believe that we should delay publication of
digest-to-historic until we have a solid document for the DIGEST-MD5
successor?  I would prefer to not introduce more dependencies than
absolutely necessary.

---Tom