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 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 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 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 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 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 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 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 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 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 FVEncryptMultiplyManyDecryptNET()
{
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 encrypted1 = encryptor.Encrypt(encoder.Encode(2));
var encrypted2 = encryptor.Encrypt(encoder.Encode(-3));
var encrypted3 = encryptor.Encrypt(encoder.Encode(4));
var encrypteds = new List <BigPolyArray>()
{
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 <BigPolyArray>()
{
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 <BigPolyArray>()
{
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 <BigPolyArray>()
{
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 <BigPolyArray>()
{
encrypted1, encrypted2, encrypted3, encrypted4
};
product = evaluator.MultiplyMany(encrypteds);
Assert.AreEqual(0, encoder.DecodeInt32(decryptor.Decrypt(product)));
}
