public void EmptyBigPolyNET()
{
var poly = new BigPoly();
Assert.AreEqual(0, poly.CoeffCount);
Assert.AreEqual(0, poly.CoeffBitCount);
Assert.AreEqual(0, poly.UInt64Count);
Assert.IsTrue(null == poly.Pointer);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.IsFalse(poly.IsAlias);
Assert.AreEqual("0", poly.ToString());
poly.SetZero();
var poly2 = new BigPoly();
Assert.IsTrue(poly.Equals(poly2));
poly.Resize(1, 1);
Assert.IsTrue(null != poly.Pointer);
Assert.IsFalse(poly.IsAlias);
poly.Resize(0, 0);
Assert.IsTrue(null == poly.Pointer);
Assert.IsFalse(poly.IsAlias);
}
public void BinaryFractionalEncodeDecodeNET()
{
var polyModulus = new BigPoly("1x^1024 + 1");
var modulus = new SmallModulus(0x10000);
var encoder = new BinaryFractionalEncoder(modulus, polyModulus, 500, 50, MemoryPoolHandle.New());
var poly = encoder.Encode(0.0);
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0.0, encoder.Decode(poly));
var poly1 = encoder.Encode(-1.0);
Assert.AreEqual(-1.0, encoder.Decode(poly1));
var poly2 = encoder.Encode(0.1);
Assert.IsTrue(Math.Abs(encoder.Decode(poly2) - 0.1) / 0.1 < 0.000001);
var poly3 = encoder.Encode(3.123);
Assert.IsTrue(Math.Abs(encoder.Decode(poly3) - 3.123) / 3.123 < 0.000001);
var poly4 = encoder.Encode(-123.456);
Assert.IsTrue(Math.Abs(encoder.Decode(poly4) + 123.456) / (-123.456) < 0.000001);
var poly5 = encoder.Encode(12345.98765);
Assert.IsTrue(Math.Abs(encoder.Decode(poly5) - 12345.98765) / 12345.98765 < 0.000001);
}
public void TransformPlainToFromNTTNET()
{
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 evaluator = new Evaluator(parms, MemoryPoolHandle.AcquireNew());
var plain = new BigPoly(65, 1);
plain.Set("0");
evaluator.TransformToNTT(plain);
Assert.IsTrue(plain.ToString() == "0");
evaluator.TransformFromNTT(plain);
Assert.IsTrue(plain.ToString() == "0");
plain.Set("1");
evaluator.TransformToNTT(plain);
for (int i = 0; i < 64; i++)
{
Assert.IsTrue(plain[i].ToString() == "1");
}
Assert.IsTrue(plain[64].ToString() == "0");
evaluator.TransformFromNTT(plain);
Assert.IsTrue(plain.ToString() == "1");
plain.Set("2");
evaluator.TransformToNTT(plain);
for (int i = 0; i < 64; i++)
{
Assert.IsTrue(plain[i].ToString() == "2");
}
Assert.IsTrue(plain[64].ToString() == "0");
evaluator.TransformFromNTT(plain);
Assert.IsTrue(plain.ToString() == "2");
plain.Set("Fx^10 + Ex^9 + Dx^8 + Cx^7 + Bx^6 + Ax^5 + 1x^4 + 2x^3 + 3x^2 + 4x^1 + 5");
evaluator.TransformToNTT(plain);
evaluator.TransformFromNTT(plain);
Assert.IsTrue(plain.ToString() == "Fx^10 + Ex^9 + Dx^8 + Cx^7 + Bx^6 + Ax^5 + 1x^4 + 2x^3 + 3x^2 + 4x^1 + 5");
}
public void PolyInftyNormCoeffmodNET()
{
var poly = new BigPoly("1x^10 + 2x^9 + 5x^8 + Ax^7 + Bx^6 + 4x^5 + 1x^2 + 1");
BigUInt value = new BigUInt();
BigUInt modulus = new BigUInt();
modulus.Set(5);
var inftynorm = Utilities.PolyInftyNormCoeffmod(poly, modulus);
value.Set("2");
Assert.AreEqual(value, inftynorm);
poly.Set("AAx^10 + ABx^9 + CAx^8 + CFx^7 + FEx^6 + F7x^5 + 1x^2 + 2");
modulus.Set("10");
inftynorm = Utilities.PolyInftyNormCoeffmod(poly, modulus);
value.Set("7");
Assert.AreEqual(value, inftynorm);
poly.Set("Ax^10 + ABx^9 + ABCx^8 + ABCDx^7 + ABCDEx^6 + ABCDEFx^5 + 1x^2 + 2");
modulus.Set("4");
inftynorm = Utilities.PolyInftyNormCoeffmod(poly, modulus);
value.Set("2");
Assert.AreEqual(value, inftynorm);
poly.Set("1x^5 + 2x^4 + 3x^3 + 4x^2 + 5x^1 + 6");
modulus.Set("4");
inftynorm = Utilities.PolyInftyNormCoeffmod(poly, modulus);
value.Set("2");
Assert.AreEqual(value, inftynorm);
}
public void FVKeyGenerationNoEVKNET()
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(0);
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(0);
Assert.IsFalse(keygen.PublicKey[0].IsZero);
Assert.IsFalse(keygen.PublicKey[1].IsZero);
Assert.IsFalse(keygen.SecretKey.IsZero);
}
public void TransformEncryptedToFromNTTNET()
{
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 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 plain = new BigPoly(65, 1);
var cipher = new BigPolyArray(2, 65, 1);
plain.Set("0");
encryptor.Encrypt(plain, cipher);
evaluator.TransformToNTT(cipher);
evaluator.TransformFromNTT(cipher);
decryptor.Decrypt(cipher, plain);
Assert.IsTrue(plain.ToString() == "0");
plain.Set("1");
encryptor.Encrypt(plain, cipher);
evaluator.TransformToNTT(cipher);
evaluator.TransformFromNTT(cipher);
decryptor.Decrypt(cipher, plain);
Assert.IsTrue(plain.ToString() == "1");
plain.Set("Fx^10 + Ex^9 + Dx^8 + Cx^7 + Bx^6 + Ax^5 + 1x^4 + 2x^3 + 3x^2 + 4x^1 + 5");
encryptor.Encrypt(plain, cipher);
evaluator.TransformToNTT(cipher);
evaluator.TransformFromNTT(cipher);
decryptor.Decrypt(cipher, plain);
Assert.IsTrue(plain.ToString() == "Fx^10 + Ex^9 + Dx^8 + Cx^7 + Bx^6 + Ax^5 + 1x^4 + 2x^3 + 3x^2 + 4x^1 + 5");
}
public void FVEncryptSquareDecryptNET()
{
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 BalancedEncoder(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(1));
var product = evaluator.Square(encrypted1);
Assert.AreEqual(1UL, encoder.DecodeUInt64(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(0));
product = evaluator.Square(encrypted1);
Assert.AreEqual(0UL, encoder.DecodeUInt64(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(-5));
product = evaluator.Square(encrypted1);
Assert.AreEqual(25UL, encoder.DecodeUInt64(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(-1));
product = evaluator.Square(encrypted1);
Assert.AreEqual(1UL, encoder.DecodeUInt64(decryptor.Decrypt(product)));
encrypted1 = encryptor.Encrypt(encoder.Encode(123));
product = evaluator.Square(encrypted1);
Assert.AreEqual(15129UL, encoder.DecodeUInt64(decryptor.Decrypt(product)));
}
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 void BigPolyFromStringNET()
{
var poly = new BigPoly("9x^2 + 2");
Assert.AreEqual("9x^2 + 2", poly.ToString());
Assert.AreEqual(3, poly.CoeffCount);
Assert.AreEqual(4, poly.CoeffBitCount);
poly.Resize(0, 0);
poly.Set("0");
Assert.AreEqual("0", poly.ToString());
Assert.AreEqual(0, poly.CoeffCount);
Assert.AreEqual(0, poly.CoeffBitCount);
poly.Set("1");
Assert.AreEqual("1", poly.ToString());
Assert.AreEqual(1, poly.CoeffCount);
Assert.AreEqual(1, poly.CoeffBitCount);
poly.Set("123");
Assert.AreEqual("123", poly.ToString());
Assert.AreEqual(1, poly.CoeffCount);
Assert.AreEqual(9, poly.CoeffBitCount);
poly.Set("23x^3");
Assert.AreEqual("23x^3", poly.ToString());
Assert.AreEqual(4, poly.CoeffCount);
Assert.AreEqual(9, poly.CoeffBitCount);
poly.Resize(0, 0);
poly.Set("23x^3");
Assert.AreEqual("23x^3", poly.ToString());
Assert.AreEqual(4, poly.CoeffCount);
Assert.AreEqual(6, poly.CoeffBitCount);
poly.Set("3x^2 + 2x^1");
Assert.AreEqual("3x^2 + 2x^1", poly.ToString());
Assert.AreEqual(4, poly.CoeffCount);
Assert.AreEqual(6, poly.CoeffBitCount);
poly.Set("1x^2 + 2x^1 + 3");
Assert.AreEqual("1x^2 + 2x^1 + 3", poly.ToString());
Assert.AreEqual(4, poly.CoeffCount);
Assert.AreEqual(6, poly.CoeffBitCount);
poly.Set("4x^1");
Assert.AreEqual("4x^1", poly.ToString());
Assert.AreEqual(4, poly.CoeffCount);
Assert.AreEqual(6, poly.CoeffBitCount);
}
public void BigPolyEvalPolyPolyModCoeffModNET()
{
var modulus = new BigUInt("5");
var polymod = new BigPoly("1x^3 + 3x^1 + 1");
var poly_to_eval = new BigPoly("0");
var poly = new BigPoly("0");
var result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("0", result.ToString());
poly_to_eval.Set("1");
poly.Set("0");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("1", result.ToString());
poly_to_eval.Set("4");
poly.Set("0");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("4", result.ToString());
poly_to_eval.Set("4");
poly.Set("1");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("4", result.ToString());
poly_to_eval.Set("0");
poly.Set("1");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("0", result.ToString());
poly_to_eval.Set("1x^1 + 2");
poly.Set("1");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("3", result.ToString());
poly_to_eval.Set("1x^1 + 4");
poly.Set("2x^1 + 1");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("2x^1", result.ToString());
poly_to_eval.Set("1x^1 + 1");
poly.Set("1x^2 + 2x^1 + 3");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("1x^2 + 2x^1 + 4", result.ToString());
poly_to_eval.Set("1x^2 + 1");
poly.Set("1x^2 + 2x^1 + 3");
result = Utilities.PolyEvalPolyPolymodCoeffmod(poly_to_eval, poly, polymod, modulus);
Assert.AreEqual("2x^2 + 4x^1 + 1", result.ToString());
}
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 BalancedFractionalEncodeDecodeNET()
{
var polyModulus = new BigPoly("1x^1024 + 1");
var modulus = new BigUInt("10000");
var poly = new BigPoly();
var poly1 = new BigPoly();
var poly2 = new BigPoly();
var poly3 = new BigPoly();
var poly4 = new BigPoly();
var poly5 = new BigPoly();
for (ulong b = 3; b < 20; b += 2)
{
var encoder = new BalancedFractionalEncoder(modulus, polyModulus, 500, 50, b);
poly = encoder.Encode(0.0);
Assert.AreEqual(polyModulus.CoeffCount, poly.CoeffCount);
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0.0, encoder.Decode(poly));
poly1 = encoder.Encode(-1.0);
Assert.AreEqual(polyModulus.CoeffCount, poly1.CoeffCount);
Assert.AreEqual(modulus.BitCount, poly1.CoeffBitCount);
Assert.AreEqual(-1.0, encoder.Decode(poly1));
poly2 = encoder.Encode(0.1);
Assert.AreEqual(polyModulus.CoeffCount, poly2.CoeffCount);
Assert.AreEqual(modulus.BitCount, poly2.CoeffBitCount);
Assert.IsTrue(Math.Abs(encoder.Decode(poly2) - 0.1) / 0.1 < 0.000001);
poly3 = encoder.Encode(3.123);
Assert.AreEqual(polyModulus.CoeffCount, poly3.CoeffCount);
Assert.AreEqual(modulus.BitCount, poly3.CoeffBitCount);
Assert.IsTrue(Math.Abs(encoder.Decode(poly3) - 3.123) / 3.123 < 0.000001);
poly4 = encoder.Encode(-123.456);
Assert.AreEqual(polyModulus.CoeffCount, poly4.CoeffCount);
Assert.AreEqual(modulus.BitCount, poly4.CoeffBitCount);
Assert.IsTrue(Math.Abs(encoder.Decode(poly4) + 123.456) / (-123.456) < 0.000001);
poly5 = encoder.Encode(12345.98765);
Assert.AreEqual(polyModulus.CoeffCount, poly5.CoeffCount);
Assert.AreEqual(modulus.BitCount, poly5.CoeffBitCount);
Assert.IsTrue(Math.Abs(encoder.Decode(poly5) - 12345.98765) / 12345.98765 < 0.000001);
}
}
public void BigPolyEvalUIntModNET()
{
var modulus = new BigUInt("5");
var poly = new BigPoly("1x^2 + 1x^1 + 1");
var value = new BigUInt("0");
var result = Utilities.PolyEvalUIntMod(poly, value, modulus);
Assert.AreEqual("1", result.ToString());
value.Set("1");
result = Utilities.PolyEvalUIntMod(poly, value, modulus);
Assert.AreEqual("3", result.ToString());
value.Set("4");
result = Utilities.PolyEvalUIntMod(poly, value, modulus);
Assert.AreEqual("1", result.ToString());
}
public void SaveLoadEncryptionParamsNET()
{
var stream = new MemoryStream();
// Create encryption parameters.
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);
var parms2 = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
stream.Seek(0, SeekOrigin.Begin);
parms.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
parms2.Load(stream);
Assert.AreEqual(parms.DecompositionBitCount, parms2.DecompositionBitCount);
Assert.AreEqual(parms.NoiseStandardDeviation, parms2.NoiseStandardDeviation);
Assert.AreEqual(parms.NoiseMaxDeviation, parms2.NoiseMaxDeviation);
Assert.AreEqual(parms.CoeffModulus, parms2.CoeffModulus);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.AreEqual(parms.AuxCoeffModulus, parms2.AuxCoeffModulus);
Assert.AreEqual(parms.PlainModulus, parms2.PlainModulus);
Assert.AreEqual(parms.PolyModulus, parms2.PolyModulus);
}
public void DuplicateFromNET()
{
var original = new BigPoly(123, 456);
original[0].Set(1);
original[1].Set(2);
original[2].Set(3);
original[3].Set(4);
original[4].Set(5);
original[122].Set(123);
BigPoly target = new BigPoly();
target.DuplicateFrom(original);
Assert.AreEqual(target.CoeffCount, original.CoeffCount);
Assert.AreEqual(target.CoeffBitCount, original.CoeffBitCount);
Assert.IsTrue(target.Equals(original));
}
public void ExponentiatePolyPolyPolyModCoeffModNET()
{
var poly = new BigPoly("1x^2 + 2x^1 + 3");
var modulus = new BigUInt("5");
var exponent = new BigUInt("1");
var polymod = new BigPoly("1x^3 + 3x^1 + 1");
var result = Utilities.ExponentiatePolyPolymodCoeffmod(poly, exponent, polymod, modulus);
Assert.AreEqual("1x^2 + 2x^1 + 3", result.ToString());
exponent.Set("2");
result = Utilities.ExponentiatePolyPolymodCoeffmod(poly, exponent, polymod, modulus);
Assert.AreEqual("2x^2 + 4x^1", result.ToString());
poly.Set("1");
exponent.Set("2");
result = Utilities.ExponentiatePolyPolymodCoeffmod(poly, exponent, polymod, modulus);
Assert.AreEqual("1", result.ToString());
exponent.Set("F00F000F00");
result = Utilities.ExponentiatePolyPolymodCoeffmod(poly, exponent, polymod, modulus);
Assert.AreEqual("1", result.ToString());
}
public void SaveLoadPolyNET()
{
var stream = new MemoryStream();
var poly = new BigPoly();
var poly2 = new BigPoly(1, 32);
poly2[0].Set(1);
stream.Seek(0, SeekOrigin.Begin);
poly.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
poly2.Load(stream);
Assert.AreEqual(poly, poly2);
poly.Resize(3, 96);
poly[0].Set(2);
poly[1].Set(3);
poly[2].Set(4);
stream.Seek(0, SeekOrigin.Begin);
poly.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
poly2.Load(stream);
Assert.AreEqual(poly, poly2);
poly[0].Set("FFFFFFFFFFFFFFFFFF");
stream.Seek(0, SeekOrigin.Begin);
poly.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
poly2.Load(stream);
Assert.AreEqual(poly, poly2);
poly.Resize(2, 32);
poly[0].Set(1);
stream.Seek(0, SeekOrigin.Begin);
poly.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
poly2.Load(stream);
Assert.AreEqual(poly, poly2);
}
public void BalancedFractionalEncodeDecodeNET()
{
var polyModulus = new BigPoly("1x^1024 + 1");
var modulus = new SmallModulus(0x10000);
var poly = new Plaintext();
var poly1 = new Plaintext();
var poly2 = new Plaintext();
var poly3 = new Plaintext();
var poly4 = new Plaintext();
var poly5 = new Plaintext();
for (ulong b = 3; b < 20; b += 2)
{
var encoder = new BalancedFractionalEncoder(modulus, polyModulus, 500, 50, b, MemoryPoolHandle.New());
poly = encoder.Encode(0.0);
Assert.AreEqual(1, poly.CoeffCount);
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0.0, encoder.Decode(poly));
poly1 = encoder.Encode(-1.0);
Assert.AreEqual(-1.0, encoder.Decode(poly1));
poly2 = encoder.Encode(0.1);
Assert.IsTrue(Math.Abs(encoder.Decode(poly2) - 0.1) / 0.1 < 0.000001);
poly3 = encoder.Encode(3.123);
Assert.IsTrue(Math.Abs(encoder.Decode(poly3) - 3.123) / 3.123 < 0.000001);
poly4 = encoder.Encode(-123.456);
Assert.IsTrue(Math.Abs(encoder.Decode(poly4) + 123.456) / (-123.456) < 0.000001);
poly5 = encoder.Encode(12345.98765);
Assert.IsTrue(Math.Abs(encoder.Decode(poly5) - 12345.98765) / 12345.98765 < 0.000001);
}
}
public void PolyInftyNormNET()
{
var poly = new BigPoly("1x^10 + 2x^9 + 5x^8 + Ax^7 + Bx^6 + 4x^5 + 1x^2 + 1");
BigUInt value = new BigUInt();
var inftynorm = Utilities.PolyInftyNorm(poly);
value.Set("B");
Assert.AreEqual(value, inftynorm);
poly.Set("AAx^10 + ABx^9 + CAx^8 + CFx^7 + FEx^6 + F7x^5 + 1x^2 + 2");
inftynorm = Utilities.PolyInftyNorm(poly);
value.Set("FE");
Assert.AreEqual(value, inftynorm);
poly.Set("Ax^10 + ABx^9 + ABCx^8 + ABCDx^7 + ABCDEx^6 + ABCDEFx^5 + 1x^2 + 2");
inftynorm = Utilities.PolyInftyNorm(poly);
value.Set("ABCDEF");
Assert.AreEqual(value, inftynorm);
poly.Set("1x^5 + 2x^4 + 3x^3 + 4x^2 + 5x^1 + 6");
inftynorm = Utilities.PolyInftyNorm(poly);
value.Set("6");
Assert.AreEqual(value, inftynorm);
}
public EncCal(string polyMod, int coeffDefault, ulong plainMod, int dbc, int noOfEvaluationKeys)
{
// Create encryption parameters.
parms = new EncryptionParameters();
parms.PolyModulus.Set(polyMod);
parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[coeffDefault]);
parms.PlainModulus.Set(plainMod);
// Generate keys.
generator = new KeyGenerator(parms);
generator.Generate(noOfEvaluationKeys); //Integer
// Generator contains the keys
publicKey = generator.PublicKey;
secretKey = generator.SecretKey;
evaluationKeys = generator.EvaluationKeys;
// Create encoder (for encoding and decoding)
encoder = new IntegerEncoder(parms.PlainModulus); //Integer
//Create Encryptor
encryptor = new Encryptor(parms, publicKey);
//Create Decryptor
decryptor = new Decryptor(parms, secretKey);
//Create Evaluator for arithmatic operations
evaluator = new Evaluator(parms);
CrtBuilder = new PolyCRTBuilder(parms);
}
public void EncryptionParamsWriteReadNET()
{
// Create encryption parameters.
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("7FFFFC801");
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);
Assert.AreEqual(4, parms.DecompositionBitCount);
Assert.AreEqual(3.19, parms.NoiseStandardDeviation);
Assert.AreEqual(35.06, parms.NoiseMaxDeviation);
Assert.AreEqual("7FFFFC801", parms.CoeffModulus.ToString());
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.AreEqual("FFFFFFFFC001", parms.AuxCoeffModulus.ToString());
Assert.AreEqual("40", parms.PlainModulus.ToString());
Assert.AreEqual("1x^64 + 1", parms.PolyModulus.ToString());
}
public void BigPoly3Coeff100BitsNET()
{
var poly = new BigPoly(3, 100);
Assert.AreEqual(3, poly.CoeffCount);
Assert.AreEqual(100, poly.CoeffBitCount);
Assert.IsTrue(null != poly.Pointer);
Assert.AreEqual(6, poly.UInt64Count);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.AreEqual("0", poly.ToString());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(0UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(0UL, poly.Pointer[4]);
Assert.AreEqual(0UL, poly.Pointer[5]);
poly[0].Set("1234");
Assert.AreEqual("1234", poly[0].ToString());
Assert.AreEqual(1, poly.GetSignificantCoeffCount());
Assert.AreEqual("1234", poly.ToString());
Assert.IsFalse(poly.IsZero);
Assert.AreEqual(0x1234UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(0UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(0UL, poly.Pointer[4]);
Assert.AreEqual(0UL, poly.Pointer[5]);
poly[2].Set("3211234567812345678");
Assert.AreEqual("3211234567812345678", poly[2].ToString());
Assert.AreEqual(3, poly.GetSignificantCoeffCount());
Assert.AreEqual("3211234567812345678x^2 + 1234", poly.ToString());
Assert.IsFalse(poly.IsZero);
Assert.AreEqual(0x1234UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(0UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(0x1234567812345678UL, poly.Pointer[4]);
Assert.AreEqual(0x321UL, poly.Pointer[5]);
poly.SetZero();
Assert.IsTrue(poly.IsZero);
Assert.AreEqual("0", poly.ToString());
Assert.AreEqual(0UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(0UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(0UL, poly.Pointer[4]);
Assert.AreEqual(0UL, poly.Pointer[5]);
poly[0].Set("123");
poly[1].Set("456");
poly[2].Set("3211234567812345678");
Assert.AreEqual("3211234567812345678x^2 + 456x^1 + 123", poly.ToString());
Assert.AreEqual(3, poly.GetSignificantCoeffCount());
Assert.AreEqual(0x123UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(0x456UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(0x1234567812345678UL, poly.Pointer[4]);
Assert.AreEqual(0x321UL, poly.Pointer[5]);
var poly2 = new BigPoly(3, 64);
poly2[0].Set(1);
poly2[1].Set(2);
poly2[2].Set(3);
Assert.IsFalse(poly.Equals(poly2));
Assert.IsFalse(poly2.Equals(poly));
Assert.AreNotEqual(poly.GetHashCode(), poly2.GetHashCode());
poly.Set(poly2);
Assert.IsTrue(poly.Equals(poly2));
Assert.IsTrue(poly2.Equals(poly));
Assert.AreEqual(poly.GetHashCode(), poly2.GetHashCode());
Assert.AreEqual("3x^2 + 2x^1 + 1", poly.ToString());
Assert.AreEqual(1UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(2UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(3UL, poly.Pointer[4]);
Assert.AreEqual(0UL, poly.Pointer[5]);
poly[0].Set("123");
poly[1].Set("456");
poly[2].Set("3211234567812345678");
poly.Resize(3, 32);
Assert.AreEqual(3, poly.CoeffCount);
Assert.AreEqual(32, poly.CoeffBitCount);
Assert.AreEqual(3, poly.UInt64Count);
Assert.AreEqual("12345678x^2 + 456x^1 + 123", poly.ToString());
Assert.AreEqual(0x123UL, poly.Pointer[0]);
Assert.AreEqual(0x456UL, poly.Pointer[1]);
Assert.AreEqual(0x12345678UL, poly.Pointer[2]);
poly.Resize(4, 100);
Assert.AreEqual(4, poly.CoeffCount);
Assert.AreEqual(100, poly.CoeffBitCount);
Assert.AreEqual("12345678x^2 + 456x^1 + 123", poly.ToString());
Assert.AreEqual(0x123UL, poly.Pointer[0]);
Assert.AreEqual(0UL, poly.Pointer[1]);
Assert.AreEqual(0x456UL, poly.Pointer[2]);
Assert.AreEqual(0UL, poly.Pointer[3]);
Assert.AreEqual(0x12345678UL, poly.Pointer[4]);
Assert.AreEqual(0UL, poly.Pointer[5]);
Assert.AreEqual(0UL, poly.Pointer[6]);
Assert.AreEqual(0UL, poly.Pointer[7]);
poly.Resize(0, 0);
Assert.AreEqual(0, poly.CoeffCount);
Assert.AreEqual(0, poly.CoeffBitCount);
Assert.AreEqual(0, poly.UInt64Count);
Assert.IsTrue(null == poly.Pointer);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.IsFalse(poly.IsAlias);
Assert.AreEqual("0", poly.ToString());
}
public BigPolyArray GetEnc(BigPoly encoded)
{
var encrypted = encryptor.Encrypt(encoded);
return(encrypted);
}
internal BigPolyArray MultiplyPlain(BigPolyArray encrypted, BigPoly encoded)
{
return(evaluator.MultiplyPlain(encrypted, encoded));
}
public void BalancedEncodeDecodeInt32NET()
{
var modulus = new BigUInt("10000");
var encoder = new BalancedEncoder(modulus, 3);
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(modulus.BitCount, 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(modulus.BitCount, poly2.CoeffBitCount);
Assert.AreEqual("1x^1 + FFFF", poly2.ToString());
Assert.AreEqual(2, encoder.DecodeInt32(poly2));
var poly3 = encoder.Encode(3);
Assert.AreEqual(2, poly3.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly3.CoeffBitCount);
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3, encoder.DecodeInt32(poly3));
var poly4 = encoder.Encode(-1);
Assert.AreEqual(1, poly4.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly4.CoeffBitCount);
Assert.AreEqual("FFFF", poly4.ToString());
Assert.AreEqual(-1, encoder.DecodeInt32(poly4));
var poly5 = encoder.Encode(-2);
Assert.AreEqual(2, poly5.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly5.CoeffBitCount);
Assert.AreEqual("FFFFx^1 + 1", poly5.ToString());
Assert.AreEqual(-2, encoder.DecodeInt32(poly5));
var poly6 = encoder.Encode(-3);
Assert.AreEqual(2, poly6.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly6.CoeffBitCount);
Assert.AreEqual("FFFFx^1", poly6.ToString());
Assert.AreEqual(-3, encoder.DecodeInt32(poly6));
var poly7 = encoder.Encode(-0x2671);
Assert.AreEqual(9, poly7.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly7.CoeffBitCount);
for (int i = 0; i < 9; ++i)
{
Assert.AreEqual("FFFF", poly7[i].ToString());
}
Assert.AreEqual(-0x2671, encoder.DecodeInt32(poly7));
var poly8 = encoder.Encode(-4374);
Assert.AreEqual(9, poly8.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly8.CoeffBitCount);
Assert.AreEqual("FFFF", poly8[8].ToString());
Assert.AreEqual("1", poly8[7].ToString());
for (int i = 0; i < 7; ++i)
{
Assert.IsTrue(poly8[i].IsZero);
}
Assert.AreEqual(-4374, encoder.DecodeInt32(poly8));
var poly9 = encoder.Encode(-0xD4EB);
Assert.AreEqual(11, poly9.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly9.CoeffBitCount);
for (int i = 0; i < 11; ++i)
{
if (i % 3 == 1)
{
Assert.AreEqual("FFFF", poly9[i].ToString());
}
else if (i % 3 == 0)
{
Assert.IsTrue(poly9[i].IsZero);
}
else
{
Assert.AreEqual("1", poly9[i].ToString());
}
}
Assert.AreEqual(-0xD4EB, encoder.DecodeInt32(poly9));
var poly10 = encoder.Encode(-30724);
Assert.AreEqual(11, poly10.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly10.CoeffBitCount);
Assert.AreEqual("FFFF", poly10[10].ToString());
Assert.AreEqual("1", poly10[9].ToString());
Assert.AreEqual("1", poly10[8].ToString());
Assert.AreEqual("1", poly10[7].ToString());
Assert.IsTrue(poly10[6].IsZero);
Assert.IsTrue(poly10[5].IsZero);
Assert.AreEqual("FFFF", poly10[4].ToString());
Assert.AreEqual("FFFF", poly10[3].ToString());
Assert.IsTrue(poly10[2].IsZero);
Assert.AreEqual("1", poly10[1].ToString());
Assert.AreEqual("FFFF", poly10[0].ToString());
Assert.AreEqual(-30724, encoder.DecodeInt32(poly10));
modulus.Set("FFFF");
var encoder2 = new BalancedEncoder(modulus, 7);
var poly12 = new BigPoly(6, 16);
poly12[0].Set(1);
poly12[1].Set("FFFE"); // -1
poly12[2].Set("FFFD"); // -2
poly12[3].Set("8000"); // -32767
poly12[4].Set("7FFF"); // 32767
poly12[5].Set("7FFE"); // 32766
Assert.AreEqual(1 + -1 * 7 + -2 * 49 + -32767 * 343 + 32767 * 2401 + 32766 * 16807, encoder2.DecodeInt32(poly12));
}
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 BalancedEncodeDecodeUInt32NET()
{
var modulus = new BigUInt("10000");
var encoder = new BalancedEncoder(modulus, 3);
var poly = encoder.Encode(0U);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0U, encoder.DecodeUInt32(poly));
var poly1 = encoder.Encode(1U);
Assert.AreEqual(1, poly1.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly1.CoeffBitCount);
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1U, encoder.DecodeUInt32(poly1));
var poly2 = encoder.Encode(2U);
Assert.AreEqual(2, poly2.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly2.CoeffBitCount);
Assert.AreEqual("1x^1 + FFFF", poly2.ToString());
Assert.AreEqual(2U, encoder.DecodeUInt32(poly2));
var poly3 = encoder.Encode(3U);
Assert.AreEqual(2, poly3.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly3.CoeffBitCount);
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3U, encoder.DecodeUInt32(poly3));
var poly4 = encoder.Encode(0x2671U);
Assert.AreEqual(9, poly4.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly4.CoeffBitCount);
for (int i = 0; i < 9; ++i)
{
Assert.IsTrue("1" == poly4[i].ToString());
}
Assert.AreEqual(0x2671U, encoder.DecodeUInt32(poly4));
var poly5 = encoder.Encode(0xD4EBU);
Assert.AreEqual(11, poly5.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly5.CoeffBitCount);
for (int i = 0; i < 11; ++i)
{
if (i % 3 == 1)
{
Assert.AreEqual("1", poly5[i].ToString());
}
else if (i % 3 == 0)
{
Assert.IsTrue(poly5[i].IsZero);
}
else
{
Assert.AreEqual("FFFF", poly5[i].ToString());
}
}
Assert.AreEqual(0xD4EBU, encoder.DecodeUInt32(poly5));
var poly6 = new BigPoly(3, 10);
poly6[0].Set(1);
poly6[1].Set(500);
poly6[2].Set(1023);
Assert.AreEqual(1U + 500 * 3 + 1023 * 9, encoder.DecodeUInt32(poly6));
var encoder2 = new BalancedEncoder(modulus, 7);
var poly7 = new BigPoly(4, 16);
poly7[0].Set(123); // 123 (*1)
poly7[1].Set("FFFF"); // -1 (*7)
poly7[2].Set(511); // 511 (*49)
poly7[3].Set(1); // 1 (*343)
Assert.AreEqual((UInt32)(123 + -1 * 7 + 511 * 49 + 1 * 343), encoder2.DecodeUInt32(poly7));
}
public void GetQualifiersNET()
{
{
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 qualifiers = parms.Qualifiers;
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsTrue(qualifiers.EnableRelinearization);
Assert.IsTrue(qualifiers.EnableNussbaumer);
Assert.IsTrue(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsTrue(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
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(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var qualifiers = parms.Qualifiers;
Assert.IsFalse(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsFalse(qualifiers.EnableNussbaumer);
Assert.IsFalse(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsFalse(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("0");
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 qualifiers = parms.Qualifiers;
Assert.IsFalse(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsFalse(qualifiers.EnableNussbaumer);
Assert.IsFalse(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsFalse(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(0);
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 qualifiers = parms.Qualifiers;
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsTrue(qualifiers.EnableNussbaumer);
Assert.IsTrue(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsTrue(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(4);
parms.SetNoiseStandardDeviation(-3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("7FFFFC801");
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 qualifiers = parms.Qualifiers;
Assert.IsFalse(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsFalse(qualifiers.EnableNussbaumer);
Assert.IsFalse(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsFalse(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(0);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("7FFFFC801");
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 qualifiers = parms.Qualifiers;
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsTrue(qualifiers.EnableNussbaumer);
Assert.IsTrue(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsFalse(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(0);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("7FFFFFFFF");
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 qualifiers = parms.Qualifiers;
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsTrue(qualifiers.EnableNussbaumer);
Assert.IsFalse(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsFalse(qualifiers.EnableNTTInMultiply);
Assert.IsFalse(qualifiers.EnableBatching);
}
{
var parms = new EncryptionParameters(MemoryPoolHandle.AcquireNew());
parms.SetDecompositionBitCount(0);
parms.SetNoiseStandardDeviation(3.19);
parms.SetNoiseMaxDeviation(35.06);
var coeffModulus = new BigUInt(48);
coeffModulus.Set("7FFFFFFFF");
parms.SetCoeffModulus(coeffModulus);
var plainModulus = new BigUInt(7);
plainModulus.Set(12289);
parms.SetPlainModulus(plainModulus);
var polyModulus = new BigPoly(65, 1);
polyModulus[0].Set(1);
polyModulus[64].Set(1);
parms.SetPolyModulus(polyModulus);
parms.Validate();
var qualifiers = parms.Qualifiers;
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.EnableRelinearization);
Assert.IsTrue(qualifiers.EnableNussbaumer);
Assert.IsFalse(qualifiers.EnableNTT);
// Commented out due to dependence on the SEAL library #define DISABLE_NTT_IN_MULTIPLY
//Assert.IsFalse(qualifiers.EnableNTTInMultiply);
Assert.IsTrue(qualifiers.EnableBatching);
}
}
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)));
}
