Threshold Secret Sharing
Efficient pureRust library for secret sharing, offering efficient share generation and reconstruction for both traditional Shamir sharing and packet sharing. For now, secrets and shares are fixed as prime field elements represented by i64
values.
Installation
Cargo
GitHub
Examples
Several examples are included in the examples/
directory. Run each with cargo
using e.g.
for the Shamir example below.
Shamir sharing
Using the Shamir scheme is relatively straightforward.
When choosing parameters, threshold
and share_count
must be chosen to satisfy security requirements, and prime
must be large enough to correctly encode the value to be shared (and such that prime >= share_count + 1
).
When reconstructing the secret, indices must be explicitly provided to identify the shares; these correspond to the indices the shares had in the vector returned by share()
.
Packed sharing
If many secrets are to be secret shared, it may be beneficial to use the packed scheme where several secrets are packed into each share. While still very computational efficient, one downside is that the parameters are somewhat restricted.
Specifically, the parameters are split in scheme parameters and implementation parameters:
 the former, like in Shamir sharing, determines the abstract properties of the scheme, yet now also with a
secret_count
specifying how many secrets are to be packed into each share; the reconstruction limit is implicitly defined assecret_count + threshold + 1
 the latter is related to the implementation (currently based on the Fast Fourier Transform) and requires not only a
prime
specifying the field, but also two principal roots of unity within that field, which must be respectively a power of 2 and a power of 3
Due to this increased complexity, providing helper functions for finding suitable parameters are in progress. For now, a few fixed fields are included in the packed
module as illustrated in the example below:

PSS_4_8_3
,PSS_4_26_3
,PSS_155_728_100
,PSS_155_19682_100
with format PSS_T_N_D
for sharing D
secrets into N
shares with a threshold of T
.
Homomorphic properties
Both the Shamir and the packed scheme enjoy certain homomorphic properties: shared secrets can be transformed by manipulating the shares. Both addition and multiplications work, yet notice that the reconstruction limit in the case of multiplication goes up by a factor of two for each application.
Parameter generation
While it's straightforward to instantiate the Shamir scheme, as mentioned above the packed scheme is more tricky and a few helper methods are provided as a result. Since some applications needs only a fixed choice of parameters, these helper methods are optional and only included if the paramgen
feature is activated during compilation:
which also adds several extra dependencies.
Performance
So far most performance efforts has been focused on share generation for the packed scheme, with some obvious enhancements for reconstruction in the process of being implemented. As an example, sharing 100 secrets into approximately 20,000 shares with the packed scheme runs in around 31ms on a recent laptop, and in around 590ms on a Raspberry Pi 3.
These numbers were obtained by running
using the nightly toolchain.
License
Licensed under either of
 Apache License, Version 2.0 (LICENSEAPACHE or http://www.apache.org/licenses/LICENSE2.0)
 MIT license (LICENSEMIT or #404) at your option.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache2.0 license, shall be dual licensed as above, without any additional terms or conditions.