Shamir's Secret Sharing (opens in new tab)

I've been wanting to use this in combination with Rabin's Information Dispersal algorithm to create an autonomous distributed file storage system. You would have redundancy, but redundancy in a way that you only require k of n "pieces" to recover your original file (or data object). This is pretty cool, because you don't need to have 10 copies of a 1 GB file (10 GB total) spread about the web in order to achieve a high probability of being able to recover your data.

Open source implementations available on GitHub:

Python - https://github.com/blockstack/secret-sharing

PHP - https://github.com/mathieuk/secretsharer

Node - https://github.com/amper5and/secrets.js

Go - https://github.com/codahale/sss

C - https://github.com/fletcher/c-sss

Ruby - https://github.com/lian/shamir-secret-sharing

Java - https://github.com/timtiemens/secretshare

Rust - https://github.com/sellibitze/secretshare

Vault uses this technique https://www.vaultproject.io/

Some software using this algorithm:

http://www.digital-scurf.org/software/libgfshare

https://github.com/ryancdotorg/threshcrypt (uses libgfshare, written by me - handles large files by splitting a key into shares and encrypting them with password-derived keys)

https://github.com/amper5and/secrets.js/

http://passguardian.com/ (uses secrets.js)

http://point-at-infinity.org/ssss/

I learned this from reading the original paper [0], which is only two pages and is easily accessible to anyone with a high school level understanding of math.

[0] http://cs.jhu.edu/~sdoshi/crypto/papers/shamirturing.pdf

What's especially cool about this technique is that unlike most crypto proofs it does not assume the existence of one-way functions (none have been found yet) nor does it require a computationally bounded adversary.

Instead this technique is information theoretically secure so even an adversary with the ability to perform exponentially slow algorithms instantly could not find the secret.

All this in a two page paper that only required high school math!

PS - The "Shamir" who found this technique is the S in RSA

I run a small operation providing websites/online storage/email for a couple of friends and small businesses, and I use this as recovery solution to a master key. I distributed the encrypted very big master key, full system documentation and a part of the decryption key to the master key to a couple of people including a public notary. This way, should it ever get necessary, it will be possible for them to access my encrypted files. Say I get hit by a bus or something similar.

Thank you, Shamir!

The wikipedia link gets mathematical very quickly.

With Shamir's secret sharing you can take a file and split it for example into 3 parts. Only 2 parts would need to be combined to re-create the original. This would be 2 of 3 in Bitcoin parlance.

This reminds me of the Simpsons episode with the Flying Hellfish: https://en.wikipedia.org/wiki/Raging_Abe_Simpson_and_His_Gru...

I created a C# implementation and explained how the math works in http://www.moserware.com/2011/11/life-death-and-splitting-se...

Super simple implementation in C: https://github.com/duncanburke/libshamir

That's how I protect my bitcoin