[jdev] https://github.com/stpeter/manifesto and additional ideas

Thu Nov 14 16:09:38 UTC 2013

On Nov 14, 2013, at 8:33 AM, Ralf Skyper Kaiser <skyper at thc.org> wrote:

> 
> On Thu, Nov 14, 2013 at 1:01 PM, Dave Cridland <dave at cridland.net> wrote:
> On Thu, Nov 14, 2013 at 12:53 PM, Ralf Skyper Kaiser <skyper at thc.org> wrote:
> Hi,
> 
> Ideas, comments and an open discussion are welcome to include the
> following ideas in the manifesto.
> 
> - Client-support for certificate pinning (including pinning of self-signed certificates).
>   https://www.owasp.org/index.php/Certificate_and_Public_Key_Pinning
>   http://tools.ietf.org/html/draft-ietf-websec-key-pinning-08
> 
> I'm waiting to see how that one stabilizes before commenting. Ultimately, I think such techniques will be handled much better by DANE.
> 
> DANE requires an upgrade in infrastructure and wont happen in the immediate future (it might not happen at all).
> 
> DANE again relies on sort-off 'CA-style' trust model ...which was the problem to start with.
> 

Ignoring the DNSSEC portion for the moment, DANE has a four difference cert usage types, one of which most definitely allows (and another kind of allows) for self-signed certificates.

Now, DNSSEC does follow a similar subject/issuer hierarchy we have with CA, except there's a single root issuer, compared to the 150+ that exist today.

> Pinning puts the trust into the hand of the server-admin, without third parties. Secure.
> 

It's probably (more) secure, assuming you get past the bootstrapping problem.

>   
> - Client Lockdown feature: Automatically sets a variety of security preferences
>   to "known good" settings. Once lockdown option is set the user should not be
>   able to change any of the 'locked' security preferences until lockdown is disabled
>   again (e.g. gray out the option). Lockdown includes: Do not permit non-OTR
>   messages, require TLS, do not permit message logging)
> 
> 
> You want the client to somehow make its options read-only? What if they got locked down in a less than optimal manner? What if they were locked down such that when a new security feature was available, the user couldn't then take advantage of it.
> 
> This also requires us to standardize the meaning of lockdown, and also standardize the options we want to be included. I really don't think this one will fly.
> 
> This is a feature in the client/UI software. Sorry if this was not clear.
> 
> The developer of the software can freely decide to include the new security feature as a lockdown-default or not.
> 
> The lockdown feature is helpful for the normal user to configure the client securely at a time of social unrest, when used from a public terminal or when a novice user (who does not understand security, e.g. 99% of all users) wants to communicate securely.
> 
> Configuring any jabber client securely requires some skills and understanding of security. It also requires a certain amount of patient to navigate through and almost endless number of menus and sub-menus to enable all the security relevant features and disable the bad ones.
> 
> The average citizen on the other hand would be able to select 'LockDown' and trusting the software to turn on maximum security features. ("Lockdown" is more easily understood than "Do you want SSL 3.0 or TLS 1.2?").
> 

I think you've actually solidified Dave's points here.

>  
> - Client to notify server which method the client used to authenticate the server's
>   identity and if client is in Lockdown.
> 
> 
> How does the server know if the client is lying or not?
> 
> The server does not (and that's not what this feature is about).
> 
> This feature prevents accidental misconfiguration or laziness of the user.
> 
> Example: I'm running a private jabber server with around 200 users. I have strict a security guideline and currently have to trust my users to follow it. I trust the users to verify the server certificate against our own ROOT CA certificate.
> 

Adding a new trust anchor is just about impossible on some mobile platforms, and could get more difficult on more traditional ones.

> Users are lazy (quote). I ran a test and invalidated our server's certificate. No user should connect if he follows the security guidelines. Yet more than half of them connected instantaneously (auto-reconnect). 
> 
> Those users configured their client not to verify the server certificate at all. Because configuring the client this way is easier than importing the ROOT CA certificate.
> 
> The lazy option is to not verify the server's certificate. The lazy option is the insecure option
> 
> Yes, the user can hack the client and lie about if the client has correctly verified the server cert. This would take more time and work than importing the ROOT CA certificate.
> 
> The lazy option becomes importing the ROOT CA certificate. Now the lazy option is the secure option.
> 

All it takes is for *one* (or a small handful) of your users to hack their client, and share that hacked client with other users.  If the platform the client runs on prevents new trust anchors from being installed, then getting the hacked client becomes the lazy option.

> It's the same argument why the car beeps when the driver does not put on his seat belt. Yes, the drive can hack his car and disable the beeper. But the lazy option is to put on the seat belt.
> 

The car hack is to get a fastener unattached to the belt, and buckle that in.  You can find them on Ebay and Amazon for just about all models.

Sounds a lot like the preceding client hack.

>  
> 
> As an aside, channel binding obviates the need for at least the former, since it ties in authentication with the TLS channel in such a ways that there can't be a MITM between the client and server without the authentication being broken anyway.
> 
> Do you have more details on 'channel binding' for clients? This sounds interesting.

< http://tools.ietf.org/html/rfc5056 >

- m&m

Matthew A. Miller
< http://goo.gl/LK55L >

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 496 bytes
Desc: Message signed with OpenPGP using GPGMail
URL: <https://www.jabber.org/jdev/attachments/20131114/10bce70d/attachment-0001.pgp>