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 BalancedEncodeDecodeUInt64NET()
{
var modulus = new BigUInt("10000");
var encoder = new BalancedEncoder(modulus, 3);
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(modulus.BitCount, 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(modulus.BitCount, poly2.CoeffBitCount);
Assert.AreEqual("1x^1 + FFFF", poly2.ToString());
Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2));
var poly3 = encoder.Encode(3UL);
Assert.AreEqual(2, poly3.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly3.CoeffBitCount);
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3));
var poly4 = encoder.Encode(0x2671UL);
Assert.AreEqual(9, poly4.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly4.CoeffBitCount);
for (int i = 0; i < 9; ++i)
{
Assert.AreEqual("1", poly4[i].ToString());
}
Assert.AreEqual(0x2671UL, encoder.DecodeUInt64(poly4));
var poly5 = encoder.Encode(0xD4EBUL);
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(0xD4EBUL, 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 * 3 + 1023 * 9), encoder.DecodeUInt64(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((UInt64)(123 + -1 * 7 + 511 * 49 + 1 * 343), encoder2.DecodeUInt64(poly7));
}
public void BalancedEncodeDecodeUInt64NET()
{
var modulus = new SmallModulus(0x10000);
var encoder = new BalancedEncoder(modulus, 3, 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 + FFFF", poly2.ToString());
Assert.AreEqual(2UL, encoder.DecodeUInt64(poly2));
var poly3 = encoder.Encode(3UL);
Assert.AreEqual(2, poly3.SignificantCoeffCount());
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3UL, encoder.DecodeUInt64(poly3));
var poly4 = encoder.Encode(0x2671UL);
Assert.AreEqual(9, poly4.SignificantCoeffCount());
for (int i = 0; i < 9; ++i)
{
Assert.AreEqual(1UL, poly4[i]);
}
Assert.AreEqual(0x2671UL, encoder.DecodeUInt64(poly4));
var poly5 = encoder.Encode(0xD4EBUL);
Assert.AreEqual(11, poly5.SignificantCoeffCount());
for (int i = 0; i < 11; ++i)
{
if (i % 3 == 1)
{
Assert.AreEqual(1UL, poly5[i]);
}
else if (i % 3 == 0)
{
Assert.IsTrue(poly5[i] == 0);
}
else
{
Assert.AreEqual(0xFFFFUL, poly5[i]);
}
}
Assert.AreEqual(0xD4EBUL, encoder.DecodeUInt64(poly5));
var poly6 = new Plaintext(3);
poly6[0] = 1;
poly6[1] = 500;
poly6[2] = 1023;
Assert.AreEqual((1UL + 500 * 3 + 1023 * 9), encoder.DecodeUInt64(poly6));
var encoder2 = new BalancedEncoder(modulus, 7, MemoryPoolHandle.New());
var poly7 = new Plaintext(4);
poly7[0] = 123; // 123 (*1)
poly7[1] = 0xFFFF; // -1 (*7)
poly7[2] = 511; // 511 (*49)
poly7[3] = 1; // 1 (*343)
Assert.AreEqual((UInt64)(123 + -1 * 7 + 511 * 49 + 1 * 343), encoder2.DecodeUInt64(poly7));
var encoder3 = new BalancedEncoder(modulus, 6, MemoryPoolHandle.New());
var poly8 = new Plaintext(4);
poly8[0] = 5;
poly8[1] = 4;
poly8[2] = 3;
poly8[3] = 2;
UInt64 value = 5 + 4 * 6 + 3 * 36 + 2 * 216;
Assert.AreEqual(value, encoder3.DecodeUInt64(poly8));
var encoder4 = new BalancedEncoder(modulus, 10, MemoryPoolHandle.New());
var poly9 = new Plaintext(4);
poly9[0] = 1;
poly9[1] = 2;
poly9[2] = 3;
poly9[3] = 4;
value = 4321;
Assert.AreEqual(value, encoder4.DecodeUInt64(poly9));
value = 1234;
var poly10 = encoder2.Encode(value);
Assert.AreEqual(5, poly10.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder2.DecodeUInt64(poly10)));
value = 1234;
var poly11 = encoder3.Encode(value);
Assert.AreEqual(5, poly11.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder3.DecodeUInt64(poly11)));
value = 1234;
var poly12 = encoder4.Encode(value);
Assert.AreEqual(4, poly12.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder4.DecodeUInt64(poly12)));
}
public void FVEncryptDecryptNET()
{
var parms = new EncryptionParameters();
var plain_modulus = new SmallModulus(1 << 6);
parms.NoiseStandardDeviation = 3.19;
parms.PlainModulus = plain_modulus;
{
parms.PolyModulus = "1x^64 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods60Bit(0)
};
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var encoder = new BalancedEncoder(plain_modulus);
var encryptor = new Encryptor(context, keygen.PublicKey);
var decryptor = new Decryptor(context, keygen.SecretKey);
var encrypted = new Ciphertext();
var plain = new Plaintext();
encryptor.Encrypt(encoder.Encode(0x12345678), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x12345678UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(1), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(1UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(2), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(2UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFD), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFE), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFF), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(314159265), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(314159265UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
}
{
parms.PolyModulus = "1x^128 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1)
};
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var encoder = new BalancedEncoder(plain_modulus);
var encryptor = new Encryptor(context, keygen.PublicKey);
var decryptor = new Decryptor(context, keygen.SecretKey);
var encrypted = new Ciphertext();
var plain = new Plaintext();
encryptor.Encrypt(encoder.Encode(0x12345678), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x12345678UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(1), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(1UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(2), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(2UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFD), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFE), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFF), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(314159265), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(314159265UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
}
{
parms.PolyModulus = "1x^256 + 1";
parms.CoeffModulus = new List <SmallModulus> {
DefaultParams.SmallMods40Bit(0), DefaultParams.SmallMods40Bit(1), DefaultParams.SmallMods40Bit(2)
};
var context = new SEALContext(parms);
var keygen = new KeyGenerator(context);
var encoder = new BalancedEncoder(plain_modulus);
var encryptor = new Encryptor(context, keygen.PublicKey);
var decryptor = new Decryptor(context, keygen.SecretKey);
var encrypted = new Ciphertext();
var plain = new Plaintext();
encryptor.Encrypt(encoder.Encode(0x12345678), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x12345678UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(1), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(1UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(2), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(2UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFD), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFDUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFE), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFEUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(0x7FFFFFFFFFFFFFFF), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
encryptor.Encrypt(encoder.Encode(314159265), encrypted);
decryptor.Decrypt(encrypted, plain);
Assert.AreEqual(314159265UL, encoder.DecodeUInt64(plain));
Assert.AreEqual(encrypted.HashBlock, parms.HashBlock);
}
}
static void ExampleParameterSelection()
{
PrintExampleBanner("Example: Automatic Parameter Selection");
/*
* Here we demonstrate the automatic parameter selection tool. Suppose we want to find parameters
* that are optimized in a way that allows us to evaluate the polynomial 42x^3-27x+1. We need to know
* the size of the input data, so let's assume that x is an integer with base-3 representation of length
* at most 10.
*/
Console.Write("Finding optimized parameters for computing 42x^3-27x+1 ... ");
var chooserEncoder = new ChooserEncoder();
var chooserEvaluator = new ChooserEvaluator();
// First create a ChooserPoly representing the input data. You can think of this modeling a freshly
// encrypted cipheretext of a plaintext polynomial with length at most 10 coefficients, where the
// coefficients have absolute value at most 1.
var cinput = new ChooserPoly(10, 1);
// Compute the first term
var ccubedInput = chooserEvaluator.Exponentiate(cinput, 3);
var cterm1 = chooserEvaluator.MultiplyPlain(ccubedInput, chooserEncoder.Encode(42));
// Compute the second term
var cterm2 = chooserEvaluator.MultiplyPlain(cinput, chooserEncoder.Encode(27));
// Subtract the first two terms
var csum12 = chooserEvaluator.Sub(cterm1, cterm2);
// Add the constant term 1
var cresult = chooserEvaluator.AddPlain(csum12, chooserEncoder.Encode(1));
// To find an optimized set of parameters, we use ChooserEvaluator::select_parameters(...).
var optimalParms = new EncryptionParameters();
chooserEvaluator.SelectParameters(cresult, optimalParms);
Console.WriteLine("done.");
// Let's print these to see what was recommended
Console.WriteLine("Selected parameters:");
Console.WriteLine("{{ poly_modulus: {0}", optimalParms.PolyModulus.ToString());
Console.WriteLine("{{ coeff_modulus: {0}", optimalParms.CoeffModulus.ToString());
Console.WriteLine("{{ plain_modulus: {0}", optimalParms.PlainModulus.ToDecimalString());
Console.WriteLine("{{ decomposition_bit_count: {0}", optimalParms.DecompositionBitCount);
Console.WriteLine("{{ noise_standard_deviation: {0}", optimalParms.NoiseStandardDeviation);
Console.WriteLine("{{ noise_max_deviation: {0}", optimalParms.NoiseMaxDeviation);
// Let's try to actually perform the homomorphic computation using the recommended parameters.
// Generate keys.
Console.WriteLine("Generating keys...");
var generator = new KeyGenerator(optimalParms);
generator.Generate();
Console.WriteLine("... key generation completed");
var publicKey = generator.PublicKey;
var secretKey = generator.SecretKey;
var evaluationKeys = generator.EvaluationKeys;
// Create the encoding/encryption tools
var encoder = new BalancedEncoder(optimalParms.PlainModulus);
var encryptor = new Encryptor(optimalParms, publicKey);
var evaluator = new Evaluator(optimalParms, evaluationKeys);
var decryptor = new Decryptor(optimalParms, secretKey);
// Now perform the computations on real encrypted data.
const int inputValue = 12345;
var plainInput = encoder.Encode(inputValue);
Console.WriteLine("Encoded {0} as polynomial {1}", inputValue, plainInput.ToString());
Console.Write("Encrypting ... ");
var input = encryptor.Encrypt(plainInput);
Console.WriteLine("done.");
// Compute the first term
Console.Write("Computing first term ... ");
var cubedInput = evaluator.Exponentiate(input, 3);
var term1 = evaluator.MultiplyPlain(cubedInput, encoder.Encode(42));
Console.WriteLine("done.");
// Compute the second term
Console.Write("Computing second term ... ");
var term2 = evaluator.MultiplyPlain(input, encoder.Encode(27));
Console.WriteLine("done.");
// Subtract the first two terms
Console.Write("Subtracting first two terms ... ");
var sum12 = evaluator.Sub(term1, term2);
Console.WriteLine("done.");
// Add the constant term 1
Console.Write("Adding one ... ");
var result = evaluator.AddPlain(sum12, encoder.Encode(1));
Console.WriteLine("done.");
// Decrypt and decode
Console.Write("Decrypting ... ");
var plainResult = decryptor.Decrypt(result);
Console.WriteLine("done.");
// Finally print the result
Console.WriteLine("Polynomial 42x^3-27x+1 evaluated at x=12345: {0}", encoder.DecodeUInt64(plainResult));
// How much noise did we end up with?
Console.WriteLine("Noise in the result: {0}/{1} bits", Utilities.InherentNoise(result, optimalParms, secretKey).GetSignificantBitCount(),
Utilities.InherentNoiseMax(optimalParms).GetSignificantBitCount());
}
