public void SeededKeyTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 128,
PlainModulus = new Modulus(1 << 6),
CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40, 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
KeyGenerator keygen = new KeyGenerator(context);
RelinKeys relinKeys = new RelinKeys();
using (MemoryStream stream = new MemoryStream())
{
keygen.CreateRelinKeys().Save(stream);
stream.Seek(0, SeekOrigin.Begin);
relinKeys.Load(context, stream);
}
keygen.CreatePublicKey(out PublicKey publicKey);
Encryptor encryptor = new Encryptor(context, publicKey);
Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
Evaluator evaluator = new Evaluator(context);
Ciphertext encrypted1 = new Ciphertext(context);
Ciphertext encrypted2 = new Ciphertext(context);
Plaintext plain1 = new Plaintext();
Plaintext plain2 = new Plaintext();
plain1.Set(0);
encryptor.Encrypt(plain1, encrypted1);
evaluator.SquareInplace(encrypted1);
evaluator.RelinearizeInplace(encrypted1, relinKeys);
decryptor.Decrypt(encrypted1, plain2);
Assert.AreEqual(1ul, plain2.CoeffCount);
Assert.AreEqual(0ul, plain2[0]);
plain1.Set("1x^10 + 2");
encryptor.Encrypt(plain1, encrypted1);
evaluator.SquareInplace(encrypted1);
evaluator.RelinearizeInplace(encrypted1, relinKeys);
evaluator.SquareInplace(encrypted1);
evaluator.Relinearize(encrypted1, relinKeys, encrypted2);
decryptor.Decrypt(encrypted2, plain2);
// {1x^40 + 8x^30 + 18x^20 + 20x^10 + 10}
Assert.AreEqual(41ul, plain2.CoeffCount);
Assert.AreEqual(16ul, plain2[0]);
Assert.AreEqual(32ul, plain2[10]);
Assert.AreEqual(24ul, plain2[20]);
Assert.AreEqual(8ul, plain2[30]);
Assert.AreEqual(1ul, plain2[40]);
}
public void ReleaseTest()
{
Plaintext plain = new Plaintext();
plain.Reserve(10000);
plain.Set("3x^2 + 4x^1 + 5");
Assert.AreEqual(10000ul, plain.Capacity);
Assert.AreEqual(3ul, plain.CoeffCount);
plain.Release();
Assert.AreEqual(0ul, plain.Capacity);
Assert.AreEqual(0ul, plain.CoeffCount);
}
public void EqualsTest()
{
Plaintext plain1 = new Plaintext();
Plaintext plain2 = new Plaintext();
plain1.Reserve(10000);
plain2.Reserve(500);
plain1.Set("4x^3 + 5x^2 + 6x^1 + 7");
plain2.Set("4x^3 + 5x^2 + 6x^1 + 7");
Assert.AreEqual(10000ul, plain1.Capacity);
Assert.AreEqual(500ul, plain2.Capacity);
Assert.AreNotSame(plain1, plain2);
Assert.AreEqual(plain1, plain2);
Assert.IsFalse(plain1.Equals(null));
}
public void CreateTest()
{
Plaintext plain = new Plaintext();
Assert.IsNotNull(plain);
Assert.AreEqual(0ul, plain.CoeffCount);
Plaintext plain2 = new Plaintext(capacity: 20, coeffCount: 10);
Assert.IsNotNull(plain2);
Assert.AreEqual(20ul, plain2.Capacity);
Assert.AreEqual(10ul, plain2.CoeffCount);
Plaintext plain3 = new Plaintext();
plain3.Set(plain2);
Assert.IsNotNull(plain3);
Assert.AreEqual(10ul, plain3.Capacity);
Assert.AreEqual(10ul, plain3.CoeffCount);
}
public void ShrinkToFitTest()
{
Plaintext plain = new Plaintext();
plain.Reserve(10000);
Assert.AreEqual(10000ul, plain.Capacity);
Assert.AreEqual(0ul, plain.CoeffCount);
plain.Set("1");
Assert.AreEqual(10000ul, plain.Capacity);
Assert.AreEqual(1ul, plain.CoeffCount);
Assert.AreEqual(1ul, plain.SignificantCoeffCount);
plain.ShrinkToFit();
Assert.AreEqual(1ul, plain.Capacity);
Assert.AreEqual(1ul, plain.CoeffCount);
Assert.AreEqual(1ul, plain[0]);
}
public void FromEnumerableTest()
{
bool EqFun(List <ulong> coeffs, Plaintext plain)
{
bool result = true;
for (int i = 0; i < coeffs.Count; i++)
{
if (coeffs[i] != plain[(ulong)i])
{
result = false;
}
}
return(result);
}
// Constructors
List <ulong> coeffs = new List <ulong> {
};
Plaintext plain = new Plaintext(coeffs);
Assert.IsTrue(plain.IsZero);
coeffs = new List <ulong> {
0
};
plain = new Plaintext(coeffs);
Assert.AreEqual(1ul, plain.CoeffCount);
Assert.AreEqual(1ul, plain.Capacity);
Assert.IsTrue(EqFun(coeffs, plain));
plain = new Plaintext(coeffs, 2);
Assert.AreEqual(1ul, plain.CoeffCount);
Assert.AreEqual(2ul, plain.Capacity);
Assert.IsTrue(EqFun(coeffs, plain));
coeffs = new List <ulong> {
1, 2
};
plain = new Plaintext(coeffs);
Assert.AreEqual(2ul, plain.CoeffCount);
Assert.AreEqual(2ul, plain.Capacity);
Assert.IsTrue(EqFun(coeffs, plain));
plain = new Plaintext(coeffs, 3);
Assert.AreEqual(2ul, plain.CoeffCount);
Assert.AreEqual(3ul, plain.Capacity);
Assert.IsTrue(EqFun(coeffs, plain));
// Setter
coeffs = new List <ulong> {
};
plain.Set(coeffs);
Assert.AreEqual(0ul, plain.CoeffCount);
Assert.AreEqual(3ul, plain.Capacity);
coeffs = new List <ulong> {
5, 4, 3, 2, 1
};
plain.Set(coeffs);
Assert.AreEqual(5ul, plain.CoeffCount);
Assert.AreEqual(5ul, plain.Capacity);
Assert.IsTrue(EqFun(coeffs, plain));
}
public void BalancedEncodeDecodeInt32NET()
{
var modulus = new SmallModulus(0x10000);
var encoder = new BalancedEncoder(modulus, 3, 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 + FFFF", poly2.ToString());
Assert.AreEqual(2, encoder.DecodeInt32(poly2));
var poly3 = encoder.Encode(3);
Assert.AreEqual(2, poly3.SignificantCoeffCount());
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3, encoder.DecodeInt32(poly3));
var poly4 = encoder.Encode(-1);
Assert.AreEqual(1, poly4.SignificantCoeffCount());
Assert.AreEqual("FFFF", poly4.ToString());
Assert.AreEqual(-1, encoder.DecodeInt32(poly4));
var poly5 = encoder.Encode(-2);
Assert.AreEqual(2, poly5.SignificantCoeffCount());
Assert.AreEqual("FFFFx^1 + 1", poly5.ToString());
Assert.AreEqual(-2, encoder.DecodeInt32(poly5));
var poly6 = encoder.Encode(-3);
Assert.AreEqual(2, poly6.SignificantCoeffCount());
Assert.AreEqual("FFFFx^1", poly6.ToString());
Assert.AreEqual(-3, encoder.DecodeInt32(poly6));
var poly7 = encoder.Encode(-0x2671);
Assert.AreEqual(9, poly7.SignificantCoeffCount());
for (int i = 0; i < 9; ++i)
{
Assert.AreEqual(0xFFFFUL, poly7[i]);
}
Assert.AreEqual(-0x2671, encoder.DecodeInt32(poly7));
var poly8 = encoder.Encode(-4374);
Assert.AreEqual(9, poly8.SignificantCoeffCount());
Assert.AreEqual(0xFFFFUL, poly8[8]);
Assert.AreEqual(1UL, poly8[7]);
for (int i = 0; i < 7; ++i)
{
Assert.IsTrue(poly8[i] == 0);
}
Assert.AreEqual(-4374, encoder.DecodeInt32(poly8));
var poly9 = encoder.Encode(-0xD4EB);
Assert.AreEqual(11, poly9.SignificantCoeffCount());
for (int i = 0; i < 11; ++i)
{
if (i % 3 == 1)
{
Assert.AreEqual(0xFFFFUL, poly9[i]);
}
else if (i % 3 == 0)
{
Assert.IsTrue(poly9[i] == 0);
}
else
{
Assert.AreEqual(1UL, poly9[i]);
}
}
Assert.AreEqual(-0xD4EB, encoder.DecodeInt32(poly9));
var poly10 = encoder.Encode(-30724);
Assert.AreEqual(11, poly10.SignificantCoeffCount());
Assert.AreEqual(0xFFFFUL, poly10[10]);
Assert.AreEqual(1UL, poly10[9]);
Assert.AreEqual(1UL, poly10[8]);
Assert.AreEqual(1UL, poly10[7]);
Assert.IsTrue(poly10[6] == 0);
Assert.IsTrue(poly10[5] == 0);
Assert.AreEqual(0xFFFFUL, poly10[4]);
Assert.AreEqual(0xFFFFUL, poly10[3]);
Assert.IsTrue(poly10[2] == 0);
Assert.AreEqual(1UL, poly10[1]);
Assert.AreEqual(0xFFFFUL, poly10[0]);
Assert.AreEqual(-30724, encoder.DecodeInt32(poly10));
modulus.Set(0xFFFF);
var encoder2 = new BalancedEncoder(modulus, 7, MemoryPoolHandle.New());
var poly12 = new Plaintext(6);
poly12[0] = 1;
poly12[1] = 0xFFFE; // -1
poly12[2] = 0xFFFD; // -2
poly12[3] = 0x8000; // -32767
poly12[4] = 0x7FFF; // 32767
poly12[5] = 0x7FFE; // 32766
Assert.AreEqual(1 + -1 * 7 + -2 * 49 + -32767 * 343 + 32767 * 2401 + 32766 * 16807, encoder2.DecodeInt32(poly12));
var encoder4 = new BalancedEncoder(modulus, 6, MemoryPoolHandle.New());
poly8 = new Plaintext(4);
poly8[0] = 5;
poly8[1] = 4;
poly8[2] = 3;
poly8[3] = (modulus.Value - 2);
Int32 value = 5 + 4 * 6 + 3 * 36 - 2 * 216;
Assert.AreEqual(value, encoder4.DecodeInt32(poly8));
var encoder5 = new BalancedEncoder(modulus, 10, MemoryPoolHandle.New());
poly9 = new Plaintext(4);
poly9[0] = 1;
poly9[1] = 2;
poly9[2] = 3;
poly9[3] = 4;
value = 4321;
Assert.AreEqual(value, encoder5.DecodeInt32(poly9));
value = -1234;
poly10.Set(encoder2.Encode(value));
Assert.AreEqual(5, poly10.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder2.DecodeInt32(poly10)));
value = -1234;
var poly11 = encoder4.Encode(value);
Assert.AreEqual(5, poly11.SignificantCoeffCount());
Assert.AreEqual(value, encoder4.DecodeInt32(poly11));
value = -1234;
poly12.Set(encoder5.Encode(value));
Assert.AreEqual(4, poly12.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder5.DecodeInt32(poly12)));
}