/// <summary>
/// Remove a key for single key scheme.
/// </summary>
/// <param name="scheme">The key scheme.</param>
/// <param name="key">The key to remove.</param>
public virtual void Remove(SingleKeyScheme scheme, Key key)
{
IKeySet keys;
if (keySets.TryGetValue(scheme, out keys))
{
keys.Remove(key);
if (keys.IsEmpty)
keySets.Remove(scheme);
}
}
/// <summary>
/// Remove a key for dual key scheme.
/// </summary>
/// <param name="scheme">The key scheme.</param>
/// <param name="subset">The key subset (PRODUCER or CONSUMER) to remove the key from.</param>
/// <param name="key">The key to remove.</param>
public virtual void Remove(DualKeyScheme scheme,
DualKeyScheme.Subset subset,
Key key)
{
IKeySet keySet;
if (keySets.TryGetValue(scheme, out keySet))
{
((DualKeySet)keySet).KeysFor(subset).Remove(key);
if (keySet.IsEmpty)
keySets.Remove(scheme);
}
}
/// <summary>
/// Add a key for single key scheme.
/// </summary>
/// <param name="scheme">The key scheme.</param>
/// <param name="key">The key to add.</param>
public virtual void Add(SingleKeyScheme scheme, Key key)
{
NewKeysetFor(scheme).Add(key);
}
/// <summary>
/// Add a key for dual key scheme.
/// </summary>
/// <param name="scheme">The key scheme.</param>
/// <param name="subset">The key subset (PRODUCER or CONSUMER) to add the key to. </param>
/// <param name="key"> The key to add.</param>
public virtual void Add(DualKeyScheme scheme,
DualKeyScheme.Subset subset, Key key)
{
NewKeysetFor(scheme).KeysFor(subset).Add(key);
}
public void producer()
{
Key alicePrivate = new Key("alice private");
Key alicePublic = alicePrivate.PublicKeyFor(KeyScheme.Sha1Producer);
Keys aliceNtfnKeys = new Keys();
aliceNtfnKeys.Add(KeyScheme.Sha1Producer, alicePrivate);
Keys bobSubKeys = new Keys();
bobSubKeys.Add(KeyScheme.Sha1Producer, alicePublic);
Keys eveSubKeys = new Keys();
eveSubKeys.Add(KeyScheme.Sha1Producer, new Key("Not alice's key").PublicKeyFor(KeyScheme.Sha1Producer));
Assert.IsTrue(bobSubKeys.Match(aliceNtfnKeys));
Assert.IsFalse(eveSubKeys.Match(aliceNtfnKeys));
}
/**
* Create the public (aka prime) key for a given private (aka raw)
* key using this scheme's hash.
*/
public Key PublicKeyFor(Key privateKey)
{
return new Key(KeyHash.Hash(privateKey.Data));
}
public void consumer()
{
Key bobPrivate = new Key("bob private");
Key bobPublic = bobPrivate.PublicKeyFor(KeyScheme.Sha1Consumer);
Keys aliceNtfnKeys = new Keys();
aliceNtfnKeys.Add(KeyScheme.Sha1Consumer, bobPublic);
Keys bobSubKeys = new Keys();
bobSubKeys.Add(KeyScheme.Sha1Consumer, bobPrivate);
Keys eveSubKeys = new Keys();
eveSubKeys.Add(KeyScheme.Sha1Consumer, new Key("Not bob's key"));
Assert.IsTrue(bobSubKeys.Match(aliceNtfnKeys));
Assert.IsFalse(eveSubKeys.Match(aliceNtfnKeys));
}
public void dual()
{
Key alicePrivate = new Key("alice private");
Key alicePublic = alicePrivate.PublicKeyFor(KeyScheme.Sha1Dual);
Key bobPrivate = new Key("bob private");
Key bobPublic = bobPrivate.PublicKeyFor(KeyScheme.Sha1Dual);
Keys aliceNtfnKeys = new Keys();
aliceNtfnKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, bobPublic);
aliceNtfnKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, alicePrivate);
Keys bobSubKeys = new Keys();
bobSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, bobPrivate);
bobSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, alicePublic);
Keys eveSubKeys = new Keys();
Key randomPrivate = new Key("Not bob's key");
eveSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, randomPrivate);
eveSubKeys.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, randomPrivate.PublicKeyFor(KeyScheme.Sha1Dual));
Assert.IsTrue(bobSubKeys.Match(aliceNtfnKeys));
Assert.IsFalse(aliceNtfnKeys.Match(bobSubKeys));
Assert.IsFalse(eveSubKeys.Match(aliceNtfnKeys));
}
public void computeDeltaSingleScheme()
{
Keys keys1 = new Keys();
Keys keys2 = new Keys();
Key key1 = new Key("key 1");
Key key2 = new Key("key 2");
Delta delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Consumer).Count);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Dual).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Consumer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Dual).Count);
// add a single producer key
keys2.Add(KeyScheme.Sha1Producer, key1);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(1, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
checkApplyDelta(delta, keys1, keys2);
// remove a single producer key
keys1.Add(KeyScheme.Sha1Producer, key2);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(1, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
checkApplyDelta(delta, keys1, keys2);
// key1 is now in both sets
keys1.Add(KeyScheme.Sha1Producer, key1);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
// key2 is not in both
keys2.Add(KeyScheme.Sha1Producer, key2);
delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Producer).Count);
Assert.AreEqual(0, delta.Removed.KeysetFor(KeyScheme.Sha1Producer).Count);
checkApplyDelta(delta, keys1, keys2);
}
public void computeDeltaDual()
{
Keys keys1 = new Keys();
Keys keys2 = new Keys();
Key key1 = new Key("key 1");
Key key2 = new Key("key 2");
Key key3 = new Key("key 3");
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, key1);
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, key2);
keys1.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, key3);
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Producer, key3);
keys2.Add(KeyScheme.Sha1Dual, DualKeyScheme.Subset.Consumer, key3);
Delta delta = keys1.DeltaFrom(keys2);
Assert.AreEqual(1, delta.Added.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Dual).ProducerKeys.Count);
Assert.AreEqual(0, delta.Added.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
Assert.AreEqual(1, delta.Removed.KeysetFor(KeyScheme.Sha1Dual).ConsumerKeys.Count);
checkApplyDelta(delta, keys1, keys2);
}
public bool Equals(Key key)
{
return hash == key.hash && new ArrayEqualityComparer<byte>().Equals(Data, key.Data);
}
public bool Add(Key key)
{
throw new NotSupportedException("Cannot add to a dual key set");
}
public bool Remove(Key key)
{
throw new NotSupportedException("Cannot remove from a dual key set");
}
