public void EncryptExponentiateDecryptNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 4); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var keygen = new KeyGenerator(parms); keygen.Generate(); var Encoder = new BinaryEncoder(parms.PlainModulus); var encryptor = new Encryptor(parms, keygen.PublicKey); var evaluator = new Evaluator(parms, keygen.EvaluationKeys); var keygenEvals = keygen.EvaluationKeys; var evaluatorEvals = keygen.EvaluationKeys; for (int i = 0; i < keygen.EvaluationKeys.Count; ++i) { Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]); } var decryptor = new Decryptor(parms, keygen.SecretKey); var encrypted = encryptor.Encrypt(Encoder.Encode(5)); var power = evaluator.Exponentiate(encrypted, 1); Assert.AreEqual(5, Encoder.DecodeInt32(decryptor.Decrypt(power))); encrypted = encryptor.Encrypt(Encoder.Encode(5)); power = evaluator.Exponentiate(encrypted, 0); Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(power))); encrypted = encryptor.Encrypt(Encoder.Encode(5)); power = evaluator.Exponentiate(encrypted, 0); Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(power))); encrypted = encryptor.Encrypt(Encoder.Encode(7)); power = evaluator.Exponentiate(encrypted, 2); Assert.AreEqual(49, Encoder.DecodeInt32(decryptor.Decrypt(power))); encrypted = encryptor.Encrypt(Encoder.Encode(-7)); power = evaluator.Exponentiate(encrypted, 3); Assert.AreEqual(-343, Encoder.DecodeInt32(decryptor.Decrypt(power))); }
public void EncryptAddDecryptNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 6); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var keygen = new KeyGenerator(parms); keygen.Generate(); var Encoder = new BinaryEncoder(parms.PlainModulus); var encryptor = new Encryptor(parms, keygen.PublicKey); var evaluator = new Evaluator(parms, keygen.EvaluationKeys); var decryptor = new Decryptor(parms, keygen.SecretKey); var encrypted1 = encryptor.Encrypt(Encoder.Encode(0x12345678)); var encrypted2 = encryptor.Encrypt(Encoder.Encode(0x54321)); var sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(Encoder.Encode(0)); encrypted2 = encryptor.Encrypt(Encoder.Encode(0)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(0UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(Encoder.Encode(0)); encrypted2 = encryptor.Encrypt(Encoder.Encode(5)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(5UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(Encoder.Encode(5)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-3)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(2, Encoder.DecodeInt32(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(Encoder.Encode(-7)); encrypted2 = encryptor.Encrypt(Encoder.Encode(2)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(-5, Encoder.DecodeInt32(decryptor.Decrypt(sum))); }
public void FVEncryptAddsNoiseNET() { var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew()); parms.SetDecompositionBitCount(4); parms.SetNoiseStandardDeviation(3.19); parms.SetNoiseMaxDeviation(35.06); var coeffModulus = new BigUInt(48); coeffModulus.Set("FFFFFFFFC001"); parms.SetCoeffModulus(coeffModulus); var plainModulus = new BigUInt(7); plainModulus.Set(1 << 6); parms.SetPlainModulus(plainModulus); var polyModulus = new BigPoly(65, 1); polyModulus[0].Set(1); polyModulus[64].Set(1); parms.SetPolyModulus(polyModulus); parms.Validate(); var Encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew()); var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew()); keygen.Generate(); var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew()); // however, this line is fine Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]); Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]); var encrypted1 = encryptor.Encrypt(Encoder.Encode(0x12345678)); var encrypted2 = encryptor.Encrypt(Encoder.Encode(0x12345678)); // this is what we want to check Assert.AreNotEqual(encrypted1[0], encrypted2[0]); Assert.AreNotEqual(encrypted1[1], encrypted2[1]); var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew()); Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted1))); Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted2))); }
public static bool Encode(BinaryEncoder encoder, byte[] value) { try { encoder.Encode((uint)value.Length); encoder.Encode(value); } catch (System.Exception) { return(false); } return(true); }
public void FVEncryptExponentiateDecryptNET() { var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew()); parms.SetDecompositionBitCount(4); parms.SetNoiseStandardDeviation(3.19); parms.SetNoiseMaxDeviation(35.06); var coeffModulus = new BigUInt(48); coeffModulus.Set("FFFFFFFFC001"); parms.SetCoeffModulus(coeffModulus); var plainModulus = new BigUInt(7); plainModulus.Set(1 << 6); parms.SetPlainModulus(plainModulus); var polyModulus = new BigPoly(65, 1); polyModulus[0].Set(1); polyModulus[64].Set(1); parms.SetPolyModulus(polyModulus); parms.Validate(); var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew()); keygen.Generate(1); var encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew()); var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew()); var evaluator = new Evaluator(parms, keygen.EvaluationKeys, MemoryPoolHandle.AcquireNew()); var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew()); var encrypted = encryptor.Encrypt(encoder.Encode(5)); var power = evaluator.Exponentiate(encrypted, 1); Assert.AreEqual(5, encoder.DecodeInt32(decryptor.Decrypt(power))); encrypted = encryptor.Encrypt(encoder.Encode(7)); power = evaluator.Exponentiate(encrypted, 2); Assert.AreEqual(49, encoder.DecodeInt32(decryptor.Decrypt(power))); encrypted = encryptor.Encrypt(encoder.Encode(-7)); power = evaluator.Exponentiate(encrypted, 3); Assert.AreEqual(-343, encoder.DecodeInt32(decryptor.Decrypt(power))); }
//public static bool EncodeUTF8String(BinaryEncoder encoder, string value) //{ // try // { // byte[] encoded_str = System.Text.Encoding.UTF8.GetBytes(value); // encoder.Encode((uint)encoded_str.Length); // encoder.Encode(encoded_str); // } // catch (System.Exception) // { // return false; // } // return true; //} public static bool EncodeUnicodeString(BinaryEncoder encoder, string value) { try { encoder.Encode((ushort)value.Length); byte[] encoded_str = System.Text.Encoding.Unicode.GetBytes(value); encoder.Encode(encoded_str); } catch (System.Exception) { return(false); } return(true); }
public void TestEncoderDecoder() { Value value = new Value(new SubValue(new SubSubValue("")), Value.bytes); Value decoded = new Value(); this.Measure(() => { byte[] buffer = new byte[8 * 1024]; int length = BinaryEncoder.Encode(value, buffer, 0); Logger.Log($"Encoded message size: {length}"); decoded = BinaryDecoder.Decode <Value>(buffer, 0, length); }, "Encoder and Decoder"); Assert.AreEqual(value.intVal, decoded.intVal); Assert.AreEqual(value.shortVal, decoded.shortVal); Assert.AreEqual(value.longVal, decoded.longVal); Assert.AreEqual(value.uintVal, decoded.uintVal); Assert.AreEqual(value.ushortVal, decoded.ushortVal); Assert.AreEqual(value.ulongVal, decoded.ulongVal); Assert.AreEqual(value.stringVal, decoded.stringVal); Assert.AreEqual(value.bytesVal, decoded.bytesVal); Assert.AreEqual(value.subValue, decoded.subValue); Assert.AreEqual(value.subValue?.subSubValue.empty, decoded.subValue?.subSubValue.empty); }
public void FVEncryptAddsNoiseNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 6); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var Encoder = new BinaryEncoder(parms.PlainModulus); var keygen = new KeyGenerator(parms); keygen.Generate(); var encryptor = new Encryptor(parms, keygen.PublicKey); // however, this line is fine Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]); Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]); var encrypted1 = encryptor.Encrypt(Encoder.Encode(0x12345678)); var encrypted2 = encryptor.Encrypt(Encoder.Encode(0x12345678)); // this is what we want to check Assert.AreNotEqual(encrypted1[0], encrypted2[0]); Assert.AreNotEqual(encrypted1[1], encrypted2[1]); var decryptor = new Decryptor(parms, keygen.SecretKey); Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted1))); Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted2))); }
public void TestEncoder() { Value value = new Value(new SubValue(new SubSubValue("")), Value.bytes); this.Measure(() => { byte[] buffer = new byte[8 * 1024]; BinaryEncoder.Encode(value, buffer, 0); }, "Encoder"); }
public void FVEncryptDecryptNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 6); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var Encoder = new BinaryEncoder(parms.PlainModulus); var keygen = new KeyGenerator(parms); keygen.Generate(); var encryptor = new Encryptor(parms, keygen.PublicKey); Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]); Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]); var decryptor = new Decryptor(parms, keygen.SecretKey); Assert.AreEqual(decryptor.SecretKey, keygen.SecretKey); var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678)); Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0)); Assert.AreEqual(0U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(1)); Assert.AreEqual(1U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(2)); Assert.AreEqual(2U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFDUL)); Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFEUL)); Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFFUL)); Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted))); }
public void Write <TMessage>(TMessage message) where TMessage : ITypedMessage { lock (this.lockToken) { var startIndex = this.currentBufferLength; this.currentBufferLength += CoderHelper.WriteInt(message.type, this.currentBuffer, this.currentBufferLength); this.currentBufferLength += BinaryEncoder.Encode(message, this.currentBuffer, this.currentBufferLength); this.currentBufferLength += CoderHelper.AddChecksum(this.currentBuffer, startIndex, this.currentBufferLength); this.currentBufferLength += CoderHelper.InsertDelimiter(this.currentBuffer, this.currentBufferLength); } }
public void TestDecoder() { Value value = new Value(new SubValue(new SubSubValue("")), Value.bytes); byte[] buffer = new byte[8 * 1024]; int length = BinaryEncoder.Encode(value, buffer, 0); this.Measure(() => { _ = BinaryDecoder.Decode <Value>(buffer, 0, length); }, "Decoder"); }
public Task <long> WriteBlockAsync(IAvroWriterBlock <T> block) { if (block == null) { throw new ArgumentNullException("block"); } var taskSource = new TaskCompletionSource <long>(); block.Flush(); long result = 0; lock (this.locker) { if (!this.isHeaderWritten) { // This is never used. result = this.WriteHeader(); } if (block.ObjectCount != 0) { // Replace this with a MemoryStream, as we will be limited to the size of an Azure Blob Block using (var stream = new MemoryStream()) { using (var encoder = new BinaryEncoder(stream, true)) { encoder.Encode(block.ObjectCount); encoder.Encode(block.Content); encoder.EncodeFixed(this.header.SyncMarker); stream.Seek(0, SeekOrigin.Begin); this.WriteStreamToBlobAsync(stream); } } } } taskSource.SetResult(result); return(taskSource.Task); }
public static bool Encode(BinaryEncoder encoder, string value) { try { ushort size = (ushort)value.Length; encoder.Encode(size); byte[] bytes = new byte[value.Length]; for (int i = 0; i < value.Length; ++i) { bytes[i] = (byte)value[i]; } encoder.Encode(bytes); } catch (System.Exception) { return(false); } return(true); }
public void TestMessageSize() { LoginRequest request = new LoginRequest { accessToken = "asdfasdfasdf", username = "******" }; byte[] buffer = new byte[8 * 1024]; int size = BinaryEncoder.Encode(request, buffer, 0); Logger.Log($"LoginRequest Message size: {size}"); }
public static bool Encode(BinaryEncoder encoder, FixedPoint value) { try { encoder.Encode(value.RawValue); } catch (System.Exception) { return(false); } return(true); }
public static bool Encode(BinaryEncoder encoder, double value) { try { encoder.Encode(value); } catch (System.Exception) { return(false); } return(true); }
public void EncryptNegateDecryptNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 6); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var keygen = new KeyGenerator(parms); keygen.Generate(); var Encoder = new BinaryEncoder(parms.PlainModulus); var encryptor = new Encryptor(parms, keygen.PublicKey); var evaluator = new Evaluator(parms, keygen.EvaluationKeys); var decryptor = new Decryptor(parms, keygen.SecretKey); var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678)); var negated = evaluator.Negate(encrypted); Assert.AreEqual(-0x12345678, Encoder.DecodeInt32(decryptor.Decrypt(negated))); encrypted = encryptor.Encrypt(Encoder.Encode(0)); negated = evaluator.Negate(encrypted); Assert.AreEqual(0, Encoder.DecodeInt32(decryptor.Decrypt(negated))); encrypted = encryptor.Encrypt(Encoder.Encode(1)); negated = evaluator.Negate(encrypted); Assert.AreEqual(-1, Encoder.DecodeInt32(decryptor.Decrypt(negated))); encrypted = encryptor.Encrypt(Encoder.Encode(-1)); negated = evaluator.Negate(encrypted); Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(negated))); encrypted = encryptor.Encrypt(Encoder.Encode(2)); negated = evaluator.Negate(encrypted); Assert.AreEqual(-2, Encoder.DecodeInt32(decryptor.Decrypt(negated))); encrypted = encryptor.Encrypt(Encoder.Encode(-5)); negated = evaluator.Negate(encrypted); Assert.AreEqual(5, Encoder.DecodeInt32(decryptor.Decrypt(negated))); }
public void Encode() { FormatterContext formatterContext = new FormatterContext(FormatterContext.DefaultBufferSize); _encoder.Encode(_data, ref formatterContext); Assert.IsTrue(formatterContext.DataLength == _data.Length); byte[] encodedData = formatterContext.GetData(); for (int i = _data.Length - 1; i >= 0; i--) { Assert.IsTrue(_data[i] == encodedData[i]); } }
public void FVEncryptAddManyDecryptNET() { var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew()); parms.SetDecompositionBitCount(4); parms.SetNoiseStandardDeviation(3.19); parms.SetNoiseMaxDeviation(35.06); var coeffModulus = new BigUInt(48); coeffModulus.Set("FFFFFFFFC001"); parms.SetCoeffModulus(coeffModulus); var plainModulus = new BigUInt(7); plainModulus.Set(1 << 6); parms.SetPlainModulus(plainModulus); var polyModulus = new BigPoly(65, 1); polyModulus[0].Set(1); polyModulus[64].Set(1); parms.SetPolyModulus(polyModulus); parms.Validate(); var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew()); keygen.Generate(); var encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew()); var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew()); var evaluator = new Evaluator(parms, MemoryPoolHandle.AcquireNew()); var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew()); var encrypted1 = encryptor.Encrypt(encoder.Encode(5)); var encrypted2 = encryptor.Encrypt(encoder.Encode(6)); var encrypted3 = encryptor.Encrypt(encoder.Encode(7)); var encrypteds = new List <BigPolyArray>() { encrypted1, encrypted2, encrypted3 }; var product = evaluator.AddMany(encrypteds); Assert.AreEqual(18, encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(-9)); encrypted2 = encryptor.Encrypt(encoder.Encode(-17)); encrypteds = new List <BigPolyArray>() { encrypted1, encrypted2 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(-26, encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(2)); encrypted2 = encryptor.Encrypt(encoder.Encode(-31)); encrypted3 = encryptor.Encrypt(encoder.Encode(7)); encrypteds = new List <BigPolyArray>() { encrypted1, encrypted2, encrypted3 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(-22, encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(1)); encrypted2 = encryptor.Encrypt(encoder.Encode(-1)); encrypted3 = encryptor.Encrypt(encoder.Encode(1)); var encrypted4 = encryptor.Encrypt(encoder.Encode(-1)); encrypteds = new List <BigPolyArray>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(0, encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(encoder.Encode(98765)); encrypted2 = encryptor.Encrypt(encoder.Encode(0)); encrypted3 = encryptor.Encrypt(encoder.Encode(12345)); encrypted4 = encryptor.Encrypt(encoder.Encode(34567)); encrypteds = new List <BigPolyArray>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(145677, encoder.DecodeInt32(decryptor.Decrypt(product))); BalancedFractionalEncoder fracEncoder = new BalancedFractionalEncoder(plainModulus, polyModulus, 10, 15, MemoryPoolHandle.AcquireNew()); encrypted1 = encryptor.Encrypt(fracEncoder.Encode(3.1415)); encrypted2 = encryptor.Encrypt(fracEncoder.Encode(12.345)); encrypted3 = encryptor.Encrypt(fracEncoder.Encode(98.765)); encrypted4 = encryptor.Encrypt(fracEncoder.Encode(1.1111)); encrypteds = new List <BigPolyArray>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.AddMany(encrypteds); Assert.IsTrue(System.Math.Abs(fracEncoder.Decode(decryptor.Decrypt(product)) - 115.3626) < 0.000001); }
public void FVEncryptAddDecryptNET() { var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew()); parms.SetDecompositionBitCount(4); parms.SetNoiseStandardDeviation(3.19); parms.SetNoiseMaxDeviation(35.06); var coeffModulus = new BigUInt(48); coeffModulus.Set("FFFFFFFFC001"); parms.SetCoeffModulus(coeffModulus); var plainModulus = new BigUInt(7); plainModulus.Set(1 << 6); parms.SetPlainModulus(plainModulus); var polyModulus = new BigPoly(65, 1); polyModulus[0].Set(1); polyModulus[64].Set(1); parms.SetPolyModulus(polyModulus); parms.Validate(); var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew()); keygen.Generate(); var encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew()); var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew()); var evaluator = new Evaluator(parms, MemoryPoolHandle.AcquireNew()); var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew()); var encrypted1 = encryptor.Encrypt(encoder.Encode(0x12345678)); var encrypted2 = encryptor.Encrypt(encoder.Encode(0x54321)); var sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(0x12399999UL, encoder.DecodeUInt64(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(encoder.Encode(0)); encrypted2 = encryptor.Encrypt(encoder.Encode(0)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(0UL, encoder.DecodeUInt64(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(encoder.Encode(0)); encrypted2 = encryptor.Encrypt(encoder.Encode(5)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(5UL, encoder.DecodeUInt64(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(encoder.Encode(5)); encrypted2 = encryptor.Encrypt(encoder.Encode(-3)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(2, encoder.DecodeInt32(decryptor.Decrypt(sum))); encrypted1 = encryptor.Encrypt(encoder.Encode(-7)); encrypted2 = encryptor.Encrypt(encoder.Encode(2)); sum = evaluator.Add(encrypted1, encrypted2); Assert.AreEqual(-5, encoder.DecodeInt32(decryptor.Decrypt(sum))); }
public void BinaryEncodeDecodeBigUIntNET() { var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF); var encoder = new BinaryEncoder(modulus); var value = new BigUInt(64); value.Set("0"); var poly = encoder.Encode(value); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(value, encoder.DecodeBigUInt(poly)); value.Set("1"); var poly1 = encoder.Encode(value); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(value, encoder.DecodeBigUInt(poly1)); value.Set("2"); var poly2 = encoder.Encode(value); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(value, encoder.DecodeBigUInt(poly2)); value.Set("3"); var poly3 = encoder.Encode(value); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(value, encoder.DecodeBigUInt(poly3)); value.Set("FFFFFFFFFFFFFFFF"); var poly4 = encoder.Encode(value); Assert.AreEqual(64, poly4.SignificantCoeffCount()); for (int i = 0; i < 64; ++i) { Assert.AreEqual("1", poly4[i].ToString()); } Assert.AreEqual(value, encoder.DecodeBigUInt(poly4)); value.Set("80F02"); var poly5 = encoder.Encode(value); Assert.AreEqual(20, poly5.SignificantCoeffCount()); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly5[i].ToString()); } else { Assert.IsTrue(poly5[i] == 0); } } Assert.AreEqual(value, encoder.DecodeBigUInt(poly5)); var poly6 = new Plaintext(3); poly6[0] = 1; poly6[1] = 500; poly6[2] = 1023; value.Set(1 + 500 * 2 + 1023 * 4); Assert.AreEqual(value, encoder.DecodeBigUInt(poly6)); modulus.Set(1024); var encoder2 = new BinaryEncoder(modulus); var poly7 = new Plaintext(4); poly7[0] = 1023; // -1 (*1) poly7[1] = 512; // -512 (*2) poly7[2] = 511; // 511 (*4) poly7[3] = 1; // 1 (*8) value.Set(-1 + -512 * 2 + 511 * 4 + 1 * 8); Assert.AreEqual(value, encoder2.DecodeBigUInt(poly7)); }
public void EvaluateTestModeNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06, Mode = EncryptionMode.Test }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 6); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var keygen = new KeyGenerator(parms); keygen.Generate(); var Encoder = new BinaryEncoder(parms.PlainModulus); var encryptor = new Encryptor(parms, keygen.PublicKey); var evaluator = new Evaluator(parms, keygen.EvaluationKeys); var decryptor = new Decryptor(parms, keygen.SecretKey); var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678)); var negated = evaluator.Negate(encrypted); Assert.AreEqual(-0x12345678, Encoder.DecodeInt32(negated)); Assert.AreEqual(-0x12345678, Encoder.DecodeInt32(decryptor.Decrypt(negated))); var plain2 = Encoder.Encode(0x54321); var encrypted2 = encryptor.Encrypt(plain2); var sum = evaluator.Add(encrypted, encrypted2); Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(sum)); Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum))); sum = evaluator.AddPlain(encrypted, plain2); Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(sum)); Assert.AreEqual(0x12399999UL, Encoder.DecodeUInt64(decryptor.Decrypt(sum))); var diff = evaluator.Sub(encrypted, encrypted2); Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(diff)); Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(decryptor.Decrypt(diff))); diff = evaluator.SubPlain(encrypted, plain2); Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(diff)); Assert.AreEqual(0x122F1357, Encoder.DecodeInt32(decryptor.Decrypt(diff))); var prod = evaluator.Multiply(encrypted, encrypted2); Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(prod)); Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(decryptor.Decrypt(prod))); prod = evaluator.MultiplyPlain(encrypted, plain2); Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(prod)); Assert.AreEqual(0x5FCBBBB88D78UL, Encoder.DecodeUInt64(decryptor.Decrypt(prod))); }
public void BinaryEncodeDecodeInt32NET() { var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF); var encoder = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly = encoder.Encode(0); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0, encoder.DecodeInt32(poly)); var poly1 = encoder.Encode(1); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1, encoder.DecodeInt32(poly1)); var poly2 = encoder.Encode(2); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(2, encoder.DecodeInt32(poly2)); var poly3 = encoder.Encode(3); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(3, encoder.DecodeInt32(poly3)); var poly4 = encoder.Encode(-1); Assert.AreEqual(1, poly4.SignificantCoeffCount()); Assert.AreEqual("FFFFFFFFFFFFFFE", poly4.ToString()); Assert.AreEqual(-1, encoder.DecodeInt32(poly4)); var poly5 = encoder.Encode(-2); Assert.AreEqual(2, poly5.SignificantCoeffCount()); Assert.AreEqual("FFFFFFFFFFFFFFEx^1", poly5.ToString()); Assert.AreEqual(-2, encoder.DecodeInt32(poly5)); var poly6 = encoder.Encode(-3); Assert.AreEqual(2, poly6.SignificantCoeffCount()); Assert.AreEqual("FFFFFFFFFFFFFFEx^1 + FFFFFFFFFFFFFFE", poly6.ToString()); Assert.AreEqual(-3, encoder.DecodeInt32(poly6)); var poly7 = encoder.Encode(0x7FFFFFFF); Assert.AreEqual(31, poly7.SignificantCoeffCount()); for (int i = 0; i < 31; ++i) { Assert.AreEqual("1", poly7[i].ToString()); } Assert.AreEqual(0x7FFFFFFF, encoder.DecodeInt32(poly7)); var poly8 = encoder.Encode(unchecked ((int)0x80000000)); Assert.AreEqual(32, poly8.SignificantCoeffCount()); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly8[31]); for (int i = 0; i < 31; ++i) { Assert.IsTrue(poly8[i] == 0); } Assert.AreEqual(unchecked ((int)0x80000000), encoder.DecodeInt32(poly8)); var poly9 = encoder.Encode(0x80F02); Assert.AreEqual(20, poly9.SignificantCoeffCount()); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly9[i].ToString()); } else { Assert.IsTrue(poly9[i] == 0); } } Assert.AreEqual(0x80F02, encoder.DecodeInt32(poly9)); var poly10 = encoder.Encode(-1073); Assert.AreEqual(11, poly10.SignificantCoeffCount()); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[10]); Assert.IsTrue(poly10[9] == 0); Assert.IsTrue(poly10[8] == 0); Assert.IsTrue(poly10[7] == 0); Assert.IsTrue(poly10[6] == 0); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[5]); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[4]); Assert.IsTrue(poly10[3] == 0); Assert.IsTrue(poly10[2] == 0); Assert.IsTrue(poly10[1] == 0); Assert.AreEqual(0xFFFFFFFFFFFFFFEUL, poly10[0]); Assert.AreEqual(-1073, encoder.DecodeInt32(poly10)); modulus.Set(0xFFFF); var encoder2 = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly11 = new Plaintext(6); poly11[0] = 1; poly11[1] = 0xFFFE; // -1 poly11[2] = 0xFFFD; // -2 poly11[3] = 0x8000; // -32767 poly11[4] = 0x7FFF; // 32767 poly11[5] = 0x7FFE; // 32766 Assert.AreEqual(1 + -1 * 2 + -2 * 4 + -32767 * 8 + 32767 * 16 + 32766 * 32, encoder2.DecodeInt32(poly11)); }
public void EncryptAddManyDecryptNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 4); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var keygen = new KeyGenerator(parms); keygen.Generate(); var Encoder = new BinaryEncoder(parms.PlainModulus); var encryptor = new Encryptor(parms, keygen.PublicKey); var evaluator = new Evaluator(parms, keygen.EvaluationKeys); var keygenEvals = keygen.EvaluationKeys; var evaluatorEvals = keygen.EvaluationKeys; for (int i = 0; i < keygen.EvaluationKeys.Count; ++i) { Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]); } var decryptor = new Decryptor(parms, keygen.SecretKey); var encrypted1 = encryptor.Encrypt(Encoder.Encode(5)); var encrypted2 = encryptor.Encrypt(Encoder.Encode(6)); var encrypted3 = encryptor.Encrypt(Encoder.Encode(7)); var encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3 }; var product = evaluator.AddMany(encrypteds); Assert.AreEqual(18, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(-9)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-17)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(-26, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(2)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-31)); encrypted3 = encryptor.Encrypt(Encoder.Encode(7)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(-22, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(1)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-1)); encrypted3 = encryptor.Encrypt(Encoder.Encode(1)); var encrypted4 = encryptor.Encrypt(Encoder.Encode(-1)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(0, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(98765)); encrypted2 = encryptor.Encrypt(Encoder.Encode(0)); encrypted3 = encryptor.Encrypt(Encoder.Encode(12345)); encrypted4 = encryptor.Encrypt(Encoder.Encode(34567)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.AddMany(encrypteds); Assert.AreEqual(145677, Encoder.DecodeInt32(decryptor.Decrypt(product))); BalancedFractionalEncoder fracEncoder = new BalancedFractionalEncoder(plainModulus, polyModulus, 10, 15); encrypted1 = encryptor.Encrypt(fracEncoder.Encode(3.1415)); encrypted2 = encryptor.Encrypt(fracEncoder.Encode(12.345)); encrypted3 = encryptor.Encrypt(fracEncoder.Encode(98.765)); encrypted4 = encryptor.Encrypt(fracEncoder.Encode(1.1111)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.AddMany(encrypteds); Assert.IsTrue(System.Math.Abs(fracEncoder.Decode(decryptor.Decrypt(product)) - 115.3626) < 0.000001); }
public void BinaryEncodeDecodeUInt64NET() { var modulus = new SmallModulus(0xFFFFFFFFFFFFFFF); var encoder = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly = encoder.Encode(0UL); Assert.AreEqual(0, poly.SignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0UL, encoder.DecodeUInt64(poly)); var poly1 = encoder.Encode(1UL); Assert.AreEqual(1, poly1.SignificantCoeffCount()); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1UL, encoder.DecodeUInt64(poly1)); var poly2 = encoder.Encode(2UL); Assert.AreEqual(2, poly2.SignificantCoeffCount()); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2)); var poly3 = encoder.Encode(3UL); Assert.AreEqual(2, poly3.SignificantCoeffCount()); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3)); var poly4 = encoder.Encode(0xFFFFFFFFFFFFFFFFUL); Assert.AreEqual(64, poly4.SignificantCoeffCount()); for (int i = 0; i < 64; ++i) { Assert.AreEqual("1", poly4[i].ToString()); } Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(poly4)); var poly5 = encoder.Encode(0x80F02UL); Assert.AreEqual(20, poly5.SignificantCoeffCount()); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly5[i].ToString()); } else { Assert.IsTrue(poly5[i] == 0); } } Assert.AreEqual(0x80F02UL, encoder.DecodeUInt64(poly5)); var poly6 = new Plaintext(3); poly6[0] = 1; poly6[1] = 500; poly6[2] = 1023; Assert.AreEqual((1UL + 500 * 2 + 1023 * 4), encoder.DecodeUInt64(poly6)); modulus.Set(1024); var encoder2 = new BinaryEncoder(modulus, MemoryPoolHandle.New()); var poly7 = new Plaintext(4); poly7[0] = 1023; // -1 (*1) poly7[1] = 512; // -512 (*2) poly7[2] = 511; // 511 (*4) poly7[3] = 1; // 1 (*8) Assert.AreEqual((ulong)(-1 + -512 * 2 + 511 * 4 + 1 * 8), encoder2.DecodeUInt64(poly7)); }
public void EncryptMultiplyManyDecryptNET() { var parms = new EncryptionParameters { DecompositionBitCount = 4, NoiseStandardDeviation = 3.19, NoiseMaxDeviation = 35.06 }; var coeffModulus = parms.CoeffModulus; coeffModulus.Resize(48); coeffModulus.Set("FFFFFFFFC001"); var plainModulus = parms.PlainModulus; plainModulus.Resize(7); plainModulus.Set(1 << 4); var polyModulus = parms.PolyModulus; polyModulus.Resize(64, 1); polyModulus[0].Set(1); polyModulus[63].Set(1); var keygen = new KeyGenerator(parms); keygen.Generate(); var Encoder = new BinaryEncoder(parms.PlainModulus); var encryptor = new Encryptor(parms, keygen.PublicKey); var evaluator = new Evaluator(parms, keygen.EvaluationKeys); var keygenEvals = keygen.EvaluationKeys; var evaluatorEvals = keygen.EvaluationKeys; for (int i = 0; i < keygen.EvaluationKeys.Count; ++i) { Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]); } var decryptor = new Decryptor(parms, keygen.SecretKey); var encrypted1 = encryptor.Encrypt(Encoder.Encode(2)); var encrypted2 = encryptor.Encrypt(Encoder.Encode(-3)); var encrypted3 = encryptor.Encrypt(Encoder.Encode(4)); var encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3 }; var product = evaluator.MultiplyMany(encrypteds); Assert.AreEqual(-24, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(-9)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-17)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2 }; product = evaluator.MultiplyMany(encrypteds); Assert.AreEqual(153, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(2)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-31)); encrypted3 = encryptor.Encrypt(Encoder.Encode(7)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3 }; product = evaluator.MultiplyMany(encrypteds); Assert.AreEqual(-434, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(1)); encrypted2 = encryptor.Encrypt(Encoder.Encode(-1)); encrypted3 = encryptor.Encrypt(Encoder.Encode(1)); var encrypted4 = encryptor.Encrypt(Encoder.Encode(-1)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.MultiplyMany(encrypteds); Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(product))); encrypted1 = encryptor.Encrypt(Encoder.Encode(98765)); encrypted2 = encryptor.Encrypt(Encoder.Encode(0)); encrypted3 = encryptor.Encrypt(Encoder.Encode(12345)); encrypted4 = encryptor.Encrypt(Encoder.Encode(34567)); encrypteds = new List <BigPoly>() { encrypted1, encrypted2, encrypted3, encrypted4 }; product = evaluator.MultiplyMany(encrypteds); Assert.AreEqual(0, Encoder.DecodeInt32(decryptor.Decrypt(product))); }
public void BinaryEncodeDecodeInt32NET() { var modulus = new BigUInt("FFFFFFFFFFFFFFFF"); var encoder = new BinaryEncoder(modulus); var poly = encoder.Encode(0); Assert.AreEqual(0, poly.GetSignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0, encoder.DecodeInt32(poly)); var poly1 = encoder.Encode(1); Assert.AreEqual(1, poly1.GetSignificantCoeffCount()); Assert.AreEqual(1, poly1.CoeffBitCount); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1, encoder.DecodeInt32(poly1)); var poly2 = encoder.Encode(2); Assert.AreEqual(2, poly2.GetSignificantCoeffCount()); Assert.AreEqual(1, poly2.CoeffBitCount); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(2, encoder.DecodeInt32(poly2)); var poly3 = encoder.Encode(3); Assert.AreEqual(2, poly3.GetSignificantCoeffCount()); Assert.AreEqual(1, poly3.CoeffBitCount); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(3, encoder.DecodeInt32(poly3)); var poly4 = encoder.Encode(-1); Assert.AreEqual(1, poly4.GetSignificantCoeffCount()); Assert.AreEqual(64, poly4.CoeffBitCount); Assert.AreEqual("FFFFFFFFFFFFFFFE", poly4.ToString()); Assert.AreEqual(-1, encoder.DecodeInt32(poly4)); var poly5 = encoder.Encode(-2); Assert.AreEqual(2, poly5.GetSignificantCoeffCount()); Assert.AreEqual(64, poly5.CoeffBitCount); Assert.AreEqual("FFFFFFFFFFFFFFFEx^1", poly5.ToString()); Assert.AreEqual(-2, encoder.DecodeInt32(poly5)); var poly6 = encoder.Encode(-3); Assert.AreEqual(2, poly6.GetSignificantCoeffCount()); Assert.AreEqual(64, poly6.CoeffBitCount); Assert.AreEqual("FFFFFFFFFFFFFFFEx^1 + FFFFFFFFFFFFFFFE", poly6.ToString()); Assert.AreEqual(-3, encoder.DecodeInt32(poly6)); var poly7 = encoder.Encode(0x7FFFFFFF); Assert.AreEqual(31, poly7.GetSignificantCoeffCount()); Assert.AreEqual(1, poly7.CoeffBitCount); for (int i = 0; i < 31; ++i) { Assert.AreEqual("1", poly7[i].ToString()); } Assert.AreEqual(0x7FFFFFFF, encoder.DecodeInt32(poly7)); var poly8 = encoder.Encode(unchecked ((int)0x80000000)); Assert.AreEqual(32, poly8.GetSignificantCoeffCount()); Assert.AreEqual(64, poly8.CoeffBitCount); Assert.AreEqual("FFFFFFFFFFFFFFFE", poly8[31].ToString()); for (int i = 0; i < 31; ++i) { Assert.IsTrue(poly8[i].IsZero); } Assert.AreEqual(unchecked ((int)0x80000000), encoder.DecodeInt32(poly8)); var poly9 = encoder.Encode(0x80F02); Assert.AreEqual(20, poly9.GetSignificantCoeffCount()); Assert.AreEqual(1, poly9.CoeffBitCount); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly9[i].ToString()); } else { Assert.IsTrue(poly9[i].IsZero); } } Assert.AreEqual(0x80F02, encoder.DecodeInt32(poly9)); var poly10 = encoder.Encode(-1073); Assert.AreEqual(11, poly10.GetSignificantCoeffCount()); Assert.AreEqual(64, poly10.CoeffBitCount); Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[10].ToString()); Assert.IsTrue(poly10[9].IsZero); Assert.IsTrue(poly10[8].IsZero); Assert.IsTrue(poly10[7].IsZero); Assert.IsTrue(poly10[6].IsZero); Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[5].ToString()); Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[4].ToString()); Assert.IsTrue(poly10[3].IsZero); Assert.IsTrue(poly10[2].IsZero); Assert.IsTrue(poly10[1].IsZero); Assert.AreEqual("FFFFFFFFFFFFFFFE", poly10[0].ToString()); Assert.AreEqual(-1073, encoder.DecodeInt32(poly10)); modulus.Set("FFFF"); var encoder2 = new BinaryEncoder(modulus); var poly11 = new BigPoly(6, 64); poly11[0].Set(1); poly11[1].Set("FFFE"); // -1 poly11[2].Set("FFFD"); // -2 poly11[3].Set("8000"); // -32767 poly11[4].Set("7FFF"); // 32767 poly11[5].Set("7FFE"); // 32766 Assert.AreEqual(1 + -1 * 2 + -2 * 4 + -32767 * 8 + 32767 * 16 + 32766 * 32, encoder2.DecodeInt32(poly11)); }
public void BinaryEncodeDecodeUInt64NET() { var modulus = new BigUInt("FFFFFFFFFFFFFFFF"); var encoder = new BinaryEncoder(modulus); var poly = encoder.Encode(0UL); Assert.AreEqual(0, poly.GetSignificantCoeffCount()); Assert.IsTrue(poly.IsZero); Assert.AreEqual(0UL, encoder.DecodeUInt64(poly)); var poly1 = encoder.Encode(1UL); Assert.AreEqual(1, poly1.GetSignificantCoeffCount()); Assert.AreEqual(1, poly1.CoeffBitCount); Assert.AreEqual("1", poly1.ToString()); Assert.AreEqual(1UL, encoder.DecodeUInt64(poly1)); var poly2 = encoder.Encode(2UL); Assert.AreEqual(2, poly2.GetSignificantCoeffCount()); Assert.AreEqual(1, poly2.CoeffBitCount); Assert.AreEqual("1x^1", poly2.ToString()); Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2)); var poly3 = encoder.Encode(3UL); Assert.AreEqual(2, poly3.GetSignificantCoeffCount()); Assert.AreEqual(1, poly3.CoeffBitCount); Assert.AreEqual("1x^1 + 1", poly3.ToString()); Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3)); var poly4 = encoder.Encode(0xFFFFFFFFFFFFFFFFUL); Assert.AreEqual(64, poly4.GetSignificantCoeffCount()); Assert.AreEqual(1, poly4.CoeffBitCount); for (int i = 0; i < 64; ++i) { Assert.AreEqual("1", poly4[i].ToString()); } Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(poly4)); var poly5 = encoder.Encode(0x80F02UL); Assert.AreEqual(20, poly5.GetSignificantCoeffCount()); Assert.AreEqual(1, poly5.CoeffBitCount); for (int i = 0; i < 20; ++i) { if (i == 19 || (i >= 8 && i <= 11) || i == 1) { Assert.AreEqual("1", poly5[i].ToString()); } else { Assert.IsTrue(poly5[i].IsZero); } } Assert.AreEqual(0x80F02UL, encoder.DecodeUInt64(poly5)); var poly6 = new BigPoly(3, 10); poly6[0].Set(1); poly6[1].Set(500); poly6[2].Set(1023); Assert.AreEqual((1UL + 500 * 2 + 1023 * 4), encoder.DecodeUInt64(poly6)); modulus.Set(1024); var encoder2 = new BinaryEncoder(modulus); var poly7 = new BigPoly(4, 10); poly7[0].Set(1023); // -1 (*1) poly7[1].Set(512); // -512 (*2) poly7[2].Set(511); // 511 (*4) poly7[3].Set(1); // 1 (*8) Assert.AreEqual((ulong)(-1 + -512 * 2 + 511 * 4 + 1 * 8), encoder2.DecodeUInt64(poly7)); }
public void FVEncryptDecryptNET() { var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew()); parms.SetDecompositionBitCount(4); parms.SetNoiseStandardDeviation(3.19); parms.SetNoiseMaxDeviation(35.06); var coeffModulus = new BigUInt(48); coeffModulus.Set("FFFFFFFFC001"); parms.SetCoeffModulus(coeffModulus); var plainModulus = new BigUInt(7); plainModulus.Set(1 << 6); parms.SetPlainModulus(plainModulus); var polyModulus = new BigPoly(65, 1); polyModulus[0].Set(1); polyModulus[64].Set(1); parms.SetPolyModulus(polyModulus); parms.Validate(); var Encoder = new BinaryEncoder(parms.PlainModulus, MemoryPoolHandle.AcquireNew()); var keygen = new KeyGenerator(parms, MemoryPoolHandle.AcquireNew()); keygen.Generate(); var encryptor = new Encryptor(parms, keygen.PublicKey, MemoryPoolHandle.AcquireNew()); Assert.AreEqual(encryptor.PublicKey[0], keygen.PublicKey[0]); Assert.AreEqual(encryptor.PublicKey[1], keygen.PublicKey[1]); var decryptor = new Decryptor(parms, keygen.SecretKey, MemoryPoolHandle.AcquireNew()); Assert.AreEqual(decryptor.SecretKey, keygen.SecretKey); var encrypted = encryptor.Encrypt(Encoder.Encode(0x12345678)); Assert.AreEqual(0x12345678U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0)); Assert.AreEqual(0U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(1)); Assert.AreEqual(1U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(2)); Assert.AreEqual(2U, Encoder.DecodeUInt32(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFDUL)); Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFEUL)); Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted))); encrypted = encryptor.Encrypt(Encoder.Encode(0x7FFFFFFFFFFFFFFFUL)); Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, Encoder.DecodeUInt64(decryptor.Decrypt(encrypted))); }