public void EncryptionParametersCompareNET()
{
var parms1 = new EncryptionParameters();
parms1.NoiseStandardDeviation = 3.19;
parms1.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods30Bit(0)
};
parms1.PlainModulus = 1 << 6;
parms1.PolyModulus = "1x^64 + 1";
var parms2 = new EncryptionParameters(parms1);
Assert.IsTrue(parms1.Equals(parms2));
var parms3 = new EncryptionParameters();
parms3.Set(parms2);
Assert.IsTrue(parms3.Equals(parms2));
parms3.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods30Bit(1)
};
Assert.IsFalse(parms3.Equals(parms2));
parms3.Set(parms2);
Assert.IsTrue(parms3.Equals(parms2));
parms3.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1)
};
Assert.IsFalse(parms3.Equals(parms2));
parms3.Set(parms2);
parms3.PolyModulus = "1x^128 + 1";
Assert.IsFalse(parms3.Equals(parms1));
parms3.Set(parms2);
parms3.PlainModulus = (1 << 6) + 1;
Assert.IsFalse(parms3.Equals(parms2));
parms3.Set(parms2);
parms3.NoiseStandardDeviation = 3.18;
Assert.IsFalse(parms3.Equals(parms2));
parms3.Set(parms2);
parms3.PolyModulus = "1";
parms3.PolyModulus = "1x^128 + 1";
parms3.PolyModulus = "1x^64 + 1";
Assert.IsTrue(parms3.Equals(parms1));
parms3.Set(parms2);
parms3.CoeffModulus = new List <SmallModulus> {
2
};
parms3.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods50Bit(0)
};
parms3.CoeffModulus = parms2.CoeffModulus;
Assert.IsTrue(parms3.Equals(parms2));
}
public void EncryptionParametersSetNET()
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 0;
parms.CoeffModulus = new List <SmallModulus> {
};
parms.PlainModulus = 0;
parms.PolyModulus = "0";
Assert.AreEqual(0.0, parms.NoiseStandardDeviation);
Assert.AreEqual(0.0, parms.NoiseMaxDeviation);
Assert.IsTrue(parms.CoeffModulus.Count == 0);
Assert.IsTrue(parms.PlainModulus.Value == 0);
Assert.IsTrue(parms.PolyModulus.ToString() == "0");
parms.NoiseStandardDeviation = 0;
parms.CoeffModulus = new List <SmallModulus> {
2
};
parms.PlainModulus = 2;
parms.PolyModulus = "1";
Assert.AreEqual(0.0, parms.NoiseStandardDeviation);
Assert.AreEqual(0.0, parms.NoiseMaxDeviation);
Assert.IsTrue(parms.CoeffModulus[0].Value == 2);
Assert.IsTrue(parms.PlainModulus.Value == 2);
Assert.IsTrue(parms.PolyModulus.ToString() == "1");
parms.NoiseStandardDeviation = 3.19;
parms.CoeffModulus = new List <SmallModulus> {
2, 3
};
parms.PlainModulus = 2;
parms.PolyModulus = "1x^2 + 1";
Assert.AreEqual(3.19, parms.NoiseStandardDeviation);
Assert.AreEqual(3.19 * 6, parms.NoiseMaxDeviation);
Assert.IsTrue(parms.CoeffModulus[0].Value == 2);
Assert.IsTrue(parms.CoeffModulus[1].Value == 3);
Assert.IsTrue(parms.PlainModulus.Value == 2);
Assert.IsTrue(parms.PolyModulus.ToString() == "1x^2 + 1");
parms.NoiseStandardDeviation = 3.19;
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods30Bit(0),
DefaultParams.SmallMods40Bit(0),
DefaultParams.SmallMods50Bit(0)
};
parms.PlainModulus = 2;
parms.PolyModulus = "1x^128 + 1";
Assert.AreEqual(3.19, parms.NoiseStandardDeviation);
Assert.AreEqual(3.19 * 6, parms.NoiseMaxDeviation);
Assert.IsTrue(parms.CoeffModulus[0].Equals(DefaultParams.SmallMods30Bit(0)));
Assert.IsTrue(parms.CoeffModulus[1].Equals(DefaultParams.SmallMods40Bit(0)));
Assert.IsTrue(parms.CoeffModulus[2].Equals(DefaultParams.SmallMods50Bit(0)));
Assert.IsTrue(parms.PolyModulus.ToString() == "1x^128 + 1");
}
public void SmallMods50BitTest()
{
SmallModulus sm = DefaultParams.SmallMods50Bit(30);
Assert.IsNotNull(sm);
Assert.AreEqual(50, sm.BitCount);
Assert.AreEqual(0x3FFFFF8B80001ul, sm.Value);
Assert.ThrowsException <ArgumentOutOfRangeException>(() => DefaultParams.SmallMods50Bit(64));
}
public void GaloisKeysSaveLoadNET()
{
var stream = new MemoryStream();
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^64 + 1";
parms.PlainModulus = 65537;
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0)
};
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var keys = new GaloisKeys();
Assert.AreEqual(keys.DecompositionBitCount, 0);
var test_keys = new GaloisKeys();
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
Assert.AreEqual(0, keys.Size);
keygen.GenerateGaloisKeys(1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 1);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Data[j].Count; i++)
{
Assert.AreEqual(keys.Data[j][i].Size, test_keys.Data[j][i].Size);
Assert.AreEqual(keys.Data[j][i].UInt64Count, test_keys.Data[j][i].UInt64Count);
}
}
Assert.AreEqual(10, keys.Size);
keygen.GenerateGaloisKeys(8, keys);
Assert.AreEqual(keys.DecompositionBitCount, 8);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Data[j].Count; i++)
{
Assert.AreEqual(keys.Data[j][i].Size, test_keys.Data[j][i].Size);
Assert.AreEqual(keys.Data[j][i].UInt64Count, test_keys.Data[j][i].UInt64Count);
}
}
Assert.AreEqual(10, keys.Size);
keygen.GenerateGaloisKeys(60, keys);
Assert.AreEqual(keys.DecompositionBitCount, 60);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Data[j].Count; i++)
{
Assert.AreEqual(keys.Data[j][i].Size, test_keys.Data[j][i].Size);
Assert.AreEqual(keys.Data[j][i].UInt64Count, test_keys.Data[j][i].UInt64Count);
}
}
Assert.AreEqual(10, keys.Size);
}
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^256 + 1";
parms.PlainModulus = 65537;
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods50Bit(0)
};
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var keys = new GaloisKeys();
Assert.AreEqual(keys.DecompositionBitCount, 0);
var test_keys = new GaloisKeys();
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
Assert.AreEqual(0, keys.Size);
keygen.GenerateGaloisKeys(8, keys);
Assert.AreEqual(keys.DecompositionBitCount, 8);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Data[j].Count; i++)
{
Assert.AreEqual(keys.Data[j][i].Size, test_keys.Data[j][i].Size);
Assert.AreEqual(keys.Data[j][i].UInt64Count, test_keys.Data[j][i].UInt64Count);
}
}
Assert.AreEqual(14, keys.Size);
keygen.GenerateGaloisKeys(60, keys);
Assert.AreEqual(keys.DecompositionBitCount, 60);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.AreEqual(keys.HashBlock, test_keys.HashBlock);
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Data[j].Count; i++)
{
Assert.AreEqual(keys.Data[j][i].Size, test_keys.Data[j][i].Size);
Assert.AreEqual(keys.Data[j][i].UInt64Count, test_keys.Data[j][i].UInt64Count);
}
}
Assert.AreEqual(14, keys.Size);
}
}
public void EvaluationKeysSaveLoadNET()
{
var stream = new MemoryStream();
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^64 + 1";
parms.PlainModulus = 1 << 6;
parms.CoeffModulus = new List<SmallModulus> { DefaultParams.SmallMods60Bit(0) };
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var keys = new EvaluationKeys();
Assert.AreEqual(keys.DecompositionBitCount, 0);
var test_keys = new EvaluationKeys();
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
Assert.AreEqual(0, keys.Size);
keygen.GenerateEvaluationKeys(1, 1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 1);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(2, 1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 2);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(59, 2, keys);
Assert.AreEqual(keys.DecompositionBitCount, 59);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(60, 5, keys);
Assert.AreEqual(keys.DecompositionBitCount, 60);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
}
{
var parms = new EncryptionParameters();
parms.NoiseStandardDeviation = 3.19;
parms.PolyModulus = "1x^256 + 1";
parms.PlainModulus = 1 << 6;
parms.CoeffModulus = new List<SmallModulus> {
DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods50Bit(0) };
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var keys = new EvaluationKeys();
Assert.AreEqual(keys.DecompositionBitCount, 0);
var test_keys = new EvaluationKeys();
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
Assert.AreEqual(0, keys.Size);
keygen.GenerateEvaluationKeys(8, 1, keys);
Assert.AreEqual(keys.DecompositionBitCount, 8);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(8, 2, keys);
Assert.AreEqual(keys.DecompositionBitCount, 8);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(59, 2, keys);
Assert.AreEqual(keys.DecompositionBitCount, 59);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
keygen.GenerateEvaluationKeys(60, 5, keys);
Assert.AreEqual(keys.DecompositionBitCount, 60);
stream.Seek(0, SeekOrigin.Begin);
keys.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
test_keys.Load(stream);
Assert.AreEqual(keys.Size, test_keys.Size);
Assert.IsTrue(keys.HashBlock.Equals(test_keys.HashBlock));
Assert.AreEqual(keys.DecompositionBitCount, test_keys.DecompositionBitCount);
for (int j = 0; j < test_keys.Size; j++)
{
for (int i = 0; i < test_keys.Key(j + 2).Count; i++)
{
Assert.AreEqual(keys.Key(j + 2)[i].Size, test_keys.Key(j + 2)[i].Size);
Assert.AreEqual(keys.Key(j + 2)[i].UInt64Count, test_keys.Key(j + 2)[i].UInt64Count);
}
}
}
}
