Class: Tapyrus::SLIP39::SSS

Inherits:

Object

Object
Tapyrus::SLIP39::SSS

show all

Extended by:: Util

Includes:: Util

Defined in:: lib/tapyrus/slip39/sss.rb

Overview

Shamir’s Secret Sharing

Constant Summary

Constants included from Util

Util::DIGEST_NAME_SHA256

Class Method Summary collapse

.recover_secret(shares, passphrase: "") ⇒ String

recovery master secret form shares.
.setup_shares(groups: [], group_threshold: nil, exp: 0, secret: nil, passphrase: "") ⇒ Array[Array[Tapyrus::SLIP39::Share]]

Create SSS shares.

Methods included from Util

byte_to_bit, calc_checksum, decode_base58_address, double_sha256, encode_base58_address, hash160, hmac_sha256, pack_boolean, pack_var_int, pack_var_string, padding_zero, sha256, unpack_boolean, unpack_var_int, unpack_var_int_from_io, unpack_var_string, valid_address?

Class Method Details

.recover_secret(shares, passphrase: "") ⇒ `String`

recovery master secret form shares.

Usage: shares: An array of shares required for recovery. master_secret = Tapyrus::SLIP39::SSS.recover_secret(shares, passphrase: ‘xxx’)

Parameters:

shares (Array[Tapyrus::SLIP30::Share]) —

an array of shares.
passphrase (String) (defaults to: "") —

the passphrase using decrypt master secret.

Returns:

(String) —

a master secret.

Raises:

(ArgumentError)

# File 'lib/tapyrus/slip39/sss.rb', line 100

def self.recover_secret(shares, passphrase: "")
  raise ArgumentError, "share is empty." if shares.nil? || shares.empty?
  groups = {}
  id = shares[0].id
  exp = shares[0].iteration_exp
  group_threshold = shares.first.group_threshold
  group_count = shares.first.group_count

  shares.each do |share|
    raise ArgumentError, "Invalid set of shares. All shares must have the same id." unless id == share.id
    unless group_threshold == share.group_threshold
      raise ArgumentError, "Invalid set of shares. All shares must have the same group threshold."
    end
    unless group_count == share.group_count
      raise ArgumentError, "Invalid set of shares. All shares must have the same group count."
    end
    unless exp == share.iteration_exp
      raise ArgumentError, "Invalid set of shares. All Shares must have the same iteration exponent."
    end
    groups[share.group_index] ||= []
    groups[share.group_index] << share
  end

  group_shares = {}
  groups.each do |group_index, shares|
    member_threshold = shares.first.member_threshold
    if shares.length < member_threshold
      raise ArgumentError,
            "Wrong number of mnemonics. Threshold is #{member_threshold}, but share count is #{shares.length}"
    end
    if shares.length == 1 && member_threshold == 1
      group_shares[group_index] = shares.first.value
    else
      value_length = shares.first.value.length
      x_coordinates = []
      shares.each do |share|
        unless member_threshold == share.member_threshold
          raise ArgumentError, "Invalid set of shares. All shares in a group must have the same member threshold."
        end
        unless value_length == share.value.length
          raise ArgumentError, "Invalid set of shares. All share values must have the same length."
        end
        x_coordinates << share.member_index
      end
      x_coordinates.uniq!
      unless x_coordinates.size == shares.size
        raise ArgumentError, "Invalid set of shares. Share indices must be unique."
      end
      interpolate_shares = shares.map { |s| [s.member_index, s.value] }

      secret = interpolate(interpolate_shares, SECRET_INDEX)
      digest_value = interpolate(interpolate_shares, DIGEST_INDEX).htb
      digest, random_value = digest_value[0...DIGEST_LENGTH_BYTES].bth, digest_value[DIGEST_LENGTH_BYTES..-1].bth
      recover_digest = create_digest(secret, random_value)
      raise ArgumentError, "Invalid digest of the shared secret." unless digest == recover_digest

      group_shares[group_index] = secret
    end
  end

  return decrypt(group_shares.values.first, passphrase, exp, id) if group_threshold == 1

  if group_shares.length < group_threshold
    raise ArgumentError,
          "Wrong number of mnemonics. Group threshold is #{group_threshold}, but share count is #{group_shares.length}"
  end

  interpolate_shares = group_shares.map { |k, v| [k, v] }
  secret = interpolate(interpolate_shares, SECRET_INDEX)
  digest_value = interpolate(interpolate_shares, DIGEST_INDEX).htb
  digest, random_value = digest_value[0...DIGEST_LENGTH_BYTES].bth, digest_value[DIGEST_LENGTH_BYTES..-1].bth
  recover_digest = create_digest(secret, random_value)
  raise ArgumentError, "Invalid digest of the shared secret." unless digest == recover_digest

  decrypt(secret, passphrase, exp, id)
end

.setup_shares(groups: [], group_threshold: nil, exp: 0, secret: nil, passphrase: "") ⇒ `Array[Array[Tapyrus::SLIP39::Share]]`

Create SSS shares.

Usage

4 groups shares.

two for Alice

one for friends(required 3 of her 5 friends) and

one for family members(required 2 of her 6 family)

Two of these group shares are required to reconstruct the master secret. groups = [1, 1], [1, 1], [3, 5], [2, 6]

group_shares = Tapyrus::SLIP39::SSS.setup_shares(group_threshold: 2, groups: groups, secret: ‘secret with hex format’, passphrase: ‘xxx’) return 4 group array of Tapyrus::SLIP39::Share

Get each share word groups[1].to_words

> [“shadow”, “pistol”, “academic”, “always”, “adequate”, “wildlife”, “fancy”, “gross”, “oasis”, “cylinder”, “mustang”, “wrist”, “rescue”, “view”, “short”, “owner”, “flip”, “making”, “coding”, “armed”]