Shamir’s Secret Sharing Algorithm | Cryptography

28 Jun, 2022
Cryptography is a technique of securing information and communications through the use of codes so that only those person for whom the information is intended can understand it and process it. Thus preventing unauthorized access to information. The prefix “crypt” means “hidden” and suffix graphy means “writing”. In this article, a type of cryptographic technique, Shamir’s secret sharing algorithm is discussed.Shamir’s Secret Sharing Algorithm: Shamir’s Secret Sharing is an algorithm in cryptography created by Adi Shamir. The main aim of this algorithm is to divide secret that needs to be encrypted into various unique parts.  
Let’s say S is the secret that we wish to encode.
It is divided into N parts: S1, S2, S3, ...., Sn.
After dividing it, a number K is chosen by the user in order to decrypt the parts and find the original secret.
It is chosen in such a way that if we know less than K parts, then we will not be able to find the secret S (i.e.) the secret S can not be reconstructed with (K – 1) parts or fewer.
If we know K or more parts from S1, S2, S3, ...., Sn, then we can compute/reconstructed our secret code S easily. This is conventionally called (K, N) threshold scheme.
Approach: The main idea behind the Shamir’s Secret Sharing Algorithm lies behind the concept that for the given K points we can find a polynomial equation with the degree (K – 1).Example:  
For the given two points, (x1, y1) and (x2, y2) we can find a linear polynomial ax + by = c.
Similarly, for the given three points, we can find a quadratic polynomial ax2 + bx + cy = d.
So, the idea is to build a polynomial with the degree (K – 1) such that the constant term is the secret code and the remaining numbers are random and this constant term can be found by using any K points out of N points generated from this polynomial by using Lagrange’s Basis Polynomial. For example: Let the secret code S = 65, N = 4, K = 2.  
Initially, in order to encrypt the secret code, we build a polynomial of degree (K – 1).Therefore, let the polynomial be y = a + bx. Here, the constant part ‘a’ is our secret code.Let b be any random number, say b = 15.Therefore, for this polynomial y = 65 + 15x, we generate N = 4 points from it.Let those 4 points be (1, 80), (2, 95), (3, 110), (4, 125). Clearly, we can generate the initial polynomial from any two of these 4 points and in the resulting polynomial, the constant term a is the required secret code.
Initially, in order to encrypt the secret code, we build a polynomial of degree (K – 1).
Therefore, let the polynomial be y = a + bx. Here, the constant part ‘a’ is our secret code.
Let b be any random number, say b = 15.
Therefore, for this polynomial y = 65 + 15x, we generate N = 4 points from it.
Let those 4 points be (1, 80), (2, 95), (3, 110), (4, 125). Clearly, we can generate the initial polynomial from any two of these 4 points and in the resulting polynomial, the constant term a is the required secret code.
In order to reconstruct the given polynomial back, the Lagrange basis Polynomial is used. The main concept behind the Lagrange polynomial is to form the Lagrange’s identities first and the summation of these identities give us the required function which we need to find from the given points. The following equations show how to compute them:  
For example, let’s say we wish to compute the given equation by using K = 2 points from the selected four points- (1, 80), (3, 110). The following illustration shows the step by step solution for this:  
Below is the implementation of the above approach: 
CPP
// C++ implementation of shamir’s// secret sharing algorithm #include <bits/stdc++.h>using namespace std; // Function to calculate the value// of y// y = poly[0] + x*poly[1] + x^2*poly[2] + ...int calculate_Y(int x, vector<int>& poly){    // Initializing y    int y = 0;    int temp = 1;     // Iterating through the array    for (auto coeff : poly) {         // Computing the value of y        y = (y + (coeff * temp));        temp = (temp * x);    }    return y;} // Function to perform the secret// sharing algorithm and encode the// given secretvoid secret_sharing(int S, vector<pair<int, int> >& points,                    int N, int K){    // A vector to store the polynomial    // coefficient of K-1 degree    vector<int> poly(K);     // Randomly choose K - 1 numbers but    // not zero and poly[0] is the secret    // create polynomial for this     poly[0] = S;     for (int j = 1; j < K; ++j) {        int p = 0;        while (p == 0)             // To keep the random values            // in range not too high            // we are taking mod with a            // prime number around 1000            p = (rand() % 997);         // This is to ensure we did not        // create a polynomial consisting        // of zeroes.        poly[j] = p;    }     // Generating N points from the    // polynomial we created    for (int j = 1; j <= N; ++j) {        int x = j;        int y = calculate_Y(x, poly);         // Points created on sharing        points[j - 1] = { x, y };    }} // This structure is used for fraction// part handling multiplication// and addition of fractionstruct fraction {    int num, den;     // A fraction consists of a    // numerator and a denominator    fraction(int n, int d)    {        num = n, den = d;    }     // If the fraction is not    // in its reduced form    // reduce it by dividing    // them with their GCD    void reduce_fraction(fraction& f)    {        int gcd = __gcd(f.num, f.den);        f.num /= gcd, f.den /= gcd;    }     // Performing multiplication on the    // fraction    fraction operator*(fraction f)    {        fraction temp(num * f.num, den * f.den);        reduce_fraction(temp);        return temp;    }     // Performing addition on the    // fraction    fraction operator+(fraction f)    {        fraction temp(num * f.den + den * f.num,                      den * f.den);         reduce_fraction(temp);        return temp;    }}; // Function to generate the secret// back from the given points// This function will use Lagrange Basis Polynomial// Instead of finding the complete Polynomial// We only required the poly[0] as our secret code,// thus we can get rid of x termsint Generate_Secret(int x[], int y[], int M){     fraction ans(0, 1);     // Loop to iterate through the given    // points    for (int i = 0; i < M; ++i) {         // Initializing the fraction        fraction l(y[i], 1);        for (int j = 0; j < M; ++j) {             // Computing the lagrange terms            if (i != j) {                fraction temp(-x[j], x[i] - x[j]);                l = l * temp;            }        }        ans = ans + l;    }     // Return the secret    return ans.num;} // Function to encode and decode the// given secret by using the above// defined functionsvoid operation(int S, int N, int K){     // Vector to store the points    vector<pair<int, int> > points(N);     // Sharing of secret Code in N parts    secret_sharing(S, points, N, K);     cout << "Secret is divided to " << N         << " Parts - " << endl;     for (int i = 0; i < N; ++i) {        cout << points[i].first << " "             << points[i].second << endl;    }     cout << "We can generate Secret from any of "         << K << " Parts" << endl;     // Input any M points from these    // to get back our secret code.    int M = 2;     // M can be greater than or equal to threshold but    // for this example we are taking for threshold    if (M < K) {        cout << "Points are less than threshold "             << K << " Points Required" << endl;    }     int* x = new int[M];    int* y = new int[M];     // Input M points you will get the secret    // Let these points are first M points from    // the N points which we shared above    // We can take any M points     for (int i = 0; i < M; ++i) {        x[i] = points[i].first;        y[i] = points[i].second;    }     // Get back our result again.    cout << "Our Secret Code is : "         << Generate_Secret(x, y, M) << endl;} // Driver Codeint main(){    int S = 65;    int N = 4;    int K = 2;     operation(S, N, K);    return 0;}
Secret is divided to 4 Parts - 
1 602
2 1139
3 1676
4 2213
We can generate Secret from any of 2 Parts
Our Secret Code is : 65
 
Reference: Shamir Secret Sharing 
surindertarika1234
as5853535
kk9826225
cryptography
Advanced Computer Subject
cryptography
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
ML | Monte Carlo Tree Search (MCTS)
Markov Decision Process
Basics of API Testing Using Postman
Copying Files to and from Docker Containers
Getting Started with System Design
Principal Component Analysis with Python
How to create a REST API using Java Spring Boot
Monolithic vs Microservices architecture
Fuzzy Logic | Introduction
Mounting a Volume Inside Docker Container