public void EncodeDecodeUlongTest() { int slots = 32; EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS); parms.PolyModulusDegree = (ulong)slots * 2; List <SmallModulus> coeffModulus = new List <SmallModulus>(4); coeffModulus.Add(DefaultParams.SmallMods40Bit(0)); coeffModulus.Add(DefaultParams.SmallMods40Bit(1)); coeffModulus.Add(DefaultParams.SmallMods40Bit(2)); coeffModulus.Add(DefaultParams.SmallMods40Bit(3)); parms.CoeffModulus = coeffModulus; SEALContext context = SEALContext.Create(parms); CKKSEncoder encoder = new CKKSEncoder(context); Plaintext plain = new Plaintext(); List <Complex> result = new List <Complex>(); long value = 15; encoder.Encode(value, plain); encoder.Decode(plain, result); for (int i = 0; i < slots; i++) { double tmp = Math.Abs(value - result[i].Real); Assert.IsTrue(tmp < 0.5); } }
public void EncodeDecodeDoubleTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS); parms.PolyModulusDegree = 64; List <SmallModulus> coeffModulus = new List <SmallModulus>(4); coeffModulus.Add(DefaultParams.SmallMods40Bit(0)); coeffModulus.Add(DefaultParams.SmallMods40Bit(1)); coeffModulus.Add(DefaultParams.SmallMods40Bit(2)); coeffModulus.Add(DefaultParams.SmallMods40Bit(3)); parms.CoeffModulus = coeffModulus; SEALContext context = SEALContext.Create(parms); int slots = 16; Plaintext plain = new Plaintext(); double delta = 1 << 16; List <Complex> result = new List <Complex>(); CKKSEncoder encoder = new CKKSEncoder(context); Assert.AreEqual(32ul, encoder.SlotCount); double value = 10d; encoder.Encode(value, delta, plain); encoder.Decode(plain, result); for (int i = 0; i < slots; i++) { double tmp = Math.Abs(value - result[i].Real); Assert.IsTrue(tmp < 0.5); } }
public void EncodeDecodeVectorDoubleTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS) { PolyModulusDegree = 64, CoeffModulus = new List <SmallModulus>() { DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1) } }; SEALContext context = SEALContext.Create(parms); CKKSEncoder encoder = new CKKSEncoder(context); Plaintext plain = new Plaintext(); double[] values = new double[] { 0.1, 2.3, 34.4 }; encoder.Encode(values, scale: Math.Pow(2, 20), destination: plain); List <double> result = new List <double>(); encoder.Decode(plain, result); Assert.IsNotNull(result); Assert.AreEqual(0.1, result[0], delta: 0.001); Assert.AreEqual(2.3, result[1], delta: 0.001); Assert.AreEqual(34.4, result[2], delta: 0.001); }
public void CreateTest() { List <SmallModulus> coeffModulus = new List <SmallModulus> { DefaultParams.SmallMods40Bit(0) }; EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 64, PlainModulus = new SmallModulus(1 << 6), CoeffModulus = coeffModulus }; SEALContext context = SEALContext.Create(parms); KeyGenerator keygen = new KeyGenerator(context); SecretKey secret = keygen.SecretKey; SecretKey copy = new SecretKey(secret); Assert.AreEqual(64ul, copy.Data.CoeffCount); Assert.IsTrue(copy.Data.IsNTTForm); SecretKey copy2 = new SecretKey(); copy2.Set(copy); Assert.AreEqual(64ul, copy2.Data.CoeffCount); Assert.IsTrue(copy2.Data.IsNTTForm); }
public ActionResult <string> CreateDefault([FromBody] DefaultParams p) { string playerName = _signInManager.UserManager.GetUserName(this.User); GameTask game = GameManager.Instance.CreateDefaultGame(playerName); return(Ok(game.Id)); }
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 EncodeDecodeComplexTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS) { PolyModulusDegree = 64, CoeffModulus = new List <SmallModulus>() { DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1), DefaultParams.SmallMods40Bit(2), DefaultParams.SmallMods40Bit(3) } }; SEALContext context = SEALContext.Create(parms); CKKSEncoder encoder = new CKKSEncoder(context); Plaintext plain = new Plaintext(); Complex value = new Complex(3.1415, 2.71828); encoder.Encode(value, scale: Math.Pow(2, 20), destination: plain); List <Complex> result = new List <Complex>(); encoder.Decode(plain, result); Assert.IsTrue(result.Count > 0); Assert.AreEqual(3.1415, result[0].Real, delta: 0.0001); Assert.AreEqual(2.71828, result[0].Imaginary, delta: 0.0001); }
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 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 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 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 HomomorphicKeyManager() { EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV); parms.PolyModulusDegree = 2048; parms.CoeffModulus = DefaultParams.CoeffModulus128(polyModulusDegree: 2048); parms.PlainModulus = new SmallModulus(1 << 8); Context = SEALContext.Create(parms); }
static SEALContext createContext(ulong keysize) { EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV); parms.PolyModulusDegree = keysize; parms.CoeffModulus = DefaultParams.CoeffModulus128(polyModulusDegree: keysize); parms.PlainModulus = new SmallModulus(1 << 8); return(SEALContext.Create(parms)); }
public void SEALContextParamsTest() { List <SmallModulus> coeffModulus = new List <SmallModulus> { DefaultParams.SmallMods30Bit(0), DefaultParams.SmallMods30Bit(1), DefaultParams.SmallMods30Bit(2) }; EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 128, PlainModulus = new SmallModulus(1 << 6), CoeffModulus = coeffModulus }; SEALContext context = SEALContext.Create(parms); SEALContext.ContextData data = context.FirstContextData; Assert.IsNotNull(data); EncryptionParameters parms2 = data.Parms; Assert.AreEqual(parms.PolyModulusDegree, parms2.PolyModulusDegree); Assert.AreEqual(parms.NoiseStandardDeviation, parms2.NoiseStandardDeviation); EncryptionParameterQualifiers qualifiers = data.Qualifiers; Assert.IsNotNull(qualifiers); Assert.IsTrue(qualifiers.ParametersSet); Assert.IsFalse(qualifiers.UsingBatching); Assert.IsTrue(qualifiers.UsingFastPlainLift); Assert.IsTrue(qualifiers.UsingFFT); Assert.IsTrue(qualifiers.UsingNTT); Assert.IsTrue(qualifiers.UsingHEStdSecurity); ulong[] cdpm = data.CoeffDivPlainModulus; Assert.AreEqual(3, cdpm.Length); Assert.AreEqual(32ul, data.PlainUpperHalfThreshold); Assert.AreEqual(3, data.PlainUpperHalfIncrement.Length); Assert.IsNull(data.UpperHalfThreshold); Assert.IsNotNull(data.UpperHalfIncrement); Assert.AreEqual(3, data.UpperHalfIncrement.Length); Assert.AreEqual(2ul, data.ChainIndex); SEALContext.ContextData data2 = data.NextContextData; Assert.IsNotNull(data2); Assert.AreEqual(1ul, data2.ChainIndex); SEALContext.ContextData data3 = data2.NextContextData; Assert.IsNotNull(data3); Assert.AreEqual(0ul, data3.ChainIndex); Assert.IsNull(data3.NextContextData); }
public void SmallMods30BitTest() { SmallModulus sm = DefaultParams.SmallMods30Bit(20); Assert.IsNotNull(sm); Assert.AreEqual(30, sm.BitCount); Assert.AreEqual(0x3BE80001ul, sm.Value); Assert.ThrowsException <ArgumentOutOfRangeException>(() => DefaultParams.SmallMods30Bit(64)); }
public void SaveLoadTest() { TestDelegate save_load_test = delegate(SchemeType scheme) { List <SmallModulus> coeffModulus = new List <SmallModulus> { DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1) }; EncryptionParameters parms = new EncryptionParameters(scheme) { PolyModulusDegree = 8, CoeffModulus = coeffModulus }; if (scheme == SchemeType.BFV) { parms.SetPlainModulus(257); } EncryptionParameters loaded = null; using (MemoryStream stream = new MemoryStream()) { EncryptionParameters.Save(parms, stream); stream.Seek(offset: 0, loc: SeekOrigin.Begin); loaded = EncryptionParameters.Load(stream); } Assert.AreEqual(scheme, loaded.Scheme); Assert.AreEqual(8ul, loaded.PolyModulusDegree); if (scheme == SchemeType.BFV) { Assert.AreEqual(257ul, loaded.PlainModulus.Value); } else if (scheme == SchemeType.CKKS) { Assert.AreEqual(0ul, loaded.PlainModulus.Value); } List <SmallModulus> loadedCoeffModulus = new List <SmallModulus>(loaded.CoeffModulus); Assert.AreEqual(2, loadedCoeffModulus.Count); Assert.AreNotSame(coeffModulus[0], loadedCoeffModulus[0]); Assert.AreNotSame(coeffModulus[1], loadedCoeffModulus[1]); Assert.AreEqual(coeffModulus[0], loadedCoeffModulus[0]); Assert.AreEqual(coeffModulus[1], loadedCoeffModulus[1]); Assert.AreEqual(parms.NoiseMaxDeviation, loaded.NoiseMaxDeviation, delta: 0.001); Assert.AreEqual(parms.NoiseStandardDeviation, loaded.NoiseStandardDeviation, delta: 0.001); }; save_load_test(SchemeType.BFV); save_load_test(SchemeType.CKKS); }
static GlobalContext() { EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 4096, CoeffModulus = DefaultParams.CoeffModulus128(polyModulusDegree: 4096) }; encParams.SetPlainModulus(0x133Ful); Context = SEALContext.Create(encParams); }
private SEALContext GetContext() { var parms = new EncryptionParameters(); parms.PolyModulus = "1x^2048 + 1"; parms.CoeffModulus = DefaultParams.CoeffModulus128(2048); parms.PlainModulus = 1 << 8; var context = new SEALContext(parms); return(context); }
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)); }
void Start() { animator = GetComponent <Animator>(); combatCanvas = GetComponentInChildren <Canvas>(); _controller = GetComponent <EnemyController>(); _boxCollider = GetComponent <BoxCollider2D>(); _targetPosition = GameManager.instance._treeRef.transform.position; _moveDirection = (_targetPosition.x - transform.position.x > 0 ? Vector2.right : Vector2.left); _isDead = false; kinematicMotionEnabled = false; _velocity = new Vector2(moveVelocity * _moveDirection.x, 0f); _defaultParams = new DefaultParams(moveVelocity, hitPoints, damage); }
public static SEALContext GetContext() { var encryptionParameters = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 32768, CoeffModulus = DefaultParams.CoeffModulus128(polyModulusDegree: 32768) }; encryptionParameters.SetPlainModulus(0x133Ful); Debug.WriteLine("[COMMON]: Successfully created context"); return(SEALContext.Create(encryptionParameters)); }
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 Coeffs256Test() { List <SmallModulus> coeffs = new List <SmallModulus>(DefaultParams.CoeffModulus256(4096)); Assert.IsNotNull(coeffs); Assert.AreEqual(1, coeffs.Count); Assert.AreEqual(0x03ffffffff040001ul, coeffs[0].Value); coeffs = new List <SmallModulus>(DefaultParams.CoeffModulus256(8192)); Assert.IsNotNull(coeffs); Assert.AreEqual(2, coeffs.Count); Assert.AreEqual(0x07ffffffffcc0001ul, coeffs[0].Value); Assert.AreEqual(0x07ffffffffb00001ul, coeffs[1].Value); }
public void Coeffs192Test() { List <SmallModulus> coeffs = new List <SmallModulus>(DefaultParams.CoeffModulus192(4096)); Assert.IsNotNull(coeffs); Assert.AreEqual(2, coeffs.Count); Assert.AreEqual(0x0000003fffe80001ul, coeffs[0].Value); Assert.AreEqual(0x0000001ffffc0001ul, coeffs[1].Value); coeffs = new List <SmallModulus>(DefaultParams.CoeffModulus192(8192)); Assert.IsNotNull(coeffs); Assert.AreEqual(3, coeffs.Count); Assert.AreEqual(0x0007ffffff9c0001ul, coeffs[0].Value); Assert.AreEqual(0x0007ffffff900001ul, coeffs[1].Value); Assert.AreEqual(0x0003ffffffb80001ul, coeffs[2].Value); }
public void SaveLoadTest() { List <SmallModulus> coeffModulus = new List <SmallModulus> { DefaultParams.SmallMods40Bit(0) }; EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 64, PlainModulus = new SmallModulus(1 << 6), CoeffModulus = coeffModulus }; SEALContext context = SEALContext.Create(parms); KeyGenerator keygen = new KeyGenerator(context); SecretKey secret = keygen.SecretKey; Assert.AreEqual(64ul, secret.Data.CoeffCount); Assert.IsTrue(secret.Data.IsNTTForm); Assert.AreNotEqual(ParmsId.Zero, secret.ParmsId); SecretKey secret2 = new SecretKey(); MemoryPoolHandle handle = secret2.Pool; Assert.IsNotNull(secret2); Assert.AreEqual(0ul, secret2.Data.CoeffCount); Assert.IsFalse(secret2.Data.IsNTTForm); ulong alloced = handle.AllocByteCount; using (MemoryStream stream = new MemoryStream()) { secret.Save(stream); stream.Seek(offset: 0, loc: SeekOrigin.Begin); secret2.Load(context, stream); } Assert.AreNotSame(secret, secret2); Assert.AreEqual(64ul, secret2.Data.CoeffCount); Assert.IsTrue(secret2.Data.IsNTTForm); Assert.AreNotEqual(ParmsId.Zero, secret2.ParmsId); Assert.AreEqual(secret.ParmsId, secret2.ParmsId); Assert.IsTrue(handle.AllocByteCount != alloced); }
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 SetParams(int level, Vector2 position) { gameObject.SetActive(true); transform.position = position; if (_defaultParams == null) { _defaultParams = new DefaultParams(moveVelocity, hitPoints, damage); } _defaultParams.Reset(this); this.damage += this.damage * (float)level / 10; this.hitPoints += this.hitPoints * (float)level / 10; this.transform.localScale = new Vector3(currentScale + (float)level / 50, currentScale + (float)level / 50, 0); //Debug.Log(gameObject.name + " level: " + level + " hp: " + hitPoints + " damage: " + damage); }
public void EqualsTest() { EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 8, PlainModulus = new SmallModulus(257), CoeffModulus = new List <SmallModulus>() { DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1) } }; EncryptionParameters parms2 = new EncryptionParameters(SchemeType.CKKS); Assert.AreNotEqual(parms, parms2); Assert.IsFalse(parms.Equals(null)); }
public void SaveLoadTest() { List <SmallModulus> coeffModulus = new List <SmallModulus> { DefaultParams.SmallMods40Bit(0) }; EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV) { PolyModulusDegree = 64, PlainModulus = new SmallModulus(1 << 6), CoeffModulus = coeffModulus }; SEALContext context = SEALContext.Create(parms); KeyGenerator keygen = new KeyGenerator(context); PublicKey pub = keygen.PublicKey; Assert.IsNotNull(pub); Assert.AreEqual(2ul, pub.Data.Size); Assert.IsTrue(pub.Data.IsNTTForm); PublicKey pub2 = new PublicKey(); MemoryPoolHandle handle = pub2.Pool; Assert.AreEqual(0ul, pub2.Data.Size); Assert.IsFalse(pub2.Data.IsNTTForm); Assert.AreEqual(ParmsId.Zero, pub2.ParmsId); using (MemoryStream stream = new MemoryStream()) { pub.Save(stream); stream.Seek(offset: 0, loc: SeekOrigin.Begin); pub2.Load(context, stream); } Assert.AreNotSame(pub, pub2); Assert.AreEqual(2ul, pub2.Data.Size); Assert.IsTrue(pub2.Data.IsNTTForm); Assert.AreEqual(pub.ParmsId, pub2.ParmsId); Assert.AreNotEqual(ParmsId.Zero, pub2.ParmsId); Assert.IsTrue(handle.AllocByteCount != 0ul); }