This article may be too technical for most readers to understand. Please help improve it to make it understandable to non-experts, without removing the technical details. (March 2014) (Learn how and when to remove this template message) |

**Shamir's Secret Sharing** is an algorithm in cryptography created by Adi Shamir. It is a form of secret sharing, where a secret is divided into parts, giving each participant its own unique part, where some of the parts or all of them are needed in order to reconstruct the secret.

Counting on all participants to combine the secret might be impractical, and therefore sometimes the *threshold scheme* is used where any $k$ of the parts are sufficient to reconstruct the original secret.

## Mathematical definition

The goal is to divide secret $S$ (for example, the combination to a safe) into $n$ pieces of data ${S}_{1},\dots ,{S}_{n}$ in such a way that:

- Knowledge of any $k$ or more ${S}_{i}$ pieces makes $S$ easy to compute. That is, the complete secret $S$ can be reconstructed from any combination of $k$ pieces of data.
- Knowledge of any $k-1$ or fewer ${S}_{i}$ pieces leaves $S$ completely undetermined, in the sense that the possible values for $S$ seem as likely as with knowledge of $0$ pieces. Said another way, the secret $S$ cannot be reconstructed with fewer than $k$ pieces.

This scheme is called $\left(k,n\right)$ threshold scheme. If $k=n$ then every piece of the original secret $S$ is required to reconstruct the secret.

## Shamir's secret-sharing scheme

The essential idea of Adi Shamir's threshold scheme is that 2 points are sufficient to define a line, 3 points are sufficient to define a parabola, 4 points to define a cubic curve and so forth. That is, it takes $k\phantom{\rule{thinmathspace}{0ex}}$ points to define a polynomial of degree $k-1\phantom{\rule{thinmathspace}{0ex}}$.

Suppose we want to use a $\left(k,n\right)\phantom{\rule{thinmathspace}{0ex}}$ threshold scheme to share our secret $S\phantom{\rule{thinmathspace}{0ex}}$, without loss of generality assumed to be an element in a finite field $F$ of size $P$ where $0<k\le n<P;S<P$ and $P$ is a prime number.

Choose at random $k-1\phantom{\rule{thinmathspace}{0ex}}$ positive integers ${a}_{1},\cdots ,{a}_{k-1}\phantom{\rule{thinmathspace}{0ex}}$ with ${a}_{i}<P$, and let ${a}_{0}=S\phantom{\rule{thinmathspace}{0ex}}$. Build the polynomial $f\left(x\right)={a}_{0}+{a}_{1}x+{a}_{2}{x}^{2}+{a}_{3}{x}^{3}+\cdots +{a}_{k-1}{x}^{k-1}\phantom{\rule{thinmathspace}{0ex}}$. Let us construct any $n\phantom{\rule{thinmathspace}{0ex}}$ points out of it, for instance set $i=1,\dots ,n\phantom{\rule{thinmathspace}{0ex}}$ to retrieve $\left(i,f\left(i\right)\right)\phantom{\rule{thinmathspace}{0ex}}$. Every participant is given a point (a non-zero integer input to the polynomial, and the corresponding integer output) along with the prime which defines the finite field to use. Given any subset of $k\phantom{\rule{thinmathspace}{0ex}}$ of these pairs, we can find the coefficients of the polynomial using interpolation. The secret is the constant term ${a}_{0}\phantom{\rule{thinmathspace}{0ex}}$.

## Usage

### Example

The following example illustrates the basic idea. Note, however, that calculations in the example are done using integer arithmetic rather than using finite field arithmetic. Therefore the example below does not provide perfect secrecy and is not a true example of Shamir's scheme. So we'll explain this problem and show the right way to implement it (using finite field arithmetic).

#### Preparation

Suppose that our secret is 1234 $(S=1234)\phantom{\rule{thinmathspace}{0ex}}$.

We wish to divide the secret into 6 parts $(n=6)\phantom{\rule{thinmathspace}{0ex}}$, where any subset of 3 parts $(k=3)\phantom{\rule{thinmathspace}{0ex}}$ is sufficient to reconstruct the secret. At random we obtain two ($k-1$) numbers: 166 and 94.

$({a}_{0}=1234;{a}_{1}=166;{a}_{2}=94)\phantom{\rule{thinmathspace}{0ex}}$

Our polynomial to produce secret shares (points) is therefore:

$f\left(x\right)=1234+166x+94{x}^{2}\phantom{\rule{thinmathspace}{0ex}}$

We construct 6 points ${D}_{x-1}=(x,f(x\left)\right)$ from the polynomial:

${D}_{0}=\left(1,1494\right);{D}_{1}=\left(2,1942\right);{D}_{2}=\left(3,2578\right);{D}_{3}=\left(4,3402\right);{D}_{4}=\left(5,4414\right);{D}_{5}=\left(6,5614\right)\phantom{\rule{thinmathspace}{0ex}}$

We give each participant a different single point (both $x\phantom{\rule{thinmathspace}{0ex}}$ and $f\left(x\right)\phantom{\rule{thinmathspace}{0ex}}$). Because we use ${D}_{x-1}$ instead of ${D}_{x}$ the points start from $(1,f(1\left)\right)$ and not $(0,f(0\left)\right)$. This is necessary because $f\left(0\right)$ is the secret.

#### Reconstruction

In order to reconstruct the secret any 3 points will be enough.

Let us consider $\left({x}_{0},{y}_{0}\right)=\left(2,1942\right);\left({x}_{1},{y}_{1}\right)=\left(4,3402\right);\left({x}_{2},{y}_{2}\right)=\left(5,4414\right)\phantom{\rule{thinmathspace}{0ex}}$.

We will compute Lagrange basis polynomials:

${\ell}_{0}=\frac{x-{x}_{1}}{{x}_{0}-{x}_{1}}\cdot \frac{x-{x}_{2}}{{x}_{0}-{x}_{2}}=\frac{x-4}{2-4}\cdot \frac{x-5}{2-5}=\frac{1}{6}{x}^{2}-\frac{3}{2}x+\frac{10}{3}\phantom{\rule{thinmathspace}{0ex}}$

${\ell}_{1}=\frac{x-{x}_{0}}{{x}_{1}-{x}_{0}}\cdot \frac{x-{x}_{2}}{{x}_{1}-{x}_{2}}=\frac{x-2}{4-2}\cdot \frac{x-5}{4-5}=-\frac{1}{2}{x}^{2}+\frac{7}{2}x-5\phantom{\rule{thinmathspace}{0ex}}$

${\ell}_{2}=\frac{x-{x}_{0}}{{x}_{2}-{x}_{0}}\cdot \frac{x-{x}_{1}}{{x}_{2}-{x}_{1}}=\frac{x-2}{5-2}\cdot \frac{x-4}{5-4}=\frac{1}{3}{x}^{2}-2x+\frac{8}{3}\phantom{\rule{thinmathspace}{0ex}}$

Therefore

$f\left(x\right)=\sum _{j=0}^{2}{y}_{j}\cdot {\ell}_{j}\left(x\right)\phantom{\rule{thinmathspace}{0ex}}$

$=1234+166x+94{x}^{2}\phantom{\rule{thinmathspace}{0ex}}$

Recall that the secret is the free coefficient, which means that $S=1234\phantom{\rule{thinmathspace}{0ex}}$, and we are done.

#### Computationally Efficient Approach

Considering that the goal of using polynomial interpolation is to find a constant in a source polynomial $S=f\left(0\right)$ using Lagrange polynomials "as it is" is not efficient, since unused constants are calculated.

An optimized approach to use Lagrange polynomials to find $L\left(0\right)$ is defined as follows:

$L\left(0\right)=\sum _{j=0}^{k-1}f\left({x}_{j}\right)\prod _{\underset{m\ne j}{m=0}}^{k-1}\frac{{x}_{m}}{{x}_{m}-{x}_{j}}$

#### Problem

Although the simplified version of the method demonstrated above, which uses integer arithmetic rather than finite field arithmetic, works fine, there is a security problem: Eve gains a lot of information about $S$ with every ${D}_{i}$ that she finds.

Suppose that she finds the 2 points ${D}_{0}=(1,1494)$ and ${D}_{1}=(2,1942)$, she still doesn't have $k=3$ points so in theory she shouldn't have gained any more info about $S$. But she combines the info from the 2 points with the public info: $n=6,k=3,f\left(x\right)={a}_{0}+{a}_{1}x+\cdots +{a}_{k-1}{x}^{k-1},{a}_{0}=S,{a}_{i}\in N$ and she :

- fills the $f\left(x\right)$-formula with $S$ and the value of $k:f\left(x\right)=S+{a}_{1}x+\cdots +{a}_{3-1}{x}^{3-1}\Rightarrow f\left(x\right)=S+{a}_{1}x+{a}_{2}{x}^{2}$
- fills (i) with the values of ${D}_{0}$'s $x$ and $f\left(x\right):1494=S+{a}_{1}1+{a}_{2}{1}^{2}\Rightarrow 1494=S+{a}_{1}+{a}_{2}$
- fills (i) with the values of ${D}_{1}$'s $x$ and $f\left(x\right):1942=S+{a}_{1}2+{a}_{2}{2}^{2}\Rightarrow 1942=S+2{a}_{1}+4{a}_{2}$
- does (iii)-(ii): $(1942-1494)=(S-S)+(2{a}_{1}-{a}_{1})+(4{a}_{2}-{a}_{2})\Rightarrow 448={a}_{1}+3{a}_{2}$ and rewrites this as ${a}_{1}=448-3{a}_{2}$
- knows that ${a}_{2}\in N$ so she starts replacing ${a}_{2}$ in (iv) with 0, 1, 2, 3, ... to find all possible values for ${a}_{1}$:
- ${a}_{2}=0\to {a}_{1}=448-3\times 0=448$
- ${a}_{2}=1\to {a}_{1}=448-3\times 1=445$
- ${a}_{2}=2\to {a}_{1}=448-3\times 2=442$
- $\dots $
- ${a}_{2}=148\to {a}_{1}=448-3\times 148=4$
- ${a}_{2}=149\to {a}_{1}=448-3\times 149=1$

- replaces ${a}_{1}$ by (iv) in (ii): $1494=S+(448-3{a}_{2})+{a}_{2}\Rightarrow S=1046+2{a}_{2}$
- replaces in (vi) ${a}_{2}$ by the values found in (v) so she gets $S\in [1046+2\times 0,1046+2\times 1,\dots ,1046+2\times 148,1046+2\times 149]$ which leads her to the information:

$S\in [1046,1048,\dots ,1342,1344]$. She now only has 150 numbers to guess from instead of an infinite number of natural numbers.

#### Solution

Geometrically this attack exploits the fact that we know the order of the polynomial and so gain insight into the paths it may take between known points this reduces possible values of unknown points since it must lie on a smooth curve.

This problem can be fixed by using finite field arithmetic. A field of size $p\in P:p>S,p>n$ is used. The graph shows a polynomial curve over a finite field, in contrast to the usual smooth curve it appears very disorganised and disjointed.

In practice this is only a small change, it just means that we should choose a prime $p$ that is bigger than the number of participants and every ${a}_{i}$ (including ${a}_{0}=S$) and we have to calculate the points as $(x,f(x\left)\phantom{\rule{1em}{0ex}}\right)$ instead of $(x,f(x\left)\right)$.

Since everyone who receives a point also has to know the value of $p$ so it may be considered to be publicly known. Therefore, one should select a value for $p$ that is not too low.

Low values of $p$ are risky because Eve knows $p>S\Rightarrow S\in [0,1,\dots ,p-2,p-1]$, so the lower one sets $p$, the fewer possible values Eve has to guess from to get $S$.

For this example we choose $p=1613$, so our polynomial becomes $f\left(x\right)=1234+166x+94{x}^{2}\phantom{\rule{1em}{0ex}}$ which gives the points: $\left(1,1494\right);\left(2,329\right);\left(3,965\right);\left(4,176\right);\left(5,1188\right);\left(6,775\right)$

This time Eve doesn't win any info when she finds a ${D}_{x}$ (until she has $k$ points).

Suppose again that Eve finds ${D}_{0}=\left(1,1494\right)$ and ${D}_{1}=\left(2,329\right)$, this time the public info is: $n=6,k=3,p=1613,f\left(x\right)={a}_{0}+{a}_{1}x+\cdots +{a}_{k-1}{x}^{k-1}\phantom{\rule{1em}{0ex}}$ so she:

- fills the $f\left(x\right)$-formula with $S$ and the value of $k$ and $p$: $f\left(x\right)=S+{a}_{1}x+\cdots +{a}_{3-1}{x}^{3-1}\phantom{\rule{1em}{0ex}}$
- fills (i) with the values of ${D}_{0}$'s $x$ and $f\left(x\right):1494=S+{a}_{1}1+{a}_{2}{1}^{2}-1613{m}_{1}\Rightarrow 1494=S+{a}_{1}+{a}_{2}-1613{m}_{1}$
- fills (i) with the values of ${D}_{1}$'s $x$ and $f\left(x\right):1942=S+{a}_{1}2+{a}_{2}{2}^{2}-1613{m}_{2}\Rightarrow 1942=S+2{a}_{1}+4{a}_{2}-1613{m}_{2}$
- does (iii)-(ii): $(1942-1494)=(S-S)+(2{a}_{1}-{a}_{1})+(4{a}_{2}-{a}_{2})+(1613{m}_{1}-1613{m}_{2})\Rightarrow 448={a}_{1}+3{a}_{2}+1613({m}_{1}-{m}_{2})$ and rewrites this as ${a}_{1}=448-3{a}_{2}-1613({m}_{1}-{m}_{2})$
- knows that ${a}_{2}\in N$ so she starts replacing ${a}_{2}$ in (iv) with 0, 1, 2, 3, ... to find all possible values for ${a}_{1}$:
- ${a}_{2}=0\to {a}_{1}=448-3\times 0-1613({m}_{1}-{m}_{2})=448-1613({m}_{1}-{m}_{2})$
- ${a}_{2}=1\to {a}_{1}=448-3\times 1-1613({m}_{1}-{m}_{2})=445-1613({m}_{1}-{m}_{2})$
- ${a}_{2}=2\to {a}_{1}=448-3\times 2-1613({m}_{1}-{m}_{2})=442-1613({m}_{1}-{m}_{2})$
- $\dots $

This time she can't stop because $({m}_{1}-{m}_{2})$ could be any integer (even negative if ${m}_{2}>{m}_{1}$) so there are an infinite amount of possible values for ${a}_{1}$. She knows that $[448,445,442,...]$ always decreases by 3 so if $1613$ was divisible by $3$ she could conclude ${a}_{1}\in [1,4,7,\dots ]$ but because it's prime she can't even conclude that and so she didn't win any information.

#### Python example

```
"""The following Python implementation of Shamir's Secret Sharing is
released into the Public Domain under the terms of CC0 and OWFa:
https://creativecommons.org/publicdomain/zero/1.0/
http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0
See the bottom few lines for usage. Tested on Python 2 and 3.
"""
from __future__ import division
import random
import functools
# 12th Mersenne Prime
# (for this application we want a known prime number as close as
# possible to our security level; e.g. desired security level of 128
# bits -- too large and all the ciphertext is large; too small and
# security is compromised)
_PRIME = 2**127 - 1
# 13th Mersenne Prime is 2**521 - 1
_rint = functools.partial(random.SystemRandom().randint, 0)
def _eval_at(poly, x, prime):
'''evaluates polynomial (coefficient tuple) at x, used to generate a
shamir pool in make_random_shares below.
'''
accum = 0
for coeff in reversed(poly):
accum *= x
accum += coeff
accum %= prime
return accum
def make_random_shares(minimum, shares, prime=_PRIME):
'''
Generates a random shamir pool, returns the secret and the share
points.
'''
if minimum > shares:
raise ValueError("pool secret would be irrecoverable")
poly = [_rint(prime) for i in range(minimum)]
points = [(i, _eval_at(poly, i, prime))
for i in range(1, shares + 1)]
return poly[0], points
def _extended_gcd(a, b):
'''
division in integers modulus p means finding the inverse of the
denominator modulo p and then multiplying the numerator by this
inverse (Note: inverse of A is B such that A*B % p == 1) this can
be computed via extended Euclidean algorithm
http://en.wikipedia.org/wiki/Modular_multiplicative_inverse#Computation
'''
x = 0
last_x = 1
y = 1
last_y = 0
while b != 0:
quot = a // b
a, b = b, a%b
x, last_x = last_x - quot * x, x
y, last_y = last_y - quot * y, y
return last_x, last_y
def _divmod(num, den, p):
'''compute num / den modulo prime p
To explain what this means, the return value will be such that
the following is true: den * _divmod(num, den, p) % p == num
'''
inv, _ = _extended_gcd(den, p)
return num * inv
def _lagrange_interpolate(x, x_s, y_s, p):
'''
Find the y-value for the given x, given n (x, y) points;
k points will define a polynomial of up to kth order
'''
k = len(x_s)
assert k == len(set(x_s)), "points must be distinct"
def PI(vals): # upper-case PI -- product of inputs
accum = 1
for v in vals:
accum *= v
return accum
nums = [] # avoid inexact division
dens = []
for i in range(k):
others = list(x_s)
cur = others.pop(i)
nums.append(PI(x - o for o in others))
dens.append(PI(cur - o for o in others))
den = PI(dens)
num = sum([_divmod(nums[i] * den * y_s[i] % p, dens[i], p)
for i in range(k)])
return (_divmod(num, den, p) + p) % p
def recover_secret(shares, prime=_PRIME):
'''
Recover the secret from share points
(x,y points on the polynomial)
'''
if len(shares) < 2:
raise ValueError("need at least two shares")
x_s, y_s = zip(*shares)
return _lagrange_interpolate(0, x_s, y_s, prime)
secret, shares = make_random_shares(minimum=3, shares=6)
print('secret and shares:', secret, shares)
print('secret recovered from minimum subset of shares', recover_secret(shares[:3]))
print('secret recovered from a different minimum subset of shares', recover_secret(shares[-3:]))
```

## Properties

Some of the useful properties of Shamir's $\left(k,n\right)\phantom{\rule{thinmathspace}{0ex}}$ threshold scheme are:

**Secure**: Information theoretic security.**Minimal**: The size of each piece does not exceed the size of the original data.**Extensible**: When $k\phantom{\rule{thinmathspace}{0ex}}$ is kept fixed, ${D}_{i}\phantom{\rule{thinmathspace}{0ex}}$ pieces can be dynamically added or deleted without affecting the other pieces.**Dynamic**: Security can be easily enhanced without changing the secret, but by changing the polynomial occasionally (keeping the same free term) and constructing new shares to the participants.**Flexible**: In organizations where hierarchy is important, we can supply each participant different number of pieces according to their importance inside the organization. For instance, the president can unlock the safe alone, whereas 3 secretaries are required together to unlock it.

A known issue in Shamir's Secret Sharing scheme is the verification of correctness of the retrieved shares during the reconstruction process, which is known as verifiable secret sharing. Verifiable secret sharing aims at verifying that shareholders are honest and not submitting fake shares.

## See also

- Secret sharing
- Lagrange polynomial
- Homomorphic secret sharing - A simplistic decentralized voting protocol.
- Two-man rule
- Partial Password

## References

- Shamir, Adi (1979), "How to share a secret",
*Communications of the ACM*,**22**(11): 612–613, doi:10.1145/359168.359176 .

- Liu, C. L. (1968),
*Introduction to Combinatorial Mathematics*, New York: McGraw-Hill . - Dawson, E.; Donovan, D. (1994), "The breadth of Shamir's secret-sharing scheme",
*Computers & Security*,**13**: 69–78, doi:10.1016/0167-4048(94)90097-3 . - Knuth, D. E. (1997),
*The Art of Computer Programming*, II: Seminumerical Algorithms (3rd ed.), Addison-Wesley, p. 505 .

- Benzekki, K. (2017), "A Verifiable Secret Sharing Approach for Secure MultiCloud Storage",
*In Ubiquitous Networking*, Casablanca: Springer, 10542 .