In my last post, on threat modeling, I had mentioned that there would be a
follow up post would talk about the issues to authenticating the
communication from the server. My cohort and fellow Josh has been working
with me on some side projects with local small and mid-size business to
secure their applications (things like auto dealership websites that collect
information for credit checks) to offset all that money our investment
accounts have taken in the past 18 months with some extra income. In that
process we have noticed several issues that keep coming up that make it
harder to be confident we are talking to the application we think we are
talking to.

In this day and age phishing is so easy because it is hard to authenticate
the server to the client. There isn’t end to end trust. Ultimately the user
only has a handful of verification methods- does the website visually look
like the website they want to connect to, does the URL look like the correct
domain, and is the communication over a secure channel, none of which is
going to be obvious to non-technical users. The visual appearance is
incredibly easy to spoof, to the point where only the most lazy phisher
won’t put forth the effort. Short of sternography, the visual appearance
can’t be trusted, and sternography isn’t a viable option. So, here are a
couple of things you can do outside of the visual appearance.

- Don’t use multiple domain names. You can register multiple domains, but
always have them redirect to one domain, and never advertise anything but
that one domain. This prevents dilution of the domain name, and trains the
user to only trust one domain. Don’t use BobsFordMazdaLincoln.com and
BobsMazdaLincolnFord.com, because a phisher can set up bobsLincolnMazdaFord.
com or similar name. This is obviously a contrived example, but plenty of
companies have a variety of domains for different purposes (Microsoft is
really bad about this, and with their live ID being an SSO for all of their
domains it is easy for me to phish that credential to great payoff).

It is better to use sub-domains if you have separate sites associated with
one company. It is also better to try and have a simple and short domain
name, without too many words in it. bobscars.com is way better than
BobsMazdaLincolnFord.com because it is much harder to create a variant that
fools the users. Bob could then have ford.bobscars.com, mazda.bobscars.com,
etc (and this scales if bob ever opens other dealerships). Also, users are
more likely to remember your domain name and it will have fewer common
mistype permutations (which you should buy, domains are cheap) if it is
simple (something for which I am probably guilty with analyticalengine.net,
a url that even I mistype occasionally).

- Don’t go crazy with sub domains. You should probably only go one (or very
rarely two) deep. mazda.bobscars.com is pretty simple to visually parse as
being part of bobscars.com, but year2009.newcars.mazda.fordcorp.bobscars.com
is going to be very easy to visually spoof to end users. We need to train
customers to look at the domain name, and in order to do that it needs to be
as apparent as possible. IE 8 does a good job calling this out, and there is
a similar firefox plugin to highlight the domain name, but with many people
still using IE 6 we need to focus on getting them to visually parse and
recognize the domain (it would also be nice to get them to upgrade to a new
browser). If we go overboard with subdomains we make the domain non-obvious
and thus make it easy to spoof.

- Use SSL liberally, and use EV certs. The use of EV certs provides visual
evidence in the location bar of the browser that this really is the
corporation I intend to communicate with. It is one more protection that
allows the user to visual identify the site. It offers more than that
though, as it can attest to the integrity of the communication back and
forth between the site. Afore mentioned cohort Josh has a post on his blog
<http://pentesterconfessions.blogspot.com/2008/10/no-longer-confident.html>
about using Ettercap to intercept communication and alter it in flight. The
specific scenario he targeted was javascript based logins, where the page is
served over http to improve performance but the login field uses javascript
to submit over https; using ettercap he can show how he can modify the
javascript while the page is being delivered so that it submits credentials
elsewhere.

He recommends that to maintain performance you specifically force users to
go to a separate page that is served start to finish over SSL. The problem
is that 1) you don’t get the EV Cert based visual confirmation on the
landing page if you do this and 2) if your landing page is sent in the clear
you can use Ettercap to modify the url to the login page so the user goes
offsite to submit credentials. Once a user is logged in you need to either
have a ridiculously short session limit or make sure you continue to
communicate over SSL, otherwise the sessionid will be sent in the clear
which is almost as valuable as the user credentials.

I think it is much better to ALWAYS use SSL with EV certs, forced on every
page. That way you get the visual validation of the cert on the landing
page, the customer sees the little lock through the whole communication, and
the entire conversation is resistant (not immune, but resistant) to
tampering. This will impact performance (though I think it might have the
advantageous effect of forcing cleaner website design) on dial up (I doubt
it is human noticable on broadband) but if you want to provide some level of
certainty to the user it is the way to go. Obviously, this should be weighed
based on the risk of the site; paypal and banks should obviously do this,
engadget probably can do without. As a final piece of advice, make sure that
you set the cookie flag so that session information is only sent over secure
channels.

These aren’t bullet proof assurances. It is all based on visually notifying
the user that this is the site the really mean to be on. It is very reliant
on training user behavior, a generally unreliable approach, and then on the
user consistently being wary, which is even more unreliable. However, at
this point we don’t have much else we can really do. Sandbags may not be an
ideal replace for building on high ground, but it beats letting the water
in. End to end trust is an unsolved problem but we do what we can.

 

 

[Ph4nt0m] <http://www.ph4nt0m.org/>  

[Ph4nt0m Security Team]

                   <http://blog.ph4nt0m.org/> [EMAIL PROTECTED]

          Email:  [EMAIL PROTECTED]

          PingMe:
<http://cn.pingme.messenger.yahoo.com/webchat/ajax_webchat.php?yid=hanqin_wu
hq&sig=9ae1bbb1ae99009d8859e88e899ab2d1c2a17724> 

          === V3ry G00d, V3ry Str0ng ===

          === Ultim4te H4cking ===

          === XPLOITZ ! ===

          === #_# ===

#If you brave,there is nothing you cannot achieve.#

 

 


--~--~---------~--~----~------------~-------~--~----~
 要向邮件组发送邮件,请发到 [email protected]
 要退订此邮件,请发邮件至 [EMAIL PROTECTED]
-~----------~----~----~----~------~----~------~--~---

<<inline: image001.gif>>

回复