Shamir's Secret Sharing

This article has multiple issues. Please help or discuss these issues on the talk page. (Learn how and when to remove these template messages) This article may be too technical for most readers to understand. Please to make it understandable to non-experts, without removing the technical details. (March 2014) (Learn how and when to remove this template message) This article includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations. Please help to improve this article by introducing more precise citations. (February 2019) (Learn how and when to remove this template message) (Learn how and when to remove this template message)

Shamir's Secret Sharing, formulated by Adi Shamir, is one of the first secret sharing schemes in cryptography. It is based on polynomial interpolation over finite fields.

High-level explanation[]

Shamir's Secret Sharing (SSS) is used to secure a secret in a distributed way, most often to secure other encryption keys. The secret is split into multiple parts, called shares. These shares are used to reconstruct the original secret.

To unlock the secret via Shamir's secret sharing, a minimum number of shares are needed. This is called the threshold, and is used to denote the minimum number of shares needed to unlock the secret. An adversary who discovers any number of shares less than the threshold will not have any additional information about the secured secret-- this is called perfect secrecy. In this sense, SSS is a generalisation of the one-time pad (which is effectively SSS with a two-share threshold and two shares in total).

Let us walk through an example:

Problem: Company XYZ needs to secure their vault's passcode. They could use something standard, such as AES, but what if the holder of the key is unavailable or dies? What if the key is compromised via a malicious hacker or the holder of the key turns rogue, and uses their power over the vault to their benefit?

This is where SSS comes in. It can be used to encrypt the vault's passcode and generate a certain number of shares, where a certain number of shares can be allocated to each executive within Company XYZ. Now, only if they pool their shares can they unlock the vault. The threshold can be appropriately set for the number of executives, so the vault is always able to be accessed by the authorized individuals. Should a share or two fall into the wrong hands, they couldn't open the passcode unless the other executives cooperated.

Mathematical formulation[]

Shamir's Secret Sharing is an ideal and perfect ${\displaystyle \left(k,n\right)}$-threshold scheme. In such a scheme, the aim is to divide a secret ${\displaystyle S}$ (for example, the combination to a safe) into ${\displaystyle n}$ pieces of data ${\displaystyle S_{1},\ldots ,S_{n}}$ (known as shares) in such a way that:

1. Knowledge of any ${\displaystyle k}$ or more ${\displaystyle S_{i}}$ pieces makes ${\displaystyle S}$ easily computable. That is, the complete secret ${\displaystyle S}$ can be reconstructed from any combination of ${\displaystyle k}$ pieces of data.
2. Knowledge of any ${\displaystyle k-1}$ or fewer ${\displaystyle S_{i}}$ pieces leaves ${\displaystyle S}$ completely undetermined, in the sense that the possible values for ${\displaystyle S}$ seem as likely as with knowledge of ${\displaystyle 0}$ pieces. The secret ${\displaystyle S}$ cannot be reconstructed with fewer than ${\displaystyle k}$ pieces.

If ${\displaystyle n=k}$, then every piece of the original secret ${\displaystyle S}$ is required to reconstruct the secret.

One can draw an infinite number of polynomials of degree 2 through 2 points. 3 points are required to define a unique polynomial of degree 2. This image is for illustration purposes only — Shamir's scheme uses polynomials over a finite field, not representable on a 2-dimensional plane.

The essential idea of the scheme is based on Lagrange interpolation theorem, specifically that ${\displaystyle k\,\!}$ points is enough to uniquely determine a polynomial of degree less than or equal to ${\displaystyle k-1\,\!}$. For instance, 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. We assume our secret ${\displaystyle S}$ can be represented as an element ${\displaystyle a_{0}}$ of a finite field ${\displaystyle GF(q)}$. We choose at random ${\displaystyle k-1}$ elements, ${\displaystyle a_{1},\cdots ,a_{k-1}\,\!}$, from ${\displaystyle GF(q)}$ and construct the polynomial ${\displaystyle f\left(x\right)=a_{0}+a_{1}x+a_{2}x^{2}+a_{3}x^{3}+\cdots +a_{k-1}x^{k-1}\,\!}$. Let us construct any ${\displaystyle n\,\!}$ points out of it, for instance set ${\displaystyle i=1,\ldots ,n\,\!}$ to retrieve ${\displaystyle \left(i,f\left(i\right)\right)\,\!}$. Every participant is given a point (a non-zero integer input to the polynomial, and the corresponding integer output). Given any subset of ${\displaystyle k\,\!}$ of these pairs, we can obtain ${\displaystyle a_{0}}$ using interpolation, with one possible formulation as below:

${\displaystyle f(0)=\sum _{j=0}^{k-1}y_{j}\prod _{\begin{smallmatrix}m\,=\,0\\m\,\neq \,j\end{smallmatrix}}^{k-1}{\frac {x_{m}}{x_{m}-x_{j}}}}$.

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 ${\displaystyle (S=1234)\,\!}$.

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

${\displaystyle (a_{0}=1234;a_{1}=166;a_{2}=94),\,\!}$ where ${\displaystyle a_{0}}$ is secret

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

${\displaystyle f(x)=1234+166x+94x^{2}\,\!}$

We construct six points ${\displaystyle D_{x-1}=(x,f(x))}$ from the polynomial:

${\displaystyle D_{0}=(1,1494);D_{1}=(2,1942);D_{2}=(3,2578);D_{3}=(4,3402);D_{4}=(5,4414);D_{5}=(6,5614)\,\!}$

We give each participant a different single point (both ${\displaystyle x\,\!}$ and ${\displaystyle f(x)\,\!}$). Because we use ${\displaystyle D_{x-1}}$ instead of ${\displaystyle D_{x}}$ the points start from ${\displaystyle (1,f(1))}$ and not ${\displaystyle (0,f(0))}$. This is necessary because ${\displaystyle f(0)}$ is the secret.

Reconstruction[]

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

Consider ${\displaystyle \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)\,\!}$.

We will compute Lagrange basis polynomials:

${\displaystyle \ell _{0}(x)={\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}}\,\!}$

${\displaystyle \ell _{1}(x)={\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\,\!}$

${\displaystyle \ell _{2}(x)={\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}}\,\!}$

Therefore

${\displaystyle {\begin{aligned}f(x)&=\sum _{j=0}^{2}y_{j}\cdot \ell _{j}(x)\\[6pt]&=y_{0}\ell _{0}(x)+y_{1}\ell _{1}(x)+y_{2}\ell _{2}(x)\\[6pt]&=1942\left({\frac {1}{6}}x^{2}-{\frac {3}{2}}x+{\frac {10}{3}}\right)+3402\left(-{\frac {1}{2}}x^{2}+{\frac {7}{2}}x-5\right)+4414\left({\frac {1}{3}}x^{2}-2x+{\frac {8}{3}}\right)\\[6pt]&=1234+166x+94x^{2}\end{aligned}}}$

Recall that the secret is the free coefficient, which means that ${\displaystyle S=1234\,\!}$, and we are done.

Computationally efficient approach[]

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

An optimized approach to use Lagrange polynomials to find ${\displaystyle f(0)}$ is defined as follows:

${\displaystyle f(0)=\sum _{j=0}^{k-1}y_{j}\prod _{\begin{smallmatrix}m\,=\,0\\m\,\neq \,j\end{smallmatrix}}^{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 ${\displaystyle S}$ with every ${\displaystyle D_{i}}$ that she finds.

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

${\displaystyle 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[]

This is a polynomial curve over a finite field—now the order of the polynomial has seemingly little to do with the shape of the graph.

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 ${\displaystyle p\in \mathbb {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 ${\displaystyle p}$ that is bigger than the number of participants and every ${\displaystyle a_{i}}$ (including ${\displaystyle a_{0}=S}$) and we have to calculate the points as ${\displaystyle (x,f(x){\bmod {p}})}$ instead of ${\displaystyle (x,f(x))}$.

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

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

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

Suppose again that Eve finds ${\displaystyle D_{0}=\left(1,1494\right)}$ and ${\displaystyle D_{1}=\left(2,329\right)}$, this time the public info is: ${\displaystyle n=6,k=3,p=1613,f(x)=a_{0}+a_{1}x+\dots +a_{k-1}x^{k-1}\mod {p},a_{0}=S,a_{i}\in \mathbb {N} }$ so she:

This time she can't stop because ${\displaystyle (m_{1}-m_{2})}$ could be any integer (even negative if ${\displaystyle m_{2}>m_{1}}$) so there are an infinite amount of possible values for ${\displaystyle a_{1}}$. She knows that ${\displaystyle [448,445,442,\ldots ]}$ always decreases by 3 so if ${\displaystyle 1613}$ was divisible by ${\displaystyle 3}$ she could conclude ${\displaystyle a_{1}\in [1,4,7,\ldots ]}$ but because it's prime she can't conclude even 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
from __future__ import print_function

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(secret, minimum, shares, prime=_PRIME):
    """
    Generates a random shamir pool for a given secret, returns share points.
    """
    if minimum > shares:
        raise ValueError("Pool secret would be irrecoverable.")
    poly = [secret] + [_RINT(prime - 1) for i in range(minimum - 1)]
    points = [(i, _eval_at(poly, i, prime))
              for i in range(1, shares + 1)]
    return 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) < 3:
        raise ValueError("need at least three shares")
    x_s, y_s = zip(*shares)
    return _lagrange_interpolate(0, x_s, y_s, prime)

def main():
    """Main function"""
    secret = 1234
    shares = make_random_shares(secret, minimum=3, shares=6)

    print('Secret:                                                     ',
          secret)
    print('Shares:')
    if shares:
        for share in shares:
            print('  ', share)

    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:]))

if __name__ == '__main__':
    main()

Properties[]

Some of the useful properties of Shamir's ${\displaystyle \left(k,n\right)\,\!}$ threshold scheme are:

1. Secure: Information theoretic security.
2. Minimal: The size of each piece does not exceed the size of the original data.
3. Extensible: When ${\displaystyle k\,\!}$ is kept fixed, ${\displaystyle D_{i}\,\!}$ pieces can be dynamically added or deleted without affecting the other pieces.
4. 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.
5. 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, S2CID 16321225.

• 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, Lecture Notes in Computer Science, Casablanca: Springer, 10542: 225–234, doi:10.1007/978-3-319-68179-5_20, ISBN 978-3-319-68178-8.

External links[]

• Shamir's Secret Sharing in the Crypto++ library
• Shamir's Secret Sharing Scheme (ssss) – a GNU GPL implementation
• sharedsecret – implementation in Go
• s4 - online shamir's secret sharing tool utilizing HashiCorp's shamir secret sharing algorithm