public void BatchUnbatchPlaintextNET() { var parms = new EncryptionParameters(); parms.PolyModulus = "1x^64 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0) }; parms.PlainModulus = 257; var context = new SEALContext(parms); Assert.IsTrue(context.Qualifiers.EnableBatching); var crtbuilder = new PolyCRTBuilder(context); Assert.AreEqual(64, crtbuilder.SlotCount); var plain = new Plaintext(crtbuilder.SlotCount); for (int i = 0; i < crtbuilder.SlotCount; i++) { plain[i] = (UInt64)i; } crtbuilder.Compose(plain); crtbuilder.Decompose(plain); for (int i = 0; i < crtbuilder.SlotCount; i++) { Assert.IsTrue(plain[i] == (UInt64)i); } for (int i = 0; i < crtbuilder.SlotCount; i++) { plain[i] = (UInt64)5; } crtbuilder.Compose(plain); Assert.IsTrue(plain.ToString().Equals("5")); crtbuilder.Decompose(plain); for (int i = 0; i < crtbuilder.SlotCount; i++) { Assert.IsTrue(plain[i] == (UInt64)5); } var short_plain = new Plaintext(20); for (int i = 0; i < 20; i++) { short_plain[i] = (UInt64)i; } crtbuilder.Compose(short_plain); crtbuilder.Decompose(short_plain); for (int i = 0; i < 20; i++) { Assert.IsTrue(short_plain[i] == (UInt64)i); } for (int i = 20; i < crtbuilder.SlotCount; i++) { Assert.IsTrue(short_plain[i] == 0UL); } }
public void KeyStepTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS) { PolyModulusDegree = 64, CoeffModulus = new List <SmallModulus>() { DefaultParams.SmallMods60Bit(0) } }; SEALContext context = SEALContext.Create(parms); KeyGenerator keygen = new KeyGenerator(context); GaloisKeys keys = keygen.GaloisKeys(decompositionBitCount: 15, steps: new int[] { 1, 2, 3 }); Assert.IsNotNull(keys); Assert.AreEqual(15, keys.DecompositionBitCount); Assert.AreEqual(3ul, keys.Size); Assert.IsFalse(keys.HasKey(1)); Assert.IsTrue(keys.HasKey(3)); Assert.IsFalse(keys.HasKey(5)); Assert.IsFalse(keys.HasKey(7)); Assert.IsTrue(keys.HasKey(9)); Assert.IsFalse(keys.HasKey(11)); Assert.IsFalse(keys.HasKey(13)); Assert.IsFalse(keys.HasKey(15)); Assert.IsFalse(keys.HasKey(17)); Assert.IsFalse(keys.HasKey(19)); Assert.IsFalse(keys.HasKey(21)); Assert.IsFalse(keys.HasKey(23)); Assert.IsFalse(keys.HasKey(25)); Assert.IsTrue(keys.HasKey(27)); }
public void SmallMods60BitTest() { SmallModulus sm = DefaultParams.SmallMods60Bit(45); Assert.IsNotNull(sm); Assert.AreEqual(60, sm.BitCount); Assert.AreEqual(0x0ffffffff1740001ul, sm.Value); }
public void FVKeyGenerationNET() { var parms = new EncryptionParameters(); { parms.NoiseStandardDeviation = 3.19; parms.PolyModulus = "1x^64 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0) }; parms.PlainModulus = 1 << 6; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); Assert.IsTrue(keygen.PublicKey.HashBlock.Equals(parms.HashBlock)); Assert.IsTrue(keygen.SecretKey.HashBlock.Equals(parms.HashBlock)); var evk = new EvaluationKeys(); keygen.GenerateEvaluationKeys(60, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(2, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(30, 1, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(4, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(2, 2, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(60, evk.Key(2)[0].Size); } { parms.NoiseStandardDeviation = 3.19; parms.PolyModulus = "1x^256 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1) }; parms.PlainModulus = 1 << 6; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); Assert.AreEqual(keygen.PublicKey.HashBlock, parms.HashBlock); Assert.AreEqual(keygen.SecretKey.HashBlock, parms.HashBlock); var evk = new EvaluationKeys(); keygen.GenerateEvaluationKeys(60, 2, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(2, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(30, 2, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(4, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(4, 1, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(30, evk.Key(2)[0].Size); } }
public void EncryptionParametersSaveLoadNET() { var stream = new MemoryStream(); var parms = new EncryptionParameters(); var parms2 = new EncryptionParameters(); parms.Save(stream); stream.Seek(0, SeekOrigin.Begin); parms2.Load(stream); Assert.AreEqual(parms.NoiseStandardDeviation, parms2.NoiseStandardDeviation); Assert.AreEqual(parms.NoiseMaxDeviation, parms2.NoiseMaxDeviation); Assert.IsTrue(parms.CoeffModulus.SequenceEqual(parms2.CoeffModulus)); Assert.IsTrue(parms.PlainModulus.Equals(parms2.PlainModulus)); Assert.IsTrue(parms.PolyModulus.Equals(parms2.PolyModulus)); Assert.IsTrue(parms.Equals(parms2)); parms.NoiseStandardDeviation = 3.19; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods30Bit(0) }; parms.PlainModulus = 1 << 6; parms.PolyModulus = "1x^64 + 1"; stream.Seek(0, SeekOrigin.Begin); parms.Save(stream); stream.Seek(0, SeekOrigin.Begin); parms2.Load(stream); Assert.AreEqual(parms.NoiseStandardDeviation, parms2.NoiseStandardDeviation); Assert.AreEqual(parms.NoiseMaxDeviation, parms2.NoiseMaxDeviation); Assert.IsTrue(parms.CoeffModulus.SequenceEqual(parms2.CoeffModulus)); Assert.IsTrue(parms.PlainModulus.Equals(parms2.PlainModulus)); Assert.IsTrue(parms.PolyModulus.Equals(parms2.PolyModulus)); Assert.IsTrue(parms.Equals(parms2)); parms.NoiseStandardDeviation = 3.19; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods60Bit(1) }; parms.PlainModulus = 1 << 30; parms.PolyModulus = "1x^256 + 1"; stream.Seek(0, SeekOrigin.Begin); parms.Save(stream); stream.Seek(0, SeekOrigin.Begin); parms2.Load(stream); Assert.AreEqual(parms.NoiseStandardDeviation, parms2.NoiseStandardDeviation); Assert.AreEqual(parms.NoiseMaxDeviation, parms2.NoiseMaxDeviation); Assert.IsTrue(parms.CoeffModulus.SequenceEqual(parms2.CoeffModulus)); Assert.IsTrue(parms.PlainModulus.Equals(parms2.PlainModulus)); Assert.IsTrue(parms.PolyModulus.Equals(parms2.PolyModulus)); Assert.IsTrue(parms.Equals(parms2)); }
public void SaveLoadPublicKeyNET() { 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 pk = keygen.PublicKey; Assert.IsTrue(pk.HashBlock.Equals(parms.HashBlock)); stream.Seek(0, SeekOrigin.Begin); pk.Save(stream); var pk2 = new PublicKey(); stream.Seek(0, SeekOrigin.Begin); pk2.Load(stream); Assert.AreEqual(pk.Data, pk2.Data); Assert.AreEqual(pk.HashBlock, pk2.HashBlock); } { var parms = new EncryptionParameters(); parms.NoiseStandardDeviation = 3.19; parms.PolyModulus = "1x^256 + 1"; parms.PlainModulus = 1 << 20; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods40Bit(0) }; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); var pk = keygen.PublicKey; Assert.IsTrue(pk.HashBlock.Equals(parms.HashBlock)); stream.Seek(0, SeekOrigin.Begin); pk.Save(stream); var pk2 = new PublicKey(); stream.Seek(0, SeekOrigin.Begin); pk2.Load(stream); Assert.AreEqual(pk.Data, pk2.Data); Assert.AreEqual(pk.HashBlock, pk2.HashBlock); } }
public void ExceptionsTest() { List <SmallModulus> coeffModulus = new List <SmallModulus>() { DefaultParams.SmallMods60Bit(0) }; EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 64, CoeffModulus = coeffModulus, PlainModulus = new SmallModulus(257) }; SEALContext context = SEALContext.Create(parms); BatchEncoder enc = new BatchEncoder(context); List <ulong> valu = new List <ulong>(); List <ulong> valu_null = null; List <long> vall = new List <long>(); List <long> vall_null = null; Plaintext plain = new Plaintext(); Plaintext plain_null = null; MemoryPoolHandle pool_uninit = new MemoryPoolHandle(); Assert.ThrowsException <ArgumentNullException>(() => enc = new BatchEncoder(null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(valu, plain_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(valu_null, plain)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(vall, plain_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(vall_null, plain)); Assert.ThrowsException <ArgumentNullException>(() => enc.Encode(plain_null)); Assert.ThrowsException <ArgumentException>(() => enc.Encode(plain, pool_uninit)); Assert.ThrowsException <ArgumentNullException>(() => enc.Decode(plain, valu_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Decode(plain_null, valu)); Assert.ThrowsException <ArgumentException>(() => enc.Decode(plain, valu, pool_uninit)); Assert.ThrowsException <ArgumentNullException>(() => enc.Decode(plain, vall_null)); Assert.ThrowsException <ArgumentNullException>(() => enc.Decode(plain_null, vall)); Assert.ThrowsException <ArgumentException>(() => enc.Decode(plain, vall, pool_uninit)); Assert.ThrowsException <ArgumentNullException>(() => enc.Decode(plain_null)); Assert.ThrowsException <ArgumentException>(() => enc.Decode(plain, pool_uninit)); }
public void EncodeInPlaceTest() { List <SmallModulus> coeffModulus = new List <SmallModulus>() { DefaultParams.SmallMods60Bit(0) }; EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 64, CoeffModulus = coeffModulus, PlainModulus = new SmallModulus(257) }; SEALContext context = SEALContext.Create(parms); BatchEncoder encoder = new BatchEncoder(context); Assert.AreEqual(64ul, encoder.SlotCount); Plaintext plain = new Plaintext("6x^5 + 5x^4 + 4x^3 + 3x^2 + 2x^1 + 1"); Assert.AreEqual(6ul, plain.CoeffCount); encoder.Encode(plain); Assert.AreEqual(64ul, plain.CoeffCount); encoder.Decode(plain); Assert.AreEqual(64ul, plain.CoeffCount); for (ulong i = 0; i < 6; i++) { Assert.AreEqual((i + 1), plain[i]); } for (ulong i = 6; i < plain.CoeffCount; i++) { Assert.AreEqual(0ul, plain[i]); } }
public void EncodeDecodeVectorTest() { int slots = 32; EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS); parms.PolyModulusDegree = (ulong)slots * 2; List <SmallModulus> coeffModulus = new List <SmallModulus>(4); coeffModulus.Add(DefaultParams.SmallMods60Bit(0)); coeffModulus.Add(DefaultParams.SmallMods60Bit(1)); coeffModulus.Add(DefaultParams.SmallMods60Bit(2)); coeffModulus.Add(DefaultParams.SmallMods60Bit(3)); parms.CoeffModulus = coeffModulus; SEALContext context = SEALContext.Create(parms); CKKSEncoder encoder = new CKKSEncoder(context); List <Complex> values = new List <Complex>(slots); Random rnd = new Random(); int dataBound = 1 << 30; double delta = 1ul << 40; for (int i = 0; i < slots; i++) { values.Add(new Complex(rnd.Next() % dataBound, 0)); } Plaintext plain = new Plaintext(); encoder.Encode(values, delta, plain); List <Complex> result = new List <Complex>(); encoder.Decode(plain, result); for (int i = 0; i < slots; i++) { double tmp = Math.Abs(values[i].Real - result[i].Real); Assert.IsTrue(tmp < 0.5); } }
public void BFVKeyGenerationNET() { var parms = new EncryptionParameters(); { parms.NoiseStandardDeviation = 3.19; parms.PolyModulus = "1x^64 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0) }; parms.PlainModulus = 1 << 6; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); Assert.IsTrue(keygen.PublicKey.HashBlock.Equals(parms.HashBlock)); Assert.IsTrue(keygen.SecretKey.HashBlock.Equals(parms.HashBlock)); var evk = new EvaluationKeys(); keygen.GenerateEvaluationKeys(60, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(2, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(30, 1, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(4, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(2, 2, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(60, evk.Key(2)[0].Size); var galks = new GaloisKeys(); keygen.GenerateGaloisKeys(60, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.AreEqual(2, galks.Key(3)[0].Size); Assert.AreEqual(10, galks.Size); keygen.GenerateGaloisKeys(30, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.AreEqual(4, galks.Key(3)[0].Size); Assert.AreEqual(10, galks.Size); keygen.GenerateGaloisKeys(2, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.AreEqual(60, galks.Key(3)[0].Size); Assert.AreEqual(10, galks.Size); keygen.GenerateGaloisKeys(60, new List <UInt64> { 1, 3, 5, 7 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(3)); Assert.IsTrue(galks.HasKey(5)); Assert.IsTrue(galks.HasKey(7)); Assert.IsFalse(galks.HasKey(9)); Assert.IsFalse(galks.HasKey(127)); Assert.AreEqual(2, galks.Key(1)[0].Size); Assert.AreEqual(2, galks.Key(3)[0].Size); Assert.AreEqual(2, galks.Key(5)[0].Size); Assert.AreEqual(2, galks.Key(7)[0].Size); Assert.AreEqual(4, galks.Size); keygen.GenerateGaloisKeys(30, new List <UInt64> { 1, 3, 5, 7 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(3)); Assert.IsTrue(galks.HasKey(5)); Assert.IsTrue(galks.HasKey(7)); Assert.IsFalse(galks.HasKey(9)); Assert.IsFalse(galks.HasKey(127)); Assert.AreEqual(4, galks.Key(1)[0].Size); Assert.AreEqual(4, galks.Key(3)[0].Size); Assert.AreEqual(4, galks.Key(5)[0].Size); Assert.AreEqual(4, galks.Key(7)[0].Size); Assert.AreEqual(4, galks.Size); keygen.GenerateGaloisKeys(2, new List <UInt64> { 1, 3, 5, 7 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(3)); Assert.IsTrue(galks.HasKey(5)); Assert.IsTrue(galks.HasKey(7)); Assert.IsFalse(galks.HasKey(9)); Assert.IsFalse(galks.HasKey(127)); Assert.AreEqual(60, galks.Key(1)[0].Size); Assert.AreEqual(60, galks.Key(3)[0].Size); Assert.AreEqual(60, galks.Key(5)[0].Size); Assert.AreEqual(60, galks.Key(7)[0].Size); Assert.AreEqual(4, galks.Size); keygen.GenerateGaloisKeys(30, new List <UInt64> { 1 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsFalse(galks.HasKey(3)); Assert.IsFalse(galks.HasKey(127)); Assert.AreEqual(4, galks.Key(1)[0].Size); Assert.AreEqual(1, galks.Size); keygen.GenerateGaloisKeys(30, new List <UInt64> { 127 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsFalse(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(127)); Assert.AreEqual(4, galks.Key(127)[0].Size); Assert.AreEqual(1, galks.Size); } { parms.NoiseStandardDeviation = 3.19; parms.PolyModulus = "1x^256 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0), DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1) }; parms.PlainModulus = 1 << 6; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); Assert.AreEqual(keygen.PublicKey.HashBlock, parms.HashBlock); Assert.AreEqual(keygen.SecretKey.HashBlock, parms.HashBlock); var evk = new EvaluationKeys(); keygen.GenerateEvaluationKeys(60, 2, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(2, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(30, 2, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(4, evk.Key(2)[0].Size); keygen.GenerateEvaluationKeys(4, 1, evk); Assert.AreEqual(evk.HashBlock, parms.HashBlock); Assert.AreEqual(30, evk.Key(2)[0].Size); var galks = new GaloisKeys(); keygen.GenerateGaloisKeys(60, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.AreEqual(2, galks.Key(3)[0].Size); Assert.AreEqual(14, galks.Size); keygen.GenerateGaloisKeys(30, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.AreEqual(4, galks.Key(3)[0].Size); Assert.AreEqual(14, galks.Size); keygen.GenerateGaloisKeys(2, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.AreEqual(60, galks.Key(3)[0].Size); Assert.AreEqual(14, galks.Size); keygen.GenerateGaloisKeys(60, new List <UInt64> { 1, 3, 5, 7 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(3)); Assert.IsTrue(galks.HasKey(5)); Assert.IsTrue(galks.HasKey(7)); Assert.IsFalse(galks.HasKey(9)); Assert.IsFalse(galks.HasKey(511)); Assert.AreEqual(2, galks.Key(1)[0].Size); Assert.AreEqual(2, galks.Key(3)[0].Size); Assert.AreEqual(2, galks.Key(5)[0].Size); Assert.AreEqual(2, galks.Key(7)[0].Size); Assert.AreEqual(4, galks.Size); keygen.GenerateGaloisKeys(30, new List <UInt64> { 1, 3, 5, 7 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(3)); Assert.IsTrue(galks.HasKey(5)); Assert.IsTrue(galks.HasKey(7)); Assert.IsFalse(galks.HasKey(9)); Assert.IsFalse(galks.HasKey(511)); Assert.AreEqual(4, galks.Key(1)[0].Size); Assert.AreEqual(4, galks.Key(3)[0].Size); Assert.AreEqual(4, galks.Key(5)[0].Size); Assert.AreEqual(4, galks.Key(7)[0].Size); Assert.AreEqual(4, galks.Size); keygen.GenerateGaloisKeys(2, new List <UInt64> { 1, 3, 5, 7 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(3)); Assert.IsTrue(galks.HasKey(5)); Assert.IsTrue(galks.HasKey(7)); Assert.IsFalse(galks.HasKey(9)); Assert.IsFalse(galks.HasKey(511)); Assert.AreEqual(60, galks.Key(1)[0].Size); Assert.AreEqual(60, galks.Key(3)[0].Size); Assert.AreEqual(60, galks.Key(5)[0].Size); Assert.AreEqual(60, galks.Key(7)[0].Size); Assert.AreEqual(4, galks.Size); keygen.GenerateGaloisKeys(30, new List <UInt64> { 1 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsTrue(galks.HasKey(1)); Assert.IsFalse(galks.HasKey(3)); Assert.IsFalse(galks.HasKey(511)); Assert.AreEqual(4, galks.Key(1)[0].Size); Assert.AreEqual(1, galks.Size); keygen.GenerateGaloisKeys(30, new List <UInt64> { 511 }, galks); Assert.AreEqual(galks.HashBlock, parms.HashBlock); Assert.IsFalse(galks.HasKey(1)); Assert.IsTrue(galks.HasKey(511)); Assert.AreEqual(4, galks.Key(511)[0].Size); Assert.AreEqual(1, galks.Size); } }
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 FVEncryptDecryptNET() { var parms = new EncryptionParameters(); var plain_modulus = new SmallModulus(1 << 6); parms.NoiseStandardDeviation = 3.19; parms.PlainModulus = plain_modulus; { parms.PolyModulus = "1x^64 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0) }; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); var encoder = new BalancedEncoder(plain_modulus); var encryptor = new Encryptor(context, keygen.PublicKey); var decryptor = new Decryptor(context, keygen.SecretKey); var encrypted = new Ciphertext(); var plain = new Plaintext(); encryptor.Encrypt(encoder.Encode(0x12345678), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x12345678UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(1), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(1UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(2), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(2UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFD), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFE), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFF), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(314159265), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(314159265UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); } { parms.PolyModulus = "1x^128 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1) }; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); var encoder = new BalancedEncoder(plain_modulus); var encryptor = new Encryptor(context, keygen.PublicKey); var decryptor = new Decryptor(context, keygen.SecretKey); var encrypted = new Ciphertext(); var plain = new Plaintext(); encryptor.Encrypt(encoder.Encode(0x12345678), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x12345678UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(1), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(1UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(2), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(2UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFD), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFE), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFF), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(314159265), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(314159265UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); } { parms.PolyModulus = "1x^256 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1), DefaultParams.SmallMods40Bit(2) }; var context = new SEALContext(parms); var keygen = new KeyGenerator(context); var encoder = new BalancedEncoder(plain_modulus); var encryptor = new Encryptor(context, keygen.PublicKey); var decryptor = new Decryptor(context, keygen.SecretKey); var encrypted = new Ciphertext(); var plain = new Plaintext(); encryptor.Encrypt(encoder.Encode(0x12345678), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x12345678UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(1), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(1UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(2), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(2UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFD), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFE), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFF), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); encryptor.Encrypt(encoder.Encode(314159265), encrypted); decryptor.Decrypt(encrypted, plain); Assert.AreEqual(314159265UL, encoder.DecodeUInt64(plain)); Assert.AreEqual(encrypted.HashBlock, parms.HashBlock); } }
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); } } } }
public void EncodeLongTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV); parms.PolyModulusDegree = 64; List <SmallModulus> coeffModulus = new List <SmallModulus>(); coeffModulus.Add(DefaultParams.SmallMods60Bit(0)); parms.CoeffModulus = coeffModulus; parms.PlainModulus = new SmallModulus(257); SEALContext context = SEALContext.Create(parms); BatchEncoder encoder = new BatchEncoder(context); Assert.AreEqual(64ul, encoder.SlotCount); List <long> plainList = new List <long>(); for (ulong i = 0; i < encoder.SlotCount; i++) { plainList.Add((long)i); } Plaintext plain = new Plaintext(); encoder.Encode(plainList, plain); List <long> plainList2 = new List <long>(); encoder.Decode(plain, plainList2); for (ulong i = 0; i < encoder.SlotCount; i++) { Assert.AreEqual(plainList[(int)i], plainList2[(int)i]); } for (ulong i = 0; i < encoder.SlotCount; i++) { plainList[(int)i] = 5; } encoder.Encode(plainList, plain); Assert.AreEqual("5", plain.ToString()); encoder.Decode(plain, plainList2); for (ulong i = 0; i < encoder.SlotCount; i++) { Assert.AreEqual(plainList[(int)i], plainList2[(int)i]); } List <long> shortList = new List <long>(); for (int i = 0; i < 20; i++) { shortList.Add((long)i); } encoder.Encode(shortList, plain); List <long> shortList2 = new List <long>(); encoder.Decode(plain, shortList2); Assert.AreEqual(20, shortList.Count); Assert.AreEqual(64, shortList2.Count); for (int i = 0; i < 20; i++) { Assert.AreEqual(shortList[i], shortList2[i]); } for (ulong i = 20; i < encoder.SlotCount; i++) { Assert.AreEqual(0L, shortList2[(int)i]); } }
public void SmallMods60BitFailTest() { SmallModulus sm = DefaultParams.SmallMods60Bit(64); }
public void BatchUnbatchIntVectorNET() { var parms = new EncryptionParameters(); parms.PolyModulus = "1x^64 + 1"; parms.CoeffModulus = new List <SmallModulus> { DefaultParams.SmallMods60Bit(0) }; parms.PlainModulus = 257; var context = new SEALContext(parms); Assert.IsTrue(context.Qualifiers.EnableBatching); var crtbuilder = new PolyCRTBuilder(context); Assert.AreEqual(64, crtbuilder.SlotCount); var plain_vec = new List <Int64>(); for (int i = 0; i < crtbuilder.SlotCount; i++) { plain_vec.Add((Int64)i * (1 - 2 * (i % 2))); } var plain = new Plaintext(); crtbuilder.Compose(plain_vec, plain); var plain_vec2 = new List <Int64>(); crtbuilder.Decompose(plain, plain_vec2); Assert.IsTrue(plain_vec.SequenceEqual(plain_vec2)); for (int i = 0; i < crtbuilder.SlotCount; i++) { plain_vec[i] = -5; } crtbuilder.Compose(plain_vec, plain); Assert.IsTrue(plain.ToString().Equals("FC")); crtbuilder.Decompose(plain, plain_vec2); Assert.IsTrue(plain_vec.SequenceEqual(plain_vec2)); var short_plain_vec = new List <Int64>(); for (int i = 0; i < 20; i++) { short_plain_vec.Add((Int64)i * (1 - 2 * (i % 2))); } crtbuilder.Compose(short_plain_vec, plain); var short_plain_vec2 = new List <Int64>(); crtbuilder.Decompose(plain, short_plain_vec2); Assert.AreEqual(20, short_plain_vec.Count); Assert.AreEqual(64, short_plain_vec2.Count); for (int i = 0; i < 20; i++) { Assert.AreEqual(short_plain_vec[i], short_plain_vec2[i]); } for (int i = 20; i < crtbuilder.SlotCount; i++) { Assert.AreEqual(0L, short_plain_vec2[i]); } }