What does Disaster Recovery and Threshold Shares conclude, in numbers, about “Leaks Accumulate: Proactive Share Refresh”?

Answer: Chapter 5 shows that leakage accumulates: three-of-five left unrefreshed for twenty years leaks with probability 0.208484, and yearly refresh brings that to 0.001551.

Scope of the numbers: Chapter 6 computes self-rescue after one share goes missing: losing the fastest holder is like raising the threshold by one, and the illustrative rescue window is 263 hours. Marked boxes separate published evidence, runnable Python calculations (19 programs), classical sources and the author's hypotheses.

中文版

Data table

The numbers below are printed verbatim by the chapter's Python program and can be reproduced by running it. standard-library Python onlyprinted values that match the answer: 0.001551, 0.208484

no refresh: P(adversary holds k shares) after t years
schemet=5t=10t=20t=30
2-of-30.0259200.0881450.2580050.431962
3-of-50.0076400.0456450.2084840.415186
4-of-70.0023480.0244710.1718540.401322
over 20 years with a refresh every R years
schemeneverR=5R=2R=1
2-of-30.2580050.0997170.0448700.023416
3-of-50.2084840.0302120.0058320.001551
4-of-70.1718540.0093600.0007810.000107
3-of-5, 20 years: never / yearly refresh = 134.4 times
Show the full program
# Chapter 5. p52: leaks pile up over the years unless shares are renewed.
# Model: a patient adversary. Each share leaks to the adversary with
# probability p = 0.02 per year (illustrative) and stays leaked. With a
# refresh every R years, shares leaked in one epoch are useless in the
# next, so the adversary must collect k shares within a single epoch.
# Horizon 20 years; exact binomial arithmetic, no simulation.
import math

P, T = 0.02, 20


def tail(n, r, x):
    terms = [math.comb(n, j) * r ** j * (1 - r) ** (n - j)
             for j in range(x, n + 1)]
    return math.fsum(terms)


def exposed(k, n, years):
    return tail(n, 1 - (1 - P) ** years, k)


print("no refresh: P(adversary holds k shares) after t years")
print("scheme    t=5        t=10       t=20       t=30")
for k, n in ((2, 3), (3, 5), (4, 7)):
    print("%d-of-%d  " % (k, n) + "".join("%11.6f" % exposed(k, n, t)
                                        for t in (5, 10, 20, 30)))
print("over %d years with a refresh every R years" % T)
print("scheme    never      R=5        R=2        R=1")
for k, n in ((2, 3), (3, 5), (4, 7)):
    row = [exposed(k, n, T)]
    for r in (5, 2, 1):
        epoch = exposed(k, n, r)
        row.append(1 - (1 - epoch) ** (T // r))
    print("%d-of-%d  " % (k, n) + "".join("%11.6f" % v for v in row))
print("3-of-5, 20 years: never / yearly refresh = %.1f times"
      % (exposed(3, 5, T) / (1 - (1 - exposed(3, 5, 1)) ** T)))

Single source and citation

Fan, Y. (2026). Disaster Recovery for Digital Assets: Shamir Secret-Sharing Thresholds, Off-Site Incremental Snapshots and Self-Rescue from Single Points of Loss (Version 1.0.0), Chapter 5: Leaks Accumulate: Proactive Share Refresh. 5D Library. DOI pending

DOI pending · monograph page goes live after publication · 5DL-B-272 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026272,
  author    = {Fan, Yafu},
  title     = {Disaster Recovery for Digital Assets: Shamir Secret-Sharing Thresholds, Off-Site Incremental Snapshots and Self-Rescue from Single Points of Loss},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

Other chapter answers in this book