Subject: Re: [webfinger] [apps-discuss] Mail client configuration via WebFinger

From: Marten Gajda <[email-masked]>
Date: Wed, 01 Jun 2016 15:59:58 +0200

Hi Paul,

we've brought up this topic during the last CalConnect conference and it
was decided to revitalize the TC where the draft you mentioned
originated from. We have some interest from software vendors and users
to get this solved.

As mentioned before, one of the major problems to solve is
authentication. The issue raised was that the pure existence of a link
to a configuration document in the webfinger response can reveal the
existence of the account. On the other hand, requiring authentication
for auto configuration results in other possible security issues and a
poor user experience. The latter ones could probably be solved by making
OpenID Connect a requirement for auto configuration, which, on the other
hand, adds another layer of complexity and probably makes it less
attractive to smaller vendors.

Does anyone see any possible solution to that?

I'd also like to suggest a few changes in the structure of the
configuration document and to drop support for services not protected by
TLS or any other transport security layer. I'll post an updated draft as
a basis for discussion.

I'm happy to join the upcoming IEFT meeting in Berlin and have a BOF or
something if there is enough interest in that.

cheers

Marten

Am 09.02.2016 um 02:03 schrieb Paul E. Jones:
> Marten,
>
> Thanks for the encouraging words; it sounds like you understand the
> problem that needs to be solved.
>
> I always felt the server side was the trivial part.  As you said, it's
> possible to set up a simple WebFinger server with a static file (or
> sets of files), an .htaccess file, etc.  I use a server that pulls
> data from a database, myself.  Importantly, though, the WebFinger
> protocol is very simple (and I have to thank a number of folks who
> forced that simplicity), so I see the server side as being far less of
> a barrier.  Hosting providers, for example, could very quickly and
> easily support this server-side.
>
> The clients are the challenge.  As others have noted, this requires
> code changes in the clients and deployment of the clients.  I'm
> encouraged that you're working on client code. :)
>
> Having an RFC is going to be an extremely important step to actually
> seeing this problem solved.  That said, I did not want to spend time
> on something that would be met with total rejection.  It sounds like
> there is at least enough interest to start a meaningful dialog, so
> I'll try to put together a draft soon and we can go from there.  If
> you're interested to collaborate on that, you're certainly welcome.
>
> Paul
>
> ------ Original Message ------
> From: "Marten Gajda" <[email-masked]>
> To: [email-masked]
> Sent: 2/8/2016 5:54:58 PM
> Subject: Re: [webfinger] [apps-discuss] Mail client configuration via
> WebFinger
>
>> Hi Paul,
>>
>> as a client developer I'm very interested in this topic. We've
>> actually implemented draft-daboo-aggregated-service-discovery-03 and
>> there is at least one groupware server product which also supports it.
>>
>> While working on our implementation we've identified a few minor
>> issues with the latest draft and we've already discussed them with
>> Cyrus. I think most of these issues are solved easily.
>>
>> Though, the major issue has not been addressed yet. It's the issue
>> mentioned by Stephen. Under certain conditions a client might have to
>> ask the user upfront to authenticate, which may disclose the user's
>> credentials to the wrong service.
>>
>> We didn't release this feature in our generic CalDAV/CardDAV clients,
>> mostly due to that issue.
>>
>> Anyway, I think it really starts with the server developers.
>> Implementing the current spec is not that much work on the server
>> side. In many cases the server configuration document could just be a
>> static file and setting up a simple WebFinger end point is not that
>> hard either. Actually, for our corporate server we've just created a
>> few static files and some redirect magic in our .htaccess file to
>> provide the WebFinger stuff.
>>
>> On the client side it's more work, because it affects the account
>> setup flow a lot. But it surely is worth the efforts if more services
>> support it.
>>
>> However, before even the server developers can start, it requires an
>> RFC. So lets start to think about how to solve the authentication issue.
>>
>> cheers
>>
>> Marten
>>
>>
>> Am 08.02.2016 um 20:00 schrieb Paul E. Jones:
>>> Cyrus,
>>>
>>>> Right now it is not clear to me that an ASCOT-like solution would
>>>> be adopted given the use of device management. Before embarking on
>>>> this we need to take a careful look at whether any solution is
>>>> likely to be adopted (with the biggest burden likely being on
>>>> clients/OS vendors to support it). Given the device management
>>>> solutions already out there, I suspect there would be little value
>>>> to m,ost of those folks to actually support ASCOT.
>>>
>>> I completely agree that we should try to get a sense of the
>>> likelihood of success.
>>>
>>> Within the enterprise -- especially the larger ones -- you are
>>> entirely correct that device management systems provide a good
>>> solution for most of the employees.   However, I interact with a lot
>>> of smaller businesses that do not use such systems.  Many of them
>>> have a web hosting company host their domains and do not have IT
>>> staff to help them on a daily basis.  I'm skeptical that a device
>>> management system would help that class of users, so arming hosting
>>> providers with tools they can deploy to their customers would help,
>>> I think.
>>>
>>> There are also a number of individuals who have their own domains,
>>> many hosted on the many, many web hosting providers out there. Same
>>> issue for most of them.
>>>
>>> So, I think there is a market need.  I suspect if we were to create
>>> a solution, hosting providers were to deploy it, and client
>>> developers were to support it, people would use it.  However, that's
>>> a string of "ifs".  I think it starts with the client developers. 
>>> If there were people interested to solve the problem, I think the
>>> rest falls into place.
>>>
>>> All that said, if client developers are uninterested, there's little
>>> point working to solve this problem.
>>>
>>>> As an alternative, the IETF might want to take a more serious look
>>>> at the overall device management solutions, and see if there might
>>>> be scope for standards in that area. That would allow us to build
>>>> off something that is already deployed (in a number of proprietary
>>>> solutions) but is today solving the problem of account setup.
>>>
>>> I think your suggestion is worthwhile independent of whether we
>>> solve the problem for smaller businesses and individual users of
>>> hosted domains.  It would good if the same solution or would address
>>> those needs of smaller businesses and individuals, but if it didn't,
>>> it's still a step forward.
>>>
>>> Paul
>>>
>>> _______________________________________________
>>> webfinger mailing list
>>> [email-masked]
>>> https://www.ietf.org/mailman/listinfo/webfinger
>>
>> -- Marten Gajda
>> CEO
>>
>> dmfs GmbH
>> Schandauer Straße 34
>> 01309 Dresden
>> GERMANY
>>
>> phone: +49 177 4427167
>> email: [email-masked]
>>
>> Managing Director: Marten Gajda
>> Registered address: Dresden
>> Registered No.: AG Dresden HRB 34881
>> VAT Reg. No.: DE303248743
>>
>> _______________________________________________
>> webfinger mailing list
>> [email-masked]
>> https://www.ietf.org/mailman/listinfo/webfinger
>

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

Managing Director: Marten Gajda
Registered address: Dresden
Registered No.: AG Dresden HRB 34881
VAT Reg. No.: DE303248743

---

From: "Paul E. Jones" <[email-masked]>
Date: Wed, 01 Jun 2016 18:39:27 +0000

Marten,

I would truly love to see this move forward and have had an intention of 
writing a draft myself.  I'd be happy to collaborate with you on one.  
Just in the past couple of weeks, I had to help somebody set up their 
email client remotely to use an IMAP server.  It was incredibly painful 
for me to try to step them through the process not having access to 
their screen, etc.  After that experience, I'm even more convinced that 
a solution to this problem is needed.

I personally don't think learning the existing of an account is an 
issue, since I can discover that by merely sending an email.  However, 
if that is a concern, then the simplest solution is for the server that 
is providing the configuration document to requires authentication 
regardless of the user ID presented.

If I were to deploy this in my own environment, I would use the same 
user ID and password to retrieve the configuration document as is used 
to log into the IMAP for SMTP server.  Interfacing with the auth 
functions that already exist would be fairly trivial.  I don't fully 
understand why we would want to have a different authentication 
mechanism, given that (at least in every case I've seen) the IMAP/POP 
and SMTP services generally validate users from the same authentication 
functions behind the scenes.  Sending credentials over HTTPS to a server 
to then validate in the same manner seems to make a lot of sense.

So the solution I had in mind would be to query using WebFinger to get 
the usual output for "[email-masked]".  In that JRD that is 
returned would be a link relation type "mailconfig" that refers to  a 
resource like https://dublin.packetizer.com/mailconfig/?user=paulej.  
That web interface would require just basic authentication (since the 
password would be encrypted with TLS) and authenticate with the auth 
function like the other mail services.  If auth is successful, it would 
return the JSON structure that would contain the mail configuration 
information.  I could easily have something like that working very 
quickly.

I'd be very hesitant to introduce more complex authentication or 
identity procedures, personally.

As for the content of the file returned, while I very much think we 
should only be using the latest security procedures, we have to allow 
the document to return things like "use SSLv2" if that is indeed what 
the IMAP server supports.  These policies are really for the IT folks to 
dictate and I don't think the document we produce should dictate the 
security mechanisms.  It's really the place for other documents to 
dictate best practices and any suggestion we might make might be wrong 
in 5 years. :)

That said, I'm certainly favorable to simplicity and have no strong view 
on exactly how the config information should be structured.  I wrote up 
an example https://tools.ietf.org/html/draft-ietf-appsawg-webfinger-03 
that was overly trivial.  It did not consider the possibility that a 
client might have multiple protocols, for example.  I think it is 
important to provide a JSON document that is an array of mail 
transmission options then an array of mail retrieval options.  Within 
each array, I would expect an array of configuration options ordered in 
the preferred order of the administrator.  Thus, the preferred security 
procedures can be conveyed.  So, "IMAP" and the host might be listed a 
few times with different ports and transports (SSL and TLS and, gulp, no 
security).  I have seen some services offered where the host name 
actually differs based on one's geographic location.  Thus, multiple 
servers names might need to be conveyed, along with perhaps checking the 
physical location of the user.  (But, that detail doesn't have to be a 
part of the spec.)

Importantly, since the whole process can be automated, then it is 
entirely possible for the client to re-check the recommended 
configuration information from time-to-time to see if there is a change 
in the configuration details.

Paul

------ Original Message ------
From: "Marten Gajda" <[email-masked]>
To: "Paul E. Jones" <[email-masked]>; "[email-masked]" 
<[email-masked]>
Sent: 6/1/2016 9:59:58 AM
Subject: Re: [webfinger] [apps-discuss] Mail client configuration via 
WebFinger

---

From: Marten Gajda <[email-masked]>
Date: Fri, 03 Jun 2016 00:55:33 +0200

Hi Paul,

the problem is that often it's possible to use the same user id with
different services. A common example is iCloud, which allows you to use
your Gmail address as the login name.
In that case, to set up calendar synchronization with iCloud, a user
would enter his login (which is the Gmail address) to start the
auto-configuration. Of course a client would first do a Webfinger
request on gmail.com in that case. If that requires authentication the
client needs to ask for the Gmail password first. That's where you
really confuse users and it might happen that they enter their iCloud
password instead, which then might be revealed to Gmail.

To avoid this, it has been suggested to give users an (additional) acct:
URI type login name which always contains the domain of the actual
service provider. So the user would enter something like
[email-masked] or maybe some generated ID like
[email-masked], but I don't see how we could teach users
to understand that they need to enter a different identifier to perform
an auto-configuration.

Cheers,

Marten

Am 01.06.2016 um 20:39 schrieb Paul E. Jones:
> Marten,
>
> I would truly love to see this move forward and have had an intention
> of writing a draft myself.  I'd be happy to collaborate with you on
> one.  Just in the past couple of weeks, I had to help somebody set up
> their email client remotely to use an IMAP server.  It was incredibly
> painful for me to try to step them through the process not having
> access to their screen, etc.  After that experience, I'm even more
> convinced that a solution to this problem is needed.
>
> if that is a concern, then the simplest solution is for the server
> that is providing the configuration document to requires
> authentication regardless of the user ID presented.
>
> and SMTP services generally validate users from the same
> authentication functions behind the scenes.  Sending credentials over
> HTTPS to a server to then validate in the same manner seems to make a
> lot of sense.
>
> function like the other mail services.  If auth is successful, it
> would return the JSON structure that would contain the mail
> configuration information.  I could easily have something like that
> working very quickly.
>
> the IMAP server supports.  These policies are really for the IT folks
> to dictate and I don't think the document we produce should dictate
> the security mechanisms.  It's really the place for other documents to
> That said, I'm certainly favorable to simplicity and have no strong
> view on exactly how the config information should be structured.  I
> wrote up an example
> https://tools.ietf.org/html/draft-ietf-appsawg-webfinger-03 that was
> overly trivial.  It did not consider the possibility that a client
> might have multiple protocols, for example.  I think it is important
> to provide a JSON document that is an array of mail transmission
> options then an array of mail retrieval options.  Within each array, I
> would expect an array of configuration options ordered in the
> preferred order of the administrator.  Thus, the preferred security
> few times with different ports and transports (SSL and TLS and, gulp,
> no security).  I have seen some services offered where the host name
> servers names might need to be conveyed, along with perhaps checking
> the physical location of the user.  (But, that detail doesn't have to
> be a part of the spec.)
>
> configuration information from time-to-time to see if there is a
> change in the configuration details.
>
> Paul
>

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

---

From: "John Levine" <[email-masked]>
Date: 3 Jun 2016 00:43:28 -0000

If I may ask an obvious question, how much better in practice is this
likely to be than RFC 6186?  I realize that 6186 is somewhat
inflexible and requires that the address or the local-part be the
login credential, but it is my impression that the vast majority of
mail servers are set up that way anyway.

R's,
John

---

From: "Paul E. Jones" <[email-masked]>
Date: Fri, 03 Jun 2016 07:42:29 +0200

Marten,

At the end of all of all of this, the email client is still going to need the password for the SMTP and IMAP/POP3 service. I guess some even use different passwords for those, since email clients ask for it.

I personally use Google Calendar with my email and authenticate that separately today (which looks like oauth given how it integrates).

So what I would expect is a UI that asks for the passwords for each service that is being accessed, much like today. We really can't get around that.  The client just has to make it clear to the user.

I only suggested to use the same password to retrieve the mail config as for using email.  In truth, I don't even see the security risk with that, as I can find nearly any server. Thus, it's like security through obfuscation, which we know isn't security. But, if we insist on securing it, use the email password (ideally that being the same).

Calendar or other services could each have their own like relations discovered via WebFinger.  Or, that info could be bundled with the email config.  Either way, I think we just have to ensure the UI is clear, but the starting point be the email password.

Perhaps I'm overlooking something, but I'm otherwise confused how the client will get that SMTP and IMAP password.

Paul

-------- Original Message --------
From: Marten Gajda <[email-masked]>
Sent: June 3, 2016 12:55:33 AM GMT+02:00
To: "Paul E. Jones" <[email-masked]>, "[email-masked]" <[email-masked]>
Subject: Re: [webfinger] [apps-discuss] Mail client configuration via	WebFinger

Hi Paul,

Cheers,

Marten

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

---

From: Marten Gajda <[email-masked]>
Date: Fri, 03 Jun 2016 11:38:16 +0200

Hi John,

good question. I see a couple of advantages over RFC 6186 (and at least
some of these have led to the development of the current draft).

# user specific configuration

The draft we're talking about allows a service provider to return a user
specific configuration file. Some example use cases are

 * premium services can be included for premium users only, the client
of a "free user" would not attempt to set up a service that it has no
access to
 * user specific endpoints - consider a company with an office in Europe
and an office in the US. All email addresses may share the same domain,
say `example.com`, but the European users actually access IMAP under
`imap.eu.example.com` and the US users access IMAP under
`imap.us.example.com`. A configuration document can be smart enough to
return the correct endpoint for each user, while SRV can't do that.

# one document to rule them all

A service configuration document contains information about all services
a service provider offers. You don't need to guess which services might
be there. Also, the service configuration client doesn't even have to
know how to handle all the services. Ideally the configuration client
would run on system level and dispatch the setup of each service found
in the configuration document to the respective service handlers which
are registered with the system.

# additional information
 
A service configuration document allows to integrate additional
information like

 * OAuth2 scopes that are required to access a specific service
 * a link to an account management page
 * support/operator contact information

# easier to integrate

## for clients

Doing an SRV lookup is not well supported by some (or many) of the
existing platforms & frameworks. Many Frameworks provide methods to
resolve domains back and forth, but other record types are often not
supported out of the box.
We're developing Android clients for CalDAV & CardDAV and to do an SRV
lookup we would have to integrate a 3rd party DNS library. Of course
that 3rd party library should support DNSSEC, otherwise you can't trust
the result of the SRV lookup.

The draft we're talking about uses HTTP based technology, which is well
supported in a secure manner by pretty much every platform/framework.

## for services

Setting up DNS records is not an issue for large service providers,
though it can be a problem for smaller installations if your hosting
service doesn't give you such control over your DNS settings.
Setting up Webfinger and a service configuration document can be quite
trivial. In simple cases you can get away with a few static files on
your server. In other cases a simple PHP script might solve this.

# works cross domain (at least in theory)

Technology like OpenID Connect allows to separate the identity provider
from the actual service provider. So my email provider might not be the
same as my calendar provider, but both use the same identity provider
for authorization. My calendar client should be able to discover my
calendars, even though my user id has a completely different domain part.

Services like webfist.org can make this even more versatile and gives
users full control over their service configuration document, even if
their email provider doesn't support it.

That's it for now. There may be other good reasons to favor a service
configuration document over SRV records.

Cheers,

Marten

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

---

From: Marten Gajda <[email-masked]>
Date: Fri, 03 Jun 2016 15:05:58 +0200

So how would the UI work?

1) User enters user identifier, most likely an email address, like 
"[email-masked]" and hits "next"

2) Client sends a Webfinger request to 
https://exampe.com/.well-known/webfinger?... to see if there is a 
configuration document

   -> response 404 Not Found
    a) Client falls back to "manual setup" or another auto-configuration 
mechanism

   -> response 401 Unauthorized
    b) Client asks for password at "example.com" and goes back to step 2 
(this time with authentication)

   -> response 200 Ok
    c) client moves on to next step

3) (optional) Client presents found services to the user to let him 
select the services to set up

4) Client runs the setup handler for each selected service

I think in general that could work but it raises two questions:

1) How to make sure the user really understands that he's authenticating 
at example.com in step 2b? If the user tries to configure calendar sync 
with "acme-calendar.com" where his login happens to be 
"[email-masked]" he might not be prepared to being asked for his 
example.com password. Maybe I'm just paranoid or overcautious, but I 
think that it might easily happen that the users sends his 
acme-calendar.com password to example.com in that case (since Basic 
authentication is still the most common mechanism, the client basically 
sends the password in plain text).

2) How does the client know which credentials to use to set up the 
individual services in step 4? Should the client ask the user for the 
credentials for each service or can it assume that some of them share 
the same credentials? Is that something an auto-configuration document 
can help with?

Ideally the server supports some kind of SSO mechanism like OpenID 
Connect, so you don't need to enter your password multiple times. But a 
working auto-configuration is really the precondition for this, because 
an OpenID Connect implementations needs a way to discover the OAuth2 
scope tokens to request from the server and auto-configuration is really 
the way to do that, IMO. For this it would be helpful to have some 
mechanism to request a broader scope from the user (without allowing him 
to switch to a different account), but that's a different topic I guess.

Cheers,

Marten

Am 03.06.2016 um 07:42 schrieb Paul E. Jones:
> Marten,
>
> At the end of all of all of this, the email client is still going to 
> need the password for the SMTP and IMAP/POP3 service. I guess some 
> even use different passwords for those, since email clients ask for it.
>
> I personally use Google Calendar with my email and authenticate that 
> separately today (which looks like oauth given how it integrates).
>
> So what I would expect is a UI that asks for the passwords for each 
> service that is being accessed, much like today. We really can't get 
> around that. The client just has to make it clear to the user.
>
> I only suggested to use the same password to retrieve the mail config 
> as for using email. In truth, I don't even see the security risk with 
> that, as I can find nearly any server. Thus, it's like security 
> through obfuscation, which we know isn't security. But, if we insist 
> on securing it, use the email password (ideally that being the same).
>
> Calendar or other services could each have their own like relations 
> discovered via WebFinger. Or, that info could be bundled with the 
> email config. Either way, I think we just have to ensure the UI is 
> clear, but the starting point be the email password.
>
> Perhaps I'm overlooking something, but I'm otherwise confused how the 
> client will get that SMTP and IMAP password.
>
> Paul
>
> ------------------------------------------------------------------------
> *From:* Marten Gajda <[email-masked]>
> *Sent:* June 3, 2016 12:55:33 AM GMT+02:00
> *To:* "Paul E. Jones" <[email-masked]>, "[email-masked]" 
> <[email-masked]>
> *Subject:* Re: [webfinger] [apps-discuss] Mail client configuration 
> via WebFinger
>
> Hi Paul,
>
> request ongmail.com  <http://gmail.com>  in that case. If that requires authentication the
> user%40gmail.com  <http://40gmail.com>@icloud.com or maybe some generated ID like
>     Marten, I would truly love to see this move forward and have had
>     an intention of writing a draft myself. I'd be happy to
>     collaborate with you on one. Just in the past couple of weeks, I
>     had to help somebody set up their email client remotely to use an
>     IMAP server. It was incredibly painful for me to try to step them
>     through the process not having access to their screen, etc. After
>     that experience, I'm even more convinced that a solution to this
>     pr! oblem is needed. I personally don't think learning the
>     existing of an account is an issue, since I can discover that by
>     merely sending an email. However, if that is a concern, then the
>     simplest solution is for the server that is providing the
>     configuration document to requires authentication regardless of
>     the user ID presented. If I were to deploy this in my own
>     environment, I would use the same user ID and password to retrieve
>     the configuration document as is used to log into the IMAP for
>     SMTP server. Interfacing with the auth functions that already
>     exist would be fairly trivial. I don't fully understand why we
>     would want to have a different authentication mechanism, given
>     that (at least in every case I've seen) the IMAP/POP and SMTP
>     services generally validate users from the same authentication
>     functions behind the scenes. Sending credentials over HTTPS to a
>     server to then validate i! n the same manner seems to make a lot
>     of sense. So the solution I had in mind would be to query using
>     WebFinger to get the usual output for "[email-masked]". In
>     that JRD that is returned would be a link relation type
>     "mailconfig" that refers to a resource like
>     https://dublin.packetizer.com/mailconfig/?user=paulej. That web
>     interface would require just basic authentication (since the
>     password would be encrypted with TLS) and authenticate with the
>     auth function like the other mail services. If auth is successful,
>     it would return the JSON structure that would contain the mail
>     working very quickly. I'd be very hesitant to introduce more
>     complex authentication or identity procedures, personally. As for
>     the content of the file returned, while! I very much think we
>     should only be using the latest security procedures, we have to
>     allow the document to return things like "use SSLv2" if that is
>     indeed what the IMAP server supports. These policies are really
>     for the IT folks to dictate and I don't think the document we
>     produce should dictate the security mechanisms. It's really the
>     place for other documents to dictate best practices and any
>     suggestion we might make might be wrong in 5 years. :) That said,
>     I'm certainly favorable to simplicity and have no strong view on
>     exactly how the config information should be structured. I wrote
>     up an example
>     https://tools.ietf.org/html/draft-ietf-appsawg-webfinger-03 that
>     was overly trivial. It did not consider the possibility that a
>     important to provide a JS! ON document that is an array of mail
>     transmission options then an array of mail retrieval options.
>     Within each array, I would expect an array of configuration
>     options ordered in the preferred order of the administrator. Thus,
>     the preferred security procedures can be conveyed. So, "IMAP" and
>     the host might be listed a few times with different ports and
>     transports (SSL and TLS and, gulp, no security). I have seen some
>     services offered where the host name actually differs based on
>     one's geographic location. Thus, multiple servers names might need
>     to be conveyed, along with perhaps checking the physical location
>     of the user. (But, that detail doesn't have to be a part of the
>     spec.) Importantly, since the whole process can be automated, then
>     it is entirely possible for the client to re-check the recommended
>     change in the configuration details. Paul ------ Original Message
>     ------ From: "Marten Gajda" <[email-masked]> To: "Paul E. Jones"
>     <[email-masked]>; "[email-masked]" <[email-masked]>
>     Sent: 6/1/2016 9:59:58 AM Subject: Re: [webfinger] [apps-discuss]
>     Mail client configuration via WebFinger
>
>         Hi Paul, we've brought up this topic during the last
>         CalConnect conference and it was decided to revitalize the TC
>         where the draft you mentioned originated from. We have some
>         interest from software vendors and users to get this solved.
>         authentication. The issue raised was that the pure existence
>         of a link to a configuration document in the webfinger
>         response can reveal theexistence of the account. On the other
>         hand, requiring authentication for auto configuration results
>         in other possible security issues and a poor user experience.
>         The latter ones could probably be solved by making OpenID
>         Connect a requirement for auto configuration, which, on the
>         other hand, adds another layer of complexity and probably
>         makes it less attractive to smaller vendors. Does anyone see
>         any possible solution to that? I'd also like to suggest a few
>         changes in the structure of the configuration document and to
>         drop support for services not protected by TLS or any other
>         transport security layer. I'll post an updated draft as a
>         basis for discussion. I'm happy to join the upcoming IEFT
>         meeting in Berlin and have a BOF or something if there is
>         enough interest in that. cheers Marten Am 09.02.2016 um 02:03
>         schrieb Paul E. Jones:
>
>             Marten, Thanks for the encouraging words; it sounds like
>             you understand the problem that needs to be solved. I
>             always felt the server side was the trivial part. As you
>             said, it's possible to set up a simple WebFinger server
>             with a static file (or sets of files), an .htaccess file,
>             etc. I use a server that pulls data from a database,
>             myself. Importantly, though, the WebFinger protocol is
>             very simple (and I have to thank a number of folks who
>             forced that simplicity), so I see the server side as being
>             far less of a barrier. Hosting providers, for example,
>             could very quickly and easily support this server-side.
>             The clients are the challenge. As others have noted, this
>             requires code changes in the clients and deployment of the
>             clients. I'm encoura! ged that you're working on client
>             code. :) Having an RFC is going to be an extremely
>             important step to actually seeing this problem solved.
>             That said, I did not want to spend time on something that
>             would be met with total rejection. It sounds like there is
>             at least enough interest to start a meaningful dialog, so
>             I'll try to put together a draft soon and we can go from
>             there. If you're interested to collaborate on that, you're
>             certainly welcome. Paul ------ Original Message ------
>             From: "Marten Gajda" <[email-masked]> To:
>             [email-masked] Sent: 2/8/2016 5:54:58 PM Subject: Re:
>             [webfinger] [apps-discuss] Mail client configuration via
>             WebFinger
>
>                 Hi Paul, as a client developer I'm very interested in
>                 this topic. We've act! ually implemented
>                 draft-daboo-aggregated-service-discovery-03 and there
>                 is at least one groupware server product which also
>                 supports it. While working on our implementation we've
>                 identified a few minor issues with the latest draft
>                 and we've already discussed them with Cyrus. I think
>                 most of these issues are solved easily. Though, the
>                 major issue has not been addressed yet. It's the issue
>                 mentioned by Stephen. Under certain conditions a
>                 client might have to ask the user upfront to
>                 authenticate, which may disclose the user's
>                 credentials to the wrong service. We didn't release
>                 this feature in our generic CalDAV/CardDAV clients,
>                 mostly due to that issue. Anyway, I think it really
>                 starts with the server developers. Implementing the
>                 current spec is not that much work on the server side.
>                 In many cases the server configuration document could
>                 just be a static file! and setting up a simple
>                 WebFinger end point is not that hard either. Actually,
>                 for our corporate server we've just created a few
>                 static files and some redirect magic in our .htaccess
>                 file to provide the WebFinger stuff. On the client
>                 side it's more work, because it affects the account
>                 setup flow a lot. But it surely is worth the efforts
>                 if more services support it. However, before even the
>                 server developers can start, it requires an RFC. So
>                 lets start to think about how to solve the
>                 authentication issue. cheers Marten Am 08.02.2016 um
>                 20:00 schrieb Paul E. Jones:
>
>                     Cyrus,
>
>                         Right now it is not clear to me that an ASCO!
>                         T-like solution would be adopted given the use
>                         of device management. Before embarking on this
>                         we need to take a careful look at whether any
>                         solution is likely to be adopted (with the
>                         biggest burden likely being on clients/OS
>                         vendors to support it). Given the device
>                         management solutions already out there, I
>                         suspect there would be little value to m,ost
>                         of those folks to actually support ASCOT. 
>
>                     I completely agree that we should try to get a
>                     sense of the likelihood of success. Within the
>                     enterprise -- especially the larger ones -- you
>                     are entirely correct that device management
>                     systems provide a good solution for most of the
>                     employees. However, I interact with a lot of
>                     smaller businesses that do not use such systems.
>                     Many of them have a web hosting company host their
>                     domains and do not have IT staff to help them on a
>                     daily basis. I'm skeptical that a device
>                     management system would help that class of users,
>                     so arming hosting providers with tools they can
>                     deploy to their customers would help, I think.
>                     There are also a number of individuals who have
>                     their own domains, many hosted on the many, many
>                     web hosting providers out there. Same issue for
>                     most of them. So, I think there is a market need.
>                     I suspect if we were to create a solution, hosting
>                     providers were to deploy it, and client developers
>                     were to support it, people would use it. However,
>                     that's a string of "ifs". I think it starts with
>                     the client developers. If there were people
>                     interested to solve the problem, I think the rest
>                     falls into place. All that said, if client
>                     developers are uninterested, there's little point
>                     working to solve this problem.
>
>                         As an alternative, the IETF might want to take
>                         a more serious look at the overall device
>                         management solutions, and see if there might
>                         be scope for standards in that area. That
>                         would allow us to build off something that is
>                         already deployed (in a number of proprietary
>                     I think your suggestion is worthwhile independent
>                     of whether we solve the problem for smaller
>                     businesses and individual users of hosted domains.
>                     It would good if the same solution or would
>                     address those needs of smaller businesses and
>                     individuals, but if it didn't, it's still a step
>                     forward. Paul
>                     ------------------------------------------------------------------------
>                     webfinger mailing list [email-masked]
>                 -- Marten Gajda CEO dmfs Gmb! H Schandauer Straße 34
>                 01309 Dresden GERMANY phone: +49 177 4427167 email:
>                 [email-masked] Managing Director: Marten Gajda
>                 Registered address: Dresden Registered No.: AG Dresden
>                 HRB 34881 VAT Reg. No.: DE303248743
>                 ------------------------------------------------------------------------
>                 webfinger mailing list [email-masked]
>         -- Marten Gajda CEO dmfs GmbH Schandauer Straße 34 01309
>         Dresden GERMANY phone: +49 177 4427167 email: [email-masked]
>         Managing Director: Marten Gajda Registered address: Dresden
>         Registered No.: AG Dresden HRB 34881 VAT Reg. No.: DE303248743
>         ------------------------------------------------------------------------
>         webfinger mailing list [email-masked]

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

---

From: "Paul E. Jones" <[email-masked]>
Date: Fri, 03 Jun 2016 13:40:20 +0000

Marten,

>mailto:[email-masked] and hits "next"
>

One should not get 401 querying the WebFinger information for the user.  
What should happen is that the server should return a JSON object that 
contains a link relation that might look like this:
{
     "rel " :  "mail-config",
     "href " : 
"https://mailserver.example.com/config?user=paulej%40packetizer.com"
}

Or something like that.  The mail client should query that URI it is 
that one that should result in a potential 401.  The JSON format that 
would come back here would need to be something we define.  It could be 
based on JRD, but would not have to be.

Otherwise, I think the flow looks right.

>1) How to make sure the user really understands that he's 
>authenticating at example.com in step 2b? If the user tries to 
>configure calendar sync with "acme-calendar.com" where his login 
>happens to be mailto:[email-masked] he might not be prepared to being 
>asked for his example.com password. Maybe I'm just paranoid or 
>overcautious, but I think that it might easily happen that the users 
>sends his acme-calendar.com password to example.com in that case (since 
>Basic authentication is still the most common mechanism, the client 
>basically sends the password in plain text).

Yeah, that's a valid concern.  The only thing I can suggest is that the 
Subject CN from the certificate is presented to the user.  
Alternatively, there could be two passwords: one that is the 
"configuration password" and one that is the email password.  However, I 
don't think two passwords will help us.  If I want to hack somebody and 
can gain access to their WF config, I can auto-config their email client 
to point to my own IMAP server and just retrieve the password that way.

So, I think we have to rely on the certificate presented to the mail 
client and the user will have to know to trust it.  The mail provider 
can tell the user "when configuring email, ensure that the configuration 
server is mailconfig.example.com and do not provide a password if that 
is not the name of the configuration server indicated."

If the mail config information is not protected with a password, we 
probably would want the customer to verify that the SMTP server 
information is correct before the password is provided.  These would be 
the steps users would take if performing manual configuration, but the 
software presents that information to the user without the user having 
to enter it.

>the same credentials? Is that something an auto-configuration document 

It would be nice if there is a config indicator that says "SMTP server 
and IMAP server passwords are the same", so the client does not have to 
ask.

If we use a "config password" then we could even have the server tell 
the client the password for services, which would transparently allow 
those to be different.  Alternatively, the client will have to ask each 
about each one.

For calendaring services, then yes: the client would have to ask the 
user.  It could ask if it's the same or different than the email 
password or the config password.  For some services, the authentication 
mechanisms will be entirely different (like Google Calendar).  The mail 
client will just have to know how to access the service.  For that 
reason, I'm a little hesitant to suggest including calendaring service 
config along with the email config data.  We could have each of those 
services listed in the users' WebFinger document.  For example, I might 
have this entry in my WF document:
{
     "rel" : "calendar"
     "href" : "urn:whatever:google"
}

Note I did not provide a URL.  The reason is that this is an entirely 
different service that has an entirely different access method.  Maybe 
the client can ask the user "is [email-masked] our user ID for 
your Google calendar?"  In my case, I don't think it is.  Certainly, 
it's not my gmail ID.  And, I would not want to advertise that to the 
world, necessarily.  Anyway, I think we should limit the scope of what 
we try to do to things that are standard OR we define a generic URN that 
a client will just have to know how to deal with.

>scope tokens to request from the server and auto-configuration is 
>really the way to do that, IMO. For this it would be helpful to have 
>some mechanism to request a broader scope from the user (without 
>allowing him to switch to a different account), but that's a different 
>topic I guess.

I definitely like the idea of SSO.  But, I struggle to see how we would 
use this in practice with mail autoconfig since SMTP, IMAP, and POP 
servers require a password, anyway.  If we use that as a means to have 
those passwords provided behind the scenes (as I indicated above), that 
might be a good argument for using OpenID Connect.  In that way, the ISP 
can also ensure that passwords are REALLY complex and unknown even to 
the user.  Not a bad practice, in that we can view those passwords as 
complex tokens.

Would that kind of use of OpenID Connect to retrieve the password be 
workable?  (I'll admit I don't have so much experience with OpenID 
Connect.  I implemented OpenID 2.0, but that's not ideal for what we'd 
want to accomplish here.  I don't have a good feel for how Connect might 
make this better.)

Paul

---

From: Marten Gajda <[email-masked]>
Date: Fri, 03 Jun 2016 16:44:17 +0200

Note that the idea behind 
https://tools.ietf.org/html/draft-daboo-aggregated-service-discovery-03 
is to put the service configuration for all services of a provider into 
a single document.

So you would receive something like this:

{
     "rel " :  "service-configuration",
     "href " : "https://example.com/service-configuration"
}

If a user uses the same account identifier at another provider the 
Webfinger request could return their configuration too (given there is 
some mechanism to add it and the provider actually supports that).

{
     "rel " :  "service-configuration",
     "href " : "https://example.com/service-configuration"
},
{
     "rel " :  "service-configuration",
     "href " : "https://acme-calendar.com/service-configuration"
}

Without that it would be more difficult to setup your account at 
acme-calendar.com with your login "[email-masked]". acme-calendar.com 
would have to issue some kind of user-identifier like 
[email-masked] for auto-configuration purposes, even though you 
don't use it for authentication (because you use [email-masked] for 
authentication). I think that's the idea behind the `acct:` URI scheme, 
but I don't think that you can explain to users why they need another 
user identifier and when to use one or the other.
But that also raises the privacy concerns I mentioned earlier. If the 
request is not authenticated, everyone could see that you have an 
account at acme-calendar.com.

Regarding SSO: There is an RFC that extends SASL based authentication to 
support the token authentication mechanisms as used by OAuth1 and 
OAuth2, see https://tools.ietf.org/html/rfc7628
So SSO already works with IMAP, POP3 and SMTP.

Cheers

Marten

Am 03.06.2016 um 15:40 schrieb Paul E. Jones:
>>    a) Client falls back to "manual setup" or another 
>> auto-configuration mechanism
>>
> One should not get 401 querying the WebFinger information for the 
> user.  What should happen is that the server should return a JSON 
> object that contains a link relation that might look like this:
> {
>     "rel " :  "mail-config",
>     "href " : 
> would come back here would need to be something we define.  It could 
> be based on JRD, but would not have to be.
>>    b) Client asks for password at "example.com" and goes back to step 
>> 2 (this time with authentication)
>>
>>   -> response 200 Ok
>> happens to be mailto:[email-masked] he might not be prepared to 
>> being asked for his example.com password. Maybe I'm just paranoid or 
>> sends his acme-calendar.com password to example.com in that case 
>> (since Basic authentication is still the most common mechanism, the 
>> client basically sends the password in plain text).
> Yeah, that's a valid concern.  The only thing I can suggest is that 
> the Subject CN from the certificate is presented to the user.  
> "configuration password" and one that is the email password.  However, 
> I don't think two passwords will help us. If I want to hack somebody 
> and can gain access to their WF config, I can auto-config their email 
> client to point to my own IMAP server and just retrieve the password 
> that way.
> can tell the user "when configuring email, ensure that the 
> configuration server is mailconfig.example.com and do not provide a 
> password if that is not the name of the configuration server indicated."
> information is correct before the password is provided.  These would 
> be the steps users would take if performing manual configuration, but 
> the software presents that information to the user without the user 
> having to enter it.
>>
>> the same credentials? Is that something an auto-configuration 
>> document can help with?
> and IMAP server passwords are the same", so the client does not have 
> to ask.
> those to be different.  Alternatively, the client will have to ask 
> each about each one.
> password or the config password.  For some services, the 
> authentication mechanisms will be entirely different (like Google 
> Calendar).  The mail client will just have to know how to access the 
> service.  For that reason, I'm a little hesitant to suggest including 
> calendaring service config along with the email config data.  We could 
> have each of those services listed in the users' WebFinger document. 
> For example, I might have this entry in my WF document:
> {
>     "rel" : "calendar"
> the client can ask the user "is [email-masked] 
> <mailto:[email-masked]> our user ID for your Google calendar?"  
> In my case, I don't think it is.  Certainly, it's not my gmail ID.  
> And, I would not want to advertise that to the world, necessarily.  
> Anyway, I think we should limit the scope of what we try to do to 
> things that are standard OR we define a generic URN that a client will 
> just have to know how to deal with.
>> Connect, so you don't need to enter your password multiple times. But 
>> a working auto-configuration is really the precondition for this, 
>> because an OpenID Connect implementations needs a way to discover the 
>> OAuth2 scope tokens to request from the server and auto-configuration 
>> is really the way to do that, IMO. For this it would be helpful to 
>> have some mechanism to request a broader scope from the user (without 
>> allowing him to switch to a different account), but that's a 
>> different topic I guess.
> I definitely like the idea of SSO.  But, I struggle to see how we 
> would use this in practice with mail autoconfig since SMTP, IMAP, and 
> POP servers require a password, anyway.  If we use that as a means to 
> have those passwords provided behind the scenes (as I indicated 
> above), that might be a good argument for using OpenID Connect.  In 
> that way, the ISP can also ensure that passwords are REALLY complex 
> and unknown even to the user.  Not a bad practice, in that we can view 
> those passwords as complex tokens.
> want to accomplish here.  I don't have a good feel for how Connect 
> might make this better.)
> Paul
>
>

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

---

From: George Fletcher <[email-masked]>
Date: Fri, 3 Jun 2016 14:13:47 -0400

Did a quick scan of the draft document. Given that more and more systems 
are trying to remove the need for passwords, it seems like the final 
solution needs to support 2FA and biometric mechanisms for "HTTP 
authentication". I definitely would not want the webfinger instance 
releasing my config data without my "authentication". I suppose OAuth2 
could be used to protect the webfinger APIs though there is a bit of a 
chicken-and-egg here:)

I kind of like the suggestion around returning a 401 with data in the 
WWW-Authenticate header on where to get a token to use with the API. 
This would allow the client to start and OAuth2 flow with the 
Authorization Server specified and that would give the user a clear 
indication of what password/credentials are being requested. Once the 
client gets the token, it uses it with the webfinger call and now the 
service-configuration data is returned because the token is the 
authorization for the specified id.

Thanks,
George

On 6/3/16 10:44 AM, Marten Gajda wrote:
> is to put the service configuration for all services of a provider 
> into a single document.
>
> acme-calendar.com with your login "[email-masked]". 
> acme-calendar.com would have to issue some kind of user-identifier 
> like [email-masked] for auto-configuration purposes, even 
> though you don't use it for authentication (because you use 
> [email-masked] for authentication). I think that's the idea behind 
> the `acct:` URI scheme, but I don't think that you can explain to 
> users why they need another user identifier and when to use one or the 
> other.
> Regarding SSO: There is an RFC that extends SASL based authentication 
> to support the token authentication mechanisms as used by OAuth1 and 
>>>    b) Client asks for password at "example.com" and goes back to 
>>> step 2 (this time with authentication)
>>>
>>>   -> response 200 Ok
>> "configuration password" and one that is the email password.  
>> However, I don't think two passwords will help us.  If I want to hack 
>> somebody and can gain access to their WF config, I can auto-config 
>> their email client to point to my own IMAP server and just retrieve 
>> the password that way.
>>> individual services in step 4? Should the client ask the user for 
>>> the credentials for each service or can it assume that some of them 
>>> share the same credentials? Is that something an auto-configuration 
>>> document can help with?
>> It would be nice if there is a config indicator that says "SMTP 
>> server and IMAP server passwords are the same", so the client does 
>> not have to ask.
>> calendaring service config along with the email config data.  We 
>> could have each of those services listed in the users' WebFinger 
>> document.  For example, I might have this entry in my WF document:
>> {
>>     "rel" : "calendar"
>> different service that has an entirely different access method.  
>> Maybe the client can ask the user "is [email-masked] 
>> <mailto:[email-masked]> our user ID for your Google 
>> calendar?"  In my case, I don't think it is.  Certainly, it's not my 
>> gmail ID.  And, I would not want to advertise that to the world, 
>> necessarily. Anyway, I think we should limit the scope of what we try 
>> to do to things that are standard OR we define a generic URN that a 
>> client will just have to know how to deal with.
>>> Connect, so you don't need to enter your password multiple times. 
>>> But a working auto-configuration is really the precondition for 
>>> this, because an OpenID Connect implementations needs a way to 
>>> discover the OAuth2 scope tokens to request from the server and 
>>> auto-configuration is really the way to do that, IMO. For this it 
>>> would be helpful to have some mechanism to request a broader scope 
>>> from the user (without allowing him to switch to a different 
>>> account), but that's a different topic I guess.
>> and unknown even to the user.  Not a bad practice, in that we can 
>> view those passwords as complex tokens.
>> Connect.  I implemented OpenID 2.0, but that's not ideal for what 
>> we'd want to accomplish here. I don't have a good feel for how 
>> Connect might make this better.)
>> Paul
>>
>>
> email:[email-masked]

---

From: Marten Gajda <[email-masked]>
Date: Sun, 05 Jun 2016 23:00:17 +0200

I think OpenID Connect already covers the discovery of everything you
need to do OAuth2. That involves Webfinger, but there is no need to
protect this request, because it doesn't contain personal information.
So we don't need to reinvent the OAuth2 bootstrapping sequence.
The only minor issue I see is that you may have to ask the user twice to
grant access. Once to authorize the client to access the configuration
document and another time to authorize the client to access the
individual services. The second step is necessary, because the scope
tokens of these services are not known when the first authorization
request is presented to the user. The problem with that is, there
doesn't seem to be a mechanism to broaden scope, without allowing the
user to switch to a different account. To get access to the individual
services, the client needs to start another authorization code grant.
But the user is always free to log out and log in with a different
account before granting access.

Marten

Am 03.06.2016 um 20:13 schrieb George Fletcher:
> Did a quick scan of the draft document. Given that more and more
> systems are trying to remove the need for passwords, it seems like the
> final solution needs to support 2FA and biometric mechanisms for "HTTP
>> Webfinger request could return their configuration too (given there
>> is some mechanism to add it and the provider actually supports that).
>>
>> {
>> users why they need another user identifier and when to use one or
>> the other.
>>> that one that should result in a potential 401.  The JSON format
>>> that would come back here would need to be something we define.  It
>>> could be based on JRD, but would not have to be.
>>>  
>>>> being asked for his example.com password. Maybe I'm just paranoid
>>>> or overcautious, but I think that it might easily happen that the
>>>> users sends his acme-calendar.com password to example.com in that
>>>> case (since Basic authentication is still the most common
>>>> mechanism, the client basically sends the password in plain text).
>>>  
>>> However, I don't think two passwords will help us.  If I want to
>>> hack somebody and can gain access to their WF config, I can
>>> auto-config their email client to point to my own IMAP server and
>>> just retrieve the password that way.
>>>  
>>> client and the user will have to know to trust it.  The mail
>>> provider can tell the user "when configuring email, ensure that the
>>> be the steps users would take if performing manual configuration,
>>> but the software presents that information to the user without the
>>> user having to enter it.
>>>  
>>>  
>>>>
>>> If we use a "config password" then we could even have the server
>>> tell the client the password for services, which would transparently
>>> allow those to be different.  Alternatively, the client will have to
>>> ask each about each one.
>>>  
>>> service.  For that reason, I'm a little hesitant to suggest
>>> including calendaring service config along with the email config
>>> data.  We could have each of those services listed in the users'
>>> WebFinger document.  For example, I might have this entry in my WF
>>> document:
>>> {
>>>     "rel" : "calendar"
>>> Note I did not provide a URL.  The reason is that this is an
>>> entirely different service that has an entirely different access
>>> method.  Maybe the client can ask the user "is [email-masked]
>>> our user ID for your Google calendar?"  In my case, I don't think it
>>> is.  Certainly, it's not my gmail ID.  And, I would not want to
>>> advertise that to the world, necessarily.  Anyway, I think we should
>>> limit the scope of what we try to do to things that are standard OR
>>> we define a generic URN that a client will just have to know how to
>>> deal with.
>>>  
>>>  
>>> would use this in practice with mail autoconfig since SMTP, IMAP,
>>> and POP servers require a password, anyway.  If we use that as a
>>> means to have those passwords provided behind the scenes (as I
>>> indicated above), that might be a good argument for using OpenID
>>> Connect.  In that way, the ISP can also ensure that passwords are
>>> REALLY complex and unknown even to the user.  Not a bad practice, in
>>> that we can view those passwords as complex tokens.
>>>  

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]

---

From: Marten Gajda <[email-masked]>
Date: Wed, 08 Jun 2016 21:35:05 +0200

All,

I've created a GitHub repository to track open issues with the current
draft, see https://github.com/CalConnect/AUTODISCOVERY/issues
You're welcome to contribute to the discussion, either by creating a new
issue or by commenting on an existing one.

Thanks,

Marten

Am 05.06.2016 um 23:00 schrieb Marten Gajda:
> The only minor issue I see is that you may have to ask the user twice
> to grant access. Once to authorize the client to access the
> configuration document and another time to authorize the client to
> access the individual services. The second step is necessary, because
> the scope tokens of these services are not known when the first
> authorization request is presented to the user. The problem with that
> is, there doesn't seem to be a mechanism to broaden scope, without
> allowing the user to switch to a different account. To get access to
> the individual services, the client needs to start another
> authorization code grant. But the user is always free to log out and
> log in with a different account before granting access.
>
> Marten
>
>> systems are trying to remove the need for passwords, it seems like
>> the final solution needs to support 2FA and biometric mechanisms for
>> "HTTP authentication". I definitely would not want the webfinger
>> instance releasing my config data without my "authentication". I
>> suppose OAuth2 could be used to protect the webfinger APIs though
>> there is a bit of a chicken-and-egg here:)
>>
>>> But that also raises the privacy concerns I mentioned earlier. If
>>> the request is not authenticated, everyone could see that you have
>>> an account at acme-calendar.com.
>>>
>>> Regarding SSO: There is an RFC that extends SASL based
>>> authentication to support the token authentication mechanisms as
>>> used by OAuth1 and OAuth2, see https://tools.ietf.org/html/rfc7628
>>>> Or something like that.  The mail client should query that URI it
>>>> is that one that should result in a potential 401.  The JSON format
>>>>> 3) (optional) Client presents found services to the user to let
>>>>> him select the services to set up
>>>>>
>>>> So, I think we have to rely on the certificate presented to the
>>>> mail client and the user will have to know to trust it.  The mail
>>>> information is correct before the password is provided.  These
>>>> would be the steps users would take if performing manual
>>>> configuration, but the software presents that information to the
>>>> user without the user having to enter it.
>>>>  
>>>>  
>>>>>
>>>>> the credentials for each service or can it assume that some of
>>>>> them share the same credentials? Is that something an
>>>>> auto-configuration document can help with?
>>>>  
>>>> tell the client the password for services, which would
>>>> transparently allow those to be different.  Alternatively, the
>>>> client will have to ask each about each one.
>>>>  
>>>> For calendaring services, then yes: the client would have to ask
>>>> the user.  It could ask if it's the same or different than the
>>>> email password or the config password.  For some services, the
>>>> Calendar).  The mail client will just have to know how to access
>>>> the service.  For that reason, I'm a little hesitant to suggest
>>>> method.  Maybe the client can ask the user "is
>>>> [email-masked] our user ID for your Google calendar?"  In my
>>>> case, I don't think it is.  Certainly, it's not my gmail ID.  And,
>>>> I would not want to advertise that to the world, necessarily. 
>>>> things that are standard OR we define a generic URN that a client
>>>> will just have to know how to deal with.
>>>>  
>>>>  
>>>> REALLY complex and unknown even to the user.  Not a bad practice,
>>>> in that we can view those passwords as complex tokens.
>>>>  
>>>> Would that kind of use of OpenID Connect to retrieve the password
>>>> be workable?  (I'll admit I don't have so much experience with
>>>> OpenID Connect.  I implemented OpenID 2.0, but that's not ideal for
>>>> what we'd want to accomplish here.  I don't have a good feel for
>>>> how Connect might make this better.)
>>>>  
>>>> Paul
>>>>  
>>>>
>>>>

-- 
Marten Gajda
CEO

dmfs GmbH
Schandauer Straße 34
01309 Dresden
GERMANY

phone: +49 177 4427167
email: [email-masked]