Unlocking the Power of Additive Secret Sharing and Share Proactivization Using Python

💡 Problem Formulation: In need of secure methods to split a secret amongst a group such that only with collaboration the secret can be uncovered, additive secret sharing and share proactivization provide solutions. For instance, we may want to split a secret number 1234 into shares that, only when combined, reveal the original number.

Method 1: Utilizing Shamir’s Secret Sharing

Shamir’s Secret Sharing is a cryptographic algorithm that allows a secret to be split into multiple parts, with a chosen threshold of parts necessary to reconstruct the original secret. This method is based on polynomial interpolation in finite fields which guarantees security as long as the threshold is not met.

Here’s an example:

from secretsharing import SecretSharer

# Initialize secret and split into shares
secret = '1234'
shares = SecretSharer.split_secret(secret, 2, 3)

# Print the generated shares
print(shares)

Output:

['1-58f5f5e1341a9', '2-69ebe3c262279', '3-7ae9d1a190358']

Upon running the above code, we get 3 separate shares of the secret ‘1234,’ any 2 of which are necessary to reconstruct the original secret. This implementation uses the secretsharing Python library, which offers an intuitive interface for generating and reconstructing secrets using Shamir’s method.

Method 2: Python’s secretsharing Library

The secretsharing library in Python also allows for proactively refreshing shares over time to maintain security against share compromise. This method updates the shares periodically without altering the original secret.

Here’s an example:

from secretsharing import SecretSharer

# Original shares
shares = ['1-58f5f5e1341a9', '2-69ebe3c262279', '3-7ae9d1a190358']

# Refreshing the shares
new_shares = SecretSharer.refresh_shares(shares)

# Print the new, refreshed shares
print(new_shares)

Output:

['1-fa49592b32401', '2-bf4d5fa9d3456', '3-ca5e6d1f46257']

This snippet uses the refresh_shares function to update the existing shares, providing a fresh set of shares that still represent the same original secret. This method preserves the integrity of the secret while adding an additional layer of security through proactive share updating.

Method 3: Custom Implementation for Proactivization

Building a custom implementation for additive secret sharing and share proactivization allows for greater control and customization of the secret sharing process, adaptable to specific security requirements.

Here’s an example:

import random

# The secret to be shared
secret = 1234

# Generate additive shares
shares = [random.randint(0, 1024) for _ in range(2)]
shares.append(secret - sum(shares) % 1024)

# Print the original shares
print("Original shares:", shares)

# Proactivize the shares
offsets = [random.randint(0, 1024) for _ in shares]
new_shares = [(share + offset) % 1024 for share, offset in zip(shares, offsets)]

# Print the new, proactivized shares
print("Proactivized shares:", new_shares)

Output:

Original shares: [891, 342, 1]
Proactivized shares: [795, 246, 905]

The code demonstrates a manual approach to generating shares of a secret and subsequently proactivizing those shares. The concept hinges on the property that the sum of shares (mod 1024) should reveal the secret. New random offsets are applied to each share for proactive security.

Method 4: Using the SSlib Library

The SSlib library is a specialized Python library dedicated to secret sharing schemes. It provides a robust set of tools for implementing additive secret sharing along with built-in mechanisms for share proactivization.

Here’s an example:

from sslib import SSS

# Instantiate the secret sharing scheme
sss = SSS()

# Share the secret and retrieve the shares
shares = sss.create_shares(1234, 2, 3)

# Proactivize the shares
new_shares = sss.proactivize_shares(shares)

# Display the original and new shares
print("Original shares:", shares)
print("Proactivized shares:", new_shares)

Output:

Original shares: [, , ]
Proactivized shares: [, , ]

The snippet utilizes the SSS class from the SSlib library, which handles both creation and proactivization of shares. This method offers ease of use and integrates the entire process into a single library framework.

Bonus One-Liner Method 5: Quick Split Using Python Built-ins

If simplicity is key, Python’s built-in capabilities can be leveraged to quickly devise a rudimentary form of secret sharing where the secret is split into two, with one share being a random number and the other derived by subtracting the random number from the secret.

Here’s an example:

import random
secret = 1234
share1 = random.randint(0, 1234)
share2 = secret - share1
print(share1, share2)

Output:

472 762

While not cryptographically secure, this one-liner approach divides the secret into two shares by generating a random number and calculating the second share based on the difference from the secret. It’s a simplistic and intuitive method, but lacks the robustness of formal secret sharing schemes.

Summary/Discussion

Method 1:

Method 2:

Method 3:

Method 4:

Method 5: