Mobile Apps use HTTP. But they usually don’t use it to transfer HyperText – rather they are using it to transfer JSON, XML, or other data formats. Just like their web counterparts, secure transmission is desirable.
But, if you ever trace a fresh SSL connection, you know that its a nasty process:
- TCP handshake
- SSL handshake
- Server sends certificate
- DNS to CA
- TCP to CA
- OCSP to CA
- Finish SSL handshake
- Finally do what you wanted to do….
SSL is designed so that you can pick up some random certificate and check it dynamically. This is a good thing for the web, where the user coasts from site to site, happily discovering new content which needs new validation.
But this process is pretty costly, especially on mobile networks. For my own service, I just did a quick trace over 3G:
- DNS (1334ms)
- TCP handshake (240ms)
- SSL handshake (376ms)
- Follow certificate chain (1011ms) — server should have bundled this.
- DNS to CA (300ms)
- TCP to CA (407ms)
- OCSP to CA #1 (598ms) — StartSSL CA uses connection close on each!
- TCP to CA #2 (317ms)
- OCSP to CA #2 (444ms)
- Finish SSL handshake (1270ms)
With the web, this verification process makes some sense – you ask the CA to be your trust point and verify that he trusts the certificate provided.
But why do this with a mobile app? Your mobile app has a lot of trust with it – they downloaded it from you, its signed by Apple, and if the code has been compromised, well, heck, your app isn’t really running anyway.
What we really want for mobile apps is to bake the server’s certificate into the app. If the server’s certificate needs to change, you can auto-update your app. In the example above, doing so would have shaved about 3000ms off application startup time.
The downside of this is that if your certificate changes, your app won’t verify. Then what to do? Simple – force an auto update.
There is another advantage to this approach. If you can verify your own certs, you don’t need a CA provided certificate anyway. These silly 1-2 year expirations are no longer necessary. Sign your own cert, and verify it yourself. Since our CAs have been getting hacked left and right in 2011, this is probably even more secure.
PS: SSL is hard. In this one trace, I can spot at *least* 3 low-hanging-fruit optimizations. I haven’t mentioned them, because they are pervasive everywhere on the net. There are errors here at every level – the client is missing opportunities, the server is missing opportunities, and the CA is missing opportunities! It’s no wonder that SSL is slow. The chance that your combination of client + server + CA will have some dumb performance bug is ~99%.