We have a great responsibility at FastMail to keep your email secure. As part of our continual process to maintain and improve security, we recently made a number of changes. This blog post summarises what we've done and why it makes your email even more secure. It's also a useful checklist of security measures to think about if you run your own web application.
This is a technical post for information only. You do not need to make any changes to your FastMail account or your email software.
Cross-site request forgery is a common security problem on the internet. Briefly, if you are browsing a malicious website A, that page can make a GET or POST request to any other website B, which includes any authentication cookies you have for website B. The page making the request from website A can't see the response, but if the request changes state on the server it could compromise the account, for example by forwarding all of your mail to the attacker's account.
FastMail has long had robust CSRF protection throughout our application. However, one thing we didn't protect from CSRF was the ability to log in to an account. At first glance, an attacker being able to log someone into the attacker's own account doesn't seem like much of a security problem. However, there are two issues that can arise from this:
An attacker could manage to confuse the target into sending an email from the wrong account. This is easy to do if you're not expecting yourself to be logged in elsewhere. The email could then be read by the attacker.
Any stored XSS vulnerabilities that only affect the user's account suddenly become much more exploitable. For example, suppose a user's folder name was not properly escaped somewhere: it could be used to inject a script into the page. Since only the user can modify the folder name, and the pages that show that folder are only accessible when logged in as that user, this does not help an attacker target anyone but himself. However, if the attacker can log someone else into his account and force the script to run, then he could potentially access any other accounts that the target is currently logged in to.
Given these risks, we've now taken steps to prevent logging in to a FastMail account from anywhere other than our own login form. Since on the homepage we don't yet have a session (at least not one that lives longer than a couple of minutes), we're doing strict referrer checking instead of using a CSRF token. The "Referer" header in the POST request must be present and must match the protocol and host (normally https://www.fastmail.fm), otherwise the login is rejected. (And yes, the referrer header really was standardised with an incorrect spelling.)
Whilst there are several ways of stripping a referrer header, as far as we are aware there is no way to fake one without using a browser extension or the like (at which point the extension could do anything it likes to the page, and no amount of CSRF tokens is going to save you).
FastMail has long had a feature where you could host some files or a small website via your FastMail account. For the account firstname.lastname@example.org, for example, we offered the ability to host files at joebloggs.fastmail.fm.
To resolve this, we've moved all user content on to a new domain, user.fm, and set up redirects so existing URLs will continue to work. For example, joebloggs.fastmail.fm will now redirect to joebloggs.fastmail.fm.user.fm.
Please note: this does not apply if you have your own domain. That will continue to work just as before. The move is only for content at one of our domains.
Cross-site scripting (more commonly known as XSS) is by far the most common type of security vulnerability to occur in web applications. An XSS vulnerability allows an attacker to inject a script into a web page on the target site, allowing them to access any data the user is currently authorised to access.
Arguably one of the biggest steps towards improving the security of web applications in recent years is the introduction of the Content-Security-Policy (CSP) header. You can use this to control what resources a modern browser will allow the webpage to load and run. We've been testing this on our beta server for some time, and we've now rolled it out to production. The CSP we are using for most of our webmail pages is the following:
default-src 'self'; script-src 'self' 'unsafe-eval' https://api.pin.net.au; style-src 'self' 'unsafe-inline'; font-src data:; img-src *; media-src 'none'; object-src 'none'; report-uri /log/csp
The most import thing about this policy is that it does not allow inline scripts to run, or for scripts to load from domains other than our own (with a specific exception for our payment provider). This means that should a future XSS bug be discovered, an attacker cannot exploit it against you if you are using a modern browser: the only scripts that can run are those hosted on our own domain (which are all written by us and known to be safe).
The other big change we're going to be making next week is to move most
user content off the fastmail.fm domain. When you open an attachment it
will load in the fastmailusercontent.com domain instead. This is an
isolation measure to provide an extra layer of security via the browser
cross-origin restrictions. At the moment, we use a
Content-Disposition: attachment header to force the browser to
download rather than open any potentially dangerous files (all files
except for a few specific safe MIME types such as JPEG images). Because
each attachment will be isolated on a different domain (with a
per-message authorisation key), we will also be able to allow more types
to be opened in the browser, as each attachment is effectively sandboxed
and cannot access sensitive data.
Like many other internet companies, we recently introduced a security bug bounty program as a way of encouraging responsible disclosure and rewarding security researchers for their hard work.
We'd like to say a public thanks to the first two recipients of our bounty: Prasant Sharma for disclosing a stored XSS vulnerability in our support ticket system, for which we awarded $1000, and V. Harish Kumar for finding two minor self-XSS vulnerabilities, for which we awarded $200.
We welcome all whitehat security researchers who wish to help us maintain our high security. Full details of the rules and how to submit a vulnerability are available on the security issue reporting guidelines help page.
The following additional security measures have been in place for some time, but we've not blogged about them before.
We send the following header back with all of our responses:
This tells all modern browsers to, from that point on, only connect to us over HTTPS, even if the user types in a non-HTTPS URL. This reduces the chance of a man-in-the-middle attack intercepting an insecure connection and proxying the user, instead of redirecting them to the secure site.
With basic support even in browsers as old as Internet Explorer 8, the
X-Frame-Options header is the easiest and best way to prevent
click-jacking and other attacks based on embedding your web app inside a
malicious site. By setting the header
X-Frame-Options: SAMEORIGIN, we
only allow our pages to be framed by other pages on our domain.
Content type sniffing is where browsers ignore the MIME type sent by the
server and interpret the content as something else. This can be
dangerous, as something that the server thought was safe (such as an
image) could be interpreted by the browser as an HTML page, opening you
up to XSS attacks. We disable this behaviour by setting the
X-Content-Type-Options: nosniff header.
We strongly believe in making the internet more secure, and one of the ways we feel we can help make this happen is to publicly document more of the security measures we have in place. This serves to both help educate and inform other sites, and to allow public scrutiny to improve our processes.
Thanks for reading, and as ever, thanks for using FastMail.