public static List <AccessStructure> ExploreAllPossibleAccessStructures(IEnumerable <Trustee> participants)
{
List <QualifiedSubset> qss = new List <QualifiedSubset>();
// build up all possible access structure for given input trustees
for (int i = 1; i <= participants.Count(); i++)
{
var combs = GetKCombs <Trustee>(participants, i);
foreach (var com in combs)
{
QualifiedSubset qs = new QualifiedSubset(com);
qss.Add(qs);
Console.Write(qs.ToString() + '\t');
}
Console.WriteLine();
}
List <AccessStructure> accesses = new List <AccessStructure>();
for (int i = 2; i <= qss.Count; i++)
{
var combinedaccesses = GetKCombs <QualifiedSubset>(qss, i);
foreach (var ac in combinedaccesses)
{
var access = new AccessStructure(ac.ToList());
accesses.Add(access);
Console.Write(access.ToString() + '\t');
}
Console.WriteLine();
}
return(accesses);
}
static void Main(string[] args)
{
//p1^p2^p3,p2^p3^p4,p1^p3^p4,p1^p2^p4,p4^p5^p6,p4^p5^p7,p4^p6^p7
//P1^P2,P2^P3,P3^p4,p3^p5,p3^p6,p6^p7,p7^p8,p8^p1
//P1^P2,P2^P3,P3^p4,p4^p5,p5^p6,p6^p7,p7^p8,p8^p1
AccessStructure acc = new AccessStructure("P1^P2,P2^P3,P3^p4,p4^p5,p5^p6,p6^p7,p7^p8,p8^p1");
var expanded = new List <QualifiedSubset>();
var qualified = new List <QualifiedSubset>();
var thresholds = new List <ThresholdSubset>();
var remaining = new List <QualifiedSubset>();
var attempts = new List <String>();
var tryIntersect = true;
ThresholdHelper.ServeThresholdDetection(acc, tryIntersect, out expanded, out qualified, out thresholds, out attempts, out remaining);
//foreach (var att in attempts)
//{
// Console.WriteLine(att);
//}
Console.WriteLine("all threshold attempts:{0}", attempts.Count);
Console.WriteLine("all fixed threshold attempts:{0}", ThresholdSubset.fixedAttemptTrace.Count);
Console.WriteLine("all found thresholds:");
foreach (var thre in thresholds)
{
Console.WriteLine(thre);
}
Console.WriteLine("all unique thresholds:");
foreach (var thre in ThresholdSubset.CheckInclusiveThresholds(thresholds))
{
Console.WriteLine(thre);
}
Console.Read();
return;
}
//
// GET: /Home/Details/5
public ActionResult DetectThreshold(string access)
{
var start = DateTime.Now;
if (!string.IsNullOrEmpty(access))
{
try
{
AccessStructure acc = new AccessStructure(access);
var expanded = new List <QualifiedSubset>();
var qualified = new List <QualifiedSubset>();
var thresholds = new List <ThresholdSubset>();
var remaining = new List <QualifiedSubset>();
var attempts = new List <String>();
var tryIntersect = true;
ThresholdHelper.ServeThresholdDetection(acc, tryIntersect, out expanded, out qualified, out thresholds, out attempts, out remaining);
ViewBag.expanded = expanded;
ViewBag.qualified = qualified;
ViewBag.thresholds = thresholds;
ViewBag.remaining = remaining;
ViewBag.attempts = attempts;
}
catch (Exception exc)
{
ViewBag.error = exc.Message;
}
}
ViewBag.elapsedSeconds = (DateTime.Now - start).TotalSeconds;
return(View());
}
public void TestReconstructSecret()
{
//assign
var secret = "12345678";
var secretbytes = Encoding.UTF8.GetBytes(secret.ToCharArray());
var benaloh = new BenalohLeichter();
var access = new AccessStructure("p1^p2^p3,p2^p3^p4,p1^p3^p4,p1^p2^p4");
var tryIntersect = true;
//arrange
var optimisedAccess = ThresholdHelper.OptimiseAccessStructure(access, tryIntersect);
var shares = benaloh.DivideSecret(secretbytes, access);
foreach (var item in shares)
{
var reconSecret = Encoding.UTF8.GetString(benaloh.ReconstructSecret(item));
Assert.AreEqual(secret, reconSecret, "secret and reconstructed secret are not the same");
}
//assert
Assert.IsNotNull(shares);
Assert.IsTrue(shares.Count > 0);
}
public static void DetectThresholds(AccessStructure access, bool tryIntersect, out List <ThresholdSubset> thresholds, out List <QualifiedSubset> notMatchingSet)
{
var expanded = new List <QualifiedSubset>();
var qualified = new List <QualifiedSubset>();
var attempts = new List <String>();
ThresholdHelper.ServeThresholdDetection(access, tryIntersect, out expanded, out qualified, out thresholds, out attempts, out notMatchingSet);
}
public void TestDetectThreshold()
{
var access = new AccessStructure("p1^p2^p3,p2^p3^p4,p1^p3^p4,p1^p2^p4");
var tryIntersect = true;
//arrange
var optimisedAccess = ThresholdHelper.OptimiseAccessStructure(access, tryIntersect);
Assert.IsTrue(optimisedAccess.ToString() == "Threshold(3,4)[(P1∧P2∧P3∧P4)]");
}
private int getMockShares(AccessStructure access)
{
var sum = 0;
foreach (var qs in access.Accesses)
{
sum += qs.getShareBranchesCount();
}
return(sum);
}
public static AccessStructure OptimiseAccessStructure(AccessStructure access, bool tryIntersect)
{
var thresholds = new List <ThresholdSubset>();
var remaining = new List <QualifiedSubset>();
DetectThresholds(access, tryIntersect, out thresholds, out remaining);
if (IsThresholdShareShorter(access, thresholds, remaining))
{
var optimisedAccess = new AccessStructure();
optimisedAccess.Accesses.AddRange(thresholds);
optimisedAccess.Accesses.AddRange(remaining);
return(optimisedAccess);
}
return(access);
}
private List <IShareCollection> wrappedDivideSecret(AccessStructure access, string secret, ref List <Int64> elapsedTicks)
{
var benaloh = new BenalohLeichter();
var sw = new Stopwatch();
var secretbytes = Encoding.UTF8.GetBytes(secret.ToCharArray());
sw.Start();
var shares = benaloh.DivideSecret(secretbytes, access);
sw.Stop();
elapsedTicks.Add(sw.ElapsedTicks);
return(shares);
}
public void IsThresholdShareShorterTestFail()
{
//assign
var nothresholdAccess = "P1^P2,P2^P3,P3^p4,p4^p5,p5^p6,p6^p7,p7^p8,p8^p1";
var tryIntersect = true;
//arrange
AccessStructure a = new AccessStructure(nothresholdAccess);
var thresholds = new List <ThresholdSubset>();
var remaining = new List <QualifiedSubset>();
ThresholdHelper.DetectThresholds(a, tryIntersect, out thresholds, out remaining);
bool isEfficicent = ThresholdHelper.IsThresholdShareShorter(a, thresholds, remaining);
//assert
Assert.IsFalse(isEfficicent);
}
public void IsThresholdShareShorterTestPass()
{
//assign
var nothresholdAccess = "p1^p2^p3,p2^p3^p4,p1^p3^p4,p1^p2^p4,p4^p5^p6,p4^p5^p7,p4^p6^p7";
var tryIntersect = true;
//arrange
AccessStructure a = new AccessStructure(nothresholdAccess);
var thresholds = new List <ThresholdSubset>();
var remaining = new List <QualifiedSubset>();
ThresholdHelper.DetectThresholds(a, tryIntersect, out thresholds, out remaining);
bool isEfficicent = ThresholdHelper.IsThresholdShareShorter(a, thresholds, remaining);
//assert
Assert.IsTrue(isEfficicent);
}
public void TestDivideSecret()
{
//assign
var secret = "12345678";
var secretbytes = Encoding.UTF8.GetBytes(secret.ToCharArray());
var benaloh = new BenalohLeichter();
var access = new AccessStructure("p1^p2^p3,p2^p3^p4,p1^p3^p4,p1^p2^p4");
var tryIntersect = true;
//arrange
var optimisedAccess = ThresholdHelper.OptimiseAccessStructure(access, tryIntersect);
var shares = benaloh.DivideSecret(secretbytes, optimisedAccess);
//assert
Assert.IsNotNull(shares);
Assert.IsTrue(shares.Count > 0);
}
private IEnumerable <BenalohLeichterBenchmarkReportSet> benchmarkScheme(AccessStructure access, string key, int iterate, List <LoadedPrimeNumber> primes)
{
Console.WriteLine("benchmarking {0}...", access);
var filteredPrimes = primes.Where(po => po.PrimeSize == key.Length).ToList();
PrimeGenerator.SetLoadedPrimes(filteredPrimes);
List <BenalohLeichterBenchmarkReportSet> results = new List <BenalohLeichterBenchmarkReportSet>();
List <long> elapsedDivide = new List <long>();
List <long> elapsedReconstruction = new List <long>();
List <IShareCollection> shares = null;
Antix.Testing.Benchmark.Run(() =>
{
shares = wrappedDivideSecret(access, key, ref elapsedDivide);
}, iterate);
BenalohLeichterBenchmarkReport divideReport = new BenalohLeichterBenchmarkReport()
{
Access = access.ToString(),
ElapsedTicks = elapsedDivide.ToArray(),
KeyLength = key.Length * 8,
Operation = OperationType.DivideSecret
};
Antix.Testing.Benchmark.Run(() =>
{
wrappedConstructSecret(shares, ref elapsedReconstruction);
}, iterate);
BenalohLeichterBenchmarkReport reconstructReport = new BenalohLeichterBenchmarkReport()
{
Access = access.ToString(),
ElapsedTicks = elapsedReconstruction.ToArray(),
KeyLength = key.Length * 8,
Operation = OperationType.ReconstructSecret
};
var setReport = new BenalohLeichterBenchmarkReportSet()
{
divideItem = divideReport,
reconstructItem = reconstructReport,
};
results.Add(setReport);
return(results);
}
public void TestExpandAccessStructure()
{
Trustee p1, p2, p3, p4;
p1 = new Trustee(1);
p2 = new Trustee(2);
p3 = new Trustee(3);
p4 = new Trustee(4);
QualifiedSubset qs1, qs2, qs3;
qs1 = new QualifiedSubset();
qs1.Parties.Add(p2);
qs1.Parties.Add(p3);
qs2 = new QualifiedSubset();
qs2.Parties.Add(p1);
qs2.Parties.Add(p2);
qs2.Parties.Add(p4);
qs3 = new QualifiedSubset();
qs3.Parties.Add(p1);
qs3.Parties.Add(p3);
qs3.Parties.Add(p4);
AccessStructure access = new AccessStructure();
access.Accesses.Add(qs1);
access.Accesses.Add(qs2);
access.Accesses.Add(qs3);
List <Trustee> trustees = new List <Trustee>()
{
p1, p2, p3
};
ExpandAllAccessPaths(trustees);
}
private int wrappedShareLengthDivideSecret(AccessStructure access, bool optimise, bool tryIntersect, string secret, ref List <Int64> elapsedTicks, ref AccessStructure optimisedAccess)
{
//return new List<IShareCollection>();
optimisedAccess = null;
var benaloh = new BenalohLeichter();
var sw = new Stopwatch();
var secretbytes = Encoding.UTF8.GetBytes(secret.ToCharArray());
sw.Start();
if (optimise)
{
access = ThresholdHelper.OptimiseAccessStructure(access, tryIntersect);
optimisedAccess = access;
}
var shares = getMockShares(access); //benaloh.DivideSecret(secretbytes, access);
sw.Stop();
elapsedTicks.Add(sw.ElapsedTicks);
return(shares);
}
public static bool IsThresholdShareShorter(AccessStructure access, List <ThresholdSubset> thresholds
, List <QualifiedSubset> notMatchingSet)
{
// caclulate shares given in case of using thresholds
var sumThresholdShare = 0;
foreach (var th in thresholds)
{
sumThresholdShare += th.getPartiesCount();
}
//append shares from the not matching sets
foreach (var qs in notMatchingSet)
{
sumThresholdShare += qs.Parties.Count;
}
var sumNoThreshold = 0;
//now let's see how it would be if we just divide simply
foreach (var qs in access.Accesses)
{
sumNoThreshold += qs.getPartiesCount();
}
return(sumThresholdShare < sumNoThreshold);
}
public static void ServeThresholdDetection(AccessStructure access, bool tryIntersect, out List <QualifiedSubset> expandedSet
, out List <QualifiedSubset> qualifiedSet, out List <ThresholdSubset> thresholds, out List <string> attempts,
out List <QualifiedSubset> notMatchingSet)
{
ThresholdSubset.attemptTrace = new List <string>();
ThresholdSubset.fixedAttemptTrace = new List <string>();
List <Trustee> trustees = access.GetAllParties().OrderBy(po => po.partyId).ToList();
//discover all possible expansion of the access structures
List <QualifiedSubset> subsets = AccessStructure.ExpandPersonPaths(null, trustees).Distinct().ToList();
expandedSet = subsets;
//return;
//we don't care about longer paths which are not mentioned in the access structure
int longestQualifiedSubsetAccepted = access.GetLongestLength();//GetLongestLength(access);
//calculate the share of each party in qualified subsets
int i = 0;
List <Tuple <Trustee, int> > allsubsetsparties = new List <Tuple <Trustee, int> >();
List <QualifiedSubset> qualifiedExpandedSubset = new List <QualifiedSubset>();
Console.WriteLine("All qualified expanded subsets:");
foreach (QualifiedSubset subset in subsets)
{
//delete unqualified subsets based on minimum access structure
if (subset.Parties.Count > longestQualifiedSubsetAccepted)
{
continue;
}
bool isqualified = AccessStructure.IsQualifiedSubset(subset, access);
if (isqualified)
{
//add the subset to expanded qualified
qualifiedExpandedSubset.Add(subset);
allsubsetsparties.AddRange(subset.Parties.Select(po => new Tuple <Trustee, int>(po, subset.Parties.Count)));
Console.WriteLine("{0}.\t [{1}] q:{2}", i++, subset.ToString(), isqualified);
}
}
qualifiedSet = qualifiedExpandedSubset.ToList();
List <ThresholdSubset> thresholdsubsets = new List <ThresholdSubset>();
var normalTH = qualifiedExpandedSubset.GroupBy(po => po.Parties.Count).Select(info => new { Depth = info.Key, Count = info.Count() });
foreach (var th in normalTH)
{
var candidateSets = qualifiedExpandedSubset.Where(po => po.Parties.Count == th.Depth);
///find threshold in sets
var threshold = ThresholdSubset.findThreshold(candidateSets, th.Depth, trustees.Count,
ThresholdSubset.GetNumberOfRequiredSetsForThreshold(trustees.Count, th.Depth, candidateSets.Count()), tryIntersect);
if (threshold != null && threshold.Count != 0)
{
thresholdsubsets.AddRange(threshold);
}
}
var uniqueInclusiveThresholds = ThresholdSubset.CheckInclusiveThresholds(thresholdsubsets.Distinct());
foreach (ThresholdSubset th in uniqueInclusiveThresholds)
{
Console.WriteLine(th);
var coveredsets = ThresholdSubset.ExploreAllSubsets(th);
qualifiedExpandedSubset = qualifiedExpandedSubset.Except(coveredsets).ToList();
}
thresholds = uniqueInclusiveThresholds.ToList();
notMatchingSet = qualifiedExpandedSubset.ToList();
attempts = ThresholdSubset.attemptTrace;
}
private IEnumerable <BenalohLeichterBenchmarkReportSet> benchmarkShareLengthAccessStructure(AccessStructure access, string key, int iterate)
{
List <BenalohLeichterBenchmarkReportSet> results = new List <BenalohLeichterBenchmarkReportSet>();
List <long> elapsedDivideOptimisdIntersected = new List <long>();
List <long> elapsedDivideOptimisd = new List <long>();
List <long> elapsedDivide = new List <long>();
List <long> elapsedReconstruction = new List <long>();
int shares = 0;
AccessStructure optimsedAccess = null;
Antix.Testing.Benchmark.Run(() =>
{
shares = wrappedShareLengthDivideSecret(access, true, true, key, ref elapsedDivideOptimisdIntersected, ref optimsedAccess);
}, iterate);
var numberOfShares = shares;
BenalohLeichterBenchmarkReport divideReportOptimisedIntersected = new BenalohLeichterBenchmarkReport()
{
Access = access.ToString(),
ElapsedTicks = elapsedDivideOptimisdIntersected.ToArray(),
KeyLength = key.Length * 8,
NumberOfShares = numberOfShares,
Operation = OperationType.DivideSecretOptimisedIntersected,
OptimisedAccess = optimsedAccess.ToString(),
};
Antix.Testing.Benchmark.Run(() =>
{
shares = wrappedShareLengthDivideSecret(access, true, false, key, ref elapsedDivideOptimisd, ref optimsedAccess);
}, iterate);
numberOfShares = shares;
BenalohLeichterBenchmarkReport divideReportOptimised = new BenalohLeichterBenchmarkReport()
{
Access = access.ToString(),
ElapsedTicks = elapsedDivideOptimisd.ToArray(),
KeyLength = key.Length * 8,
NumberOfShares = numberOfShares,
Operation = OperationType.DivideSecretOptimised,
OptimisedAccess = optimsedAccess.ToString(),
};
Antix.Testing.Benchmark.Run(() =>
{
shares = wrappedShareLengthDivideSecret(access, false, false, key, ref elapsedDivide, ref optimsedAccess);
}, iterate);
numberOfShares = shares;
BenalohLeichterBenchmarkReport divideReport = new BenalohLeichterBenchmarkReport()
{
Access = access.ToString(),
ElapsedTicks = elapsedDivide.ToArray(),
KeyLength = key.Length * 8,
NumberOfShares = numberOfShares,
Operation = OperationType.DivideSecret
};
var setReport = new BenalohLeichterBenchmarkReportSet()
{
divideItem = divideReport,
optimisedItem = divideReportOptimised,
IntersectedItem = divideReportOptimisedIntersected
};
results.Add(setReport);
return(results);
}
