The web is changing. Historically it’s been painfully easy to request resources from remote locations (such as stylesheets, scripts, images, and loading pages in iframes) – but this has brought along a whole world of security issues that browsers are continuing to try and resolve.
This openness has come to define what web development is all about: Dead simple sharing of resources and ability to get started. It’s very likely that the lack of restrictions placed on these historical page elements will continue to plague browser developers for many years to come.
That doesn’t mean that browsers have to make the same “mistakes” going forward.
This is where the new W3C Access Control specification comes into play.
All the new cross-domain-capable technologies that are coming to browsers will be requiring the use of Access Controls from the get-go, including:
The Access Control specification has been one of the most-rapidly-changing specifications that I’ve seen. I wrote a demo early this year and have had to update it at least twice since then in order to match the updated APIs – and it appears as if they may have even changed again.
Right now the specification requires that any resource that you wish to make accessible in a cross-domain manner must include an extra header specifying which site(s) are allowed to access it.
If you wish to allow any site to access your resource you would use:
and if you only wanted one other domain to access it you would use:
This is important: It now means that site owners must make a conscious decision to enable cross-domain access of their resources (in contrast to images, stylesheets, and scripts which are always made available cross-domain with no way to disable it).
(There are a number of other headers specified by the Access Control specification, for more fine-grained access.)
There is going to be a lot of confusion and anger regarding this large, fundamental, change to the style of these upcoming APIs: They aren’t like the web that we know and love!
The best write-up that I’ve seen, to date, was by Jonas Sicking of Mozilla on the Ogg Mailing lists. This one section, in particular, is particularly poignant:
Why not use the same policy as for <img>?
Yes, we could definitely do the same for <video> as we have for <img>. But it will come with the same downsides. It will mean that we will have to be much more cautious with how we develop the API for
We could say that the captions callback would work, but only if the video was loaded from same site, or if had the Access-Control-Allow-Origin:* header set. However this will likely result in random bugs like captions sometimes failing since the developer had perfect hearing and so didn’t do a lot of testing with captions. In general accessibility is hard enough to get people to do correct that I’m reluctant to add features that work great as long as you don’t take accessibility into account, but where you have to take extra steps to get accessibility to work.
Similar arguments goes for accessing the size of the video file (for example through progress events). We can not allow that to work for cross-site loads unless the site has opted in. This is because we likely won’t know that it’s actually a video that is being downloaded until after the first progress events have been fired. This means that you could use <video> to measure file sizes for arbitrary files that are otherwise protected by firewalls and/or logins.
If we always restrict usage of <video> to the cases when we know that the video is private data we will be much more free to develop APIs and functionality since we won’t have to worry about protecting the data inside it, or deal with error conditions when someone tries to use sensitive APIs from a cross-site loaded video that didn’t have Access-Control-Allow-Origin:*.
I recommend that you take the time to read his whole piece as it’s worth it to gain a full understanding of the problems at play here (especially related to the <video/> tag).
One thing is clear: Security is being addressed center-stage in the new web APIs. This is going to be good as it’ll prevent horrible security bugs going forward while, at the same time, change the landscape of web development in a very fundamental way. The web had its fun but now reality is starting to set in – it’s time to get to work.
I’m reminded of the recent release of a crazy hack: transmitting data via URL encoded strings in stylesheets, named CSSHttpRequest. It’s an insane technique (in the best possible sense of the word) and well outside the realm of most users. Even though the syntax and technique is different, the security/information-leak implications of this are every-bit as real as those presented by JSONP.
Boris (November 19, 2008 at 8:27 am)
Actually, is not going to require access-control for the time being. See recent WHATWG mailing list discussion.
Bart van Heukelom (November 21, 2008 at 12:50 pm)
I don’t get it, how is this going to improve any security?
It does not protect users from sites that request resources from malicious servers, because the malicious admins of those servers can choose to allow any request.
It does not protect servers from malicious users, because malicious users can use a hacked browser which ignores these rules.
So what’s up with this?
Jaka Jancar (November 21, 2008 at 6:56 pm)
It protects sites from malicious sites doing XSRF, I guess. Maybe something else too.
Personally, all of this is starting to stink to me. You shouldn’t have to try so hard to develop secure web apps.