If you want to encrypt the messages on the transport (which is a really good idea!), there has to be some shared knowledge between the sender (the client) and the server. This can be hardcoded, but that’s really not a good idea at all – if that “common shared” knowledge is ever compromised, an attacker could decipher and read all your messages.
Also, since it’s definitely not recommended practice, there’s no support of any kind in WCF to simplify using a shared secret. You’re on your own – you have to roll your own 100% of the way.
The only viable way to have a common shared secret exchanged in a safe way is to use a certificate. No way around this, sorry. The certificate doesn’t even have to be used for user authentication or anything – but it establishes a shared secret between the caller and the service and thus allows the caller to encrypt the messages in such a way only the intended recipient can actually decrypt and use them.
So I really don’t see any way you can get around having certificates on your servers – doesn’t need to be on every client, but on every server where your service runs.
Marc
PS: if you really want to investigate the “hardcoded shared secret” approach, you’ll need to think about this:
- how do you store a shared secret safely on each and every single one of your clients?
- how do you use information from that stored shared secret to encrypt your messages?
Typically, the approach would be two-fold:
- exchange some form of a private/public key pair; the server generates a key pair and keeps the private key to itself and shares the public key with the client (e.g. over a WCF message, for instance)
- using that private/public key pair, exchange a common shared secret, e.g. an “encryption key” that will symmetrically encrypt your messages (and since it’s symmetrical, the server can use the same key to decrypt the messages)
- setup infrastructure on your client (e.g. a WCF extension called a behavior) to inspect the message before it goes out and encrypt it with your shared secret
All in all, it’s really not trivial – anything simpler than that is not worth being called “security” at all.
If you look at all that work you will have to do – wouldn’t it be easier to just use the WCF built-in certificate mechanisms??
Decent security worth its salt is hard – so why not leverage what’s available instead of doing all the work yourself, or worse: come up with a half-baked solution that’s so easy to crack you could just as easily send everything in cleartext….. don’t under estimate the complexity and amount of code needed to handle even the most basic security scenarios – WCF does this all for you – for free and in a reliable and safe manner – use it! You won’t regret it!