public void EncodeDecodeDoubleTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS);
parms.PolyModulusDegree = 64;
parms.CoeffModulus = CoeffModulus.Create(64, new int[] { 40, 40, 40, 40 });
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
int slots = 16;
Plaintext plain = new Plaintext();
double delta = 1 << 16;
List <Complex> result = new List <Complex>();
CKKSEncoder encoder = new CKKSEncoder(context);
Assert.AreEqual(32ul, encoder.SlotCount);
double value = 10d;
encoder.Encode(value, delta, plain);
encoder.Decode(plain, result);
for (int i = 0; i < slots; i++)
{
double tmp = Math.Abs(value - result[i].Real);
Assert.IsTrue(tmp < 0.5);
}
}
public void ScaleTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 8,
CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40, 40, 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: true,
secLevel: SecLevelType.None);
KeyGenerator keygen = new KeyGenerator(context);
keygen.CreatePublicKey(out PublicKey publicKey);
keygen.CreateGaloisKeys(out GaloisKeys galoisKeys);
Encryptor encryptor = new Encryptor(context, publicKey);
Evaluator evaluator = new Evaluator(context);
CKKSEncoder encoder = new CKKSEncoder(context);
MemoryPoolHandle pool = MemoryManager.GetPool(MMProfOpt.ForceNew);
Assert.AreEqual(0ul, pool.AllocByteCount);
Ciphertext encrypted = new Ciphertext(pool);
Plaintext plain = new Plaintext();
MemoryPoolHandle cipherPool = encrypted.Pool;
Assert.IsNotNull(cipherPool);
Assert.AreEqual(0ul, cipherPool.AllocByteCount);
List <Complex> input = new List <Complex>()
{
new Complex(1, 1),
new Complex(2, 2),
new Complex(3, 3),
new Complex(4, 4)
};
double delta = Math.Pow(2, 70);
encoder.Encode(input, context.FirstParmsId, delta, plain);
encryptor.Encrypt(plain, encrypted);
Assert.AreEqual(delta, encrypted.Scale, delta: Math.Pow(2, 60));
Ciphertext encrypted2 = new Ciphertext();
encrypted2.Set(encrypted);
Assert.AreEqual(delta, encrypted2.Scale, delta: Math.Pow(2, 60));
evaluator.RescaleToNextInplace(encrypted);
Assert.AreEqual(Math.Pow(2, 30), encrypted.Scale, delta: 10000);
Assert.AreNotEqual(0ul, cipherPool.AllocByteCount);
double newScale = Math.Pow(2, 10);
encrypted.Scale = newScale;
Assert.AreEqual(newScale, encrypted.Scale, delta: 100);
}
public void CreateTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 64,
PlainModulus = new Modulus(1 << 6),
CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
KeyGenerator keygen = new KeyGenerator(context);
SecretKey secret = keygen.SecretKey;
SecretKey copy = new SecretKey(secret);
Assert.AreEqual(64ul, copy.Data.CoeffCount);
Assert.IsTrue(copy.Data.IsNTTForm);
SecretKey copy2 = new SecretKey();
copy2.Set(copy);
Assert.AreEqual(64ul, copy2.Data.CoeffCount);
Assert.IsTrue(copy2.Data.IsNTTForm);
}
public void EncodeDecodeUlongTest()
{
int slots = 32;
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS);
parms.PolyModulusDegree = (ulong)slots * 2;
parms.CoeffModulus = CoeffModulus.Create(64, new int[] { 40, 40, 40, 40 });
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
CKKSEncoder encoder = new CKKSEncoder(context);
Plaintext plain = new Plaintext();
List <Complex> result = new List <Complex>();
long value = 15;
encoder.Encode(value, plain);
encoder.Decode(plain, result);
for (int i = 0; i < slots; i++)
{
double tmp = Math.Abs(value - result[i].Real);
Assert.IsTrue(tmp < 0.5);
}
}
public void KeyStepTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 64,
CoeffModulus = CoeffModulus.Create(64, new int[] { 60, 60 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
KeyGenerator keygen = new KeyGenerator(context);
GaloisKeys keys = keygen.GaloisKeys(steps: new int[] { 1, 2, 3 });
Assert.IsNotNull(keys);
Assert.AreEqual(3ul, keys.Size);
Assert.IsFalse(keys.HasKey(1));
Assert.IsTrue(keys.HasKey(3));
Assert.IsFalse(keys.HasKey(5));
Assert.IsFalse(keys.HasKey(7));
Assert.IsTrue(keys.HasKey(9));
Assert.IsFalse(keys.HasKey(11));
Assert.IsFalse(keys.HasKey(13));
Assert.IsFalse(keys.HasKey(15));
Assert.IsFalse(keys.HasKey(17));
Assert.IsFalse(keys.HasKey(19));
Assert.IsFalse(keys.HasKey(21));
Assert.IsFalse(keys.HasKey(23));
Assert.IsFalse(keys.HasKey(25));
Assert.IsTrue(keys.HasKey(27));
}
public void EncodeDecodeComplexTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 64,
CoeffModulus = CoeffModulus.Create(64, new int[] { 40, 40, 40, 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
CKKSEncoder encoder = new CKKSEncoder(context);
Plaintext plain = new Plaintext();
Complex value = new Complex(3.1415, 2.71828);
encoder.Encode(value, scale: Math.Pow(2, 20), destination: plain);
List <Complex> result = new List <Complex>();
encoder.Decode(plain, result);
Assert.IsTrue(result.Count > 0);
Assert.AreEqual(3.1415, result[0].Real, delta: 0.0001);
Assert.AreEqual(2.71828, result[0].Imaginary, delta: 0.0001);
}
public void CreateTest()
{
List <Modulus> cm = (List <Modulus>)CoeffModulus.Create(2, new int[] { });
Assert.AreEqual(0, cm.Count);
cm = (List <Modulus>)CoeffModulus.Create(2, new int[] { 3 });
Assert.AreEqual(1, cm.Count);
Assert.AreEqual(5ul, cm[0].Value);
cm = (List <Modulus>)CoeffModulus.Create(2, new int[] { 3, 4 });
Assert.AreEqual(2, cm.Count);
Assert.AreEqual(5ul, cm[0].Value);
Assert.AreEqual(13ul, cm[1].Value);
cm = (List <Modulus>)CoeffModulus.Create(2, new int[] { 3, 5, 4, 5 });
Assert.AreEqual(4, cm.Count);
Assert.AreEqual(5ul, cm[0].Value);
Assert.AreEqual(17ul, cm[1].Value);
Assert.AreEqual(13ul, cm[2].Value);
Assert.AreEqual(29ul, cm[3].Value);
cm = (List <Modulus>)CoeffModulus.Create(32, new int[] { 30, 40, 30, 30, 40 });
Assert.AreEqual(5, cm.Count);
Assert.AreEqual(30, (int)(Math.Log(cm[0].Value, 2)) + 1);
Assert.AreEqual(40, (int)(Math.Log(cm[1].Value, 2)) + 1);
Assert.AreEqual(30, (int)(Math.Log(cm[2].Value, 2)) + 1);
Assert.AreEqual(30, (int)(Math.Log(cm[3].Value, 2)) + 1);
Assert.AreEqual(40, (int)(Math.Log(cm[4].Value, 2)) + 1);
Assert.AreEqual(1ul, cm[0].Value % 64);
Assert.AreEqual(1ul, cm[1].Value % 64);
Assert.AreEqual(1ul, cm[2].Value % 64);
Assert.AreEqual(1ul, cm[3].Value % 64);
Assert.AreEqual(1ul, cm[4].Value % 64);
}
private static void ExampleCKKSPerformanceDefault()
{
Utilities.PrintExampleBanner("CKKS Performance Test with Degrees: 4096, 8192, and 16384");
// It is not recommended to use BFVDefault primes in CKKS. However, for performance
// test, BFVDefault primes are good enough.
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS);
ulong polyModulusDegree = 4096;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
CKKSPerformanceTest(new SEALContext(parms));
Console.WriteLine();
polyModulusDegree = 8192;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
CKKSPerformanceTest(new SEALContext(parms));
Console.WriteLine();
polyModulusDegree = 16384;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
CKKSPerformanceTest(new SEALContext(parms));
/*
* Comment out the following to run the biggest example.
*/
//Console.WriteLine();
//polyModulusDegree = 32768;
//parms.PolyModulusDegree = polyModulusDegree;
//parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
//CKKSPerformanceTest(new SEALContext(parms));
}
public void ExceptionsTest()
{
Modulus sm = new Modulus(0x12345ul);
Utilities.AssertThrows <ArgumentNullException>(() => sm = new Modulus(null));
Utilities.AssertThrows <ArgumentNullException>(() => sm.Set(null));
Utilities.AssertThrows <ArgumentNullException>(() => sm.Save(null));
Utilities.AssertThrows <ArgumentNullException>(() => sm.Load(null));
Utilities.AssertThrows <EndOfStreamException>(() => sm.Load(new MemoryStream()));
// Too small polyModulusDegree
Utilities.AssertThrows <ArgumentException>(() => CoeffModulus.Create(1, new int[] { 2 }));
// Too large polyModulusDegree
Utilities.AssertThrows <ArgumentException>(() => CoeffModulus.Create(262144, new int[] { 30 }));
// Invalid polyModulusDegree
Utilities.AssertThrows <ArgumentException>(() => CoeffModulus.Create(1023, new int[] { 20 }));
// Invalid bitSize
Utilities.AssertThrows <ArgumentException>(() => CoeffModulus.Create(2048, new int[] { 0 }));
Utilities.AssertThrows <ArgumentException>(() => CoeffModulus.Create(2048, new int[] { -30 }));
Utilities.AssertThrows <ArgumentException>(() => CoeffModulus.Create(2048, new int[] { 30, -30 }));
// Too small primes requested
Utilities.AssertThrows <InvalidOperationException>(() => CoeffModulus.Create(2, new int[] { 2 }));
Utilities.AssertThrows <InvalidOperationException>(() => CoeffModulus.Create(2, new int[] { 3, 3, 3 }));
Utilities.AssertThrows <InvalidOperationException>(() => CoeffModulus.Create(1024, new int[] { 8 }));
}
private static void ExampleCKKSPerformanceCustom()
{
Console.Write("> Set PolyModulusDegree (1024, 2048, 4096, 8192, 16384, or 32768): ");
string input = Console.ReadLine();
if (!ulong.TryParse(input, out ulong polyModulusDegree))
{
Console.WriteLine("Invalid option.");
return;
}
if (polyModulusDegree < 1024 || polyModulusDegree > 32768 ||
(polyModulusDegree & (polyModulusDegree - 1)) != 0)
{
Console.WriteLine("Invalid option.");
return;
}
string banner = $"CKKS Performance Test with Degree: {polyModulusDegree}";
Utilities.PrintExampleBanner(banner);
using EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = polyModulusDegree,
CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree)
};
using (SEALContext context = new SEALContext(parms))
{
CKKSPerformanceTest(context);
}
}
public void ExpandModChainTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 4096,
CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 4096),
PlainModulus = new Modulus(1 << 20)
};
SEALContext context1 = new SEALContext(parms,
expandModChain: true,
secLevel: SecLevelType.None);
// By default there is a chain
SEALContext.ContextData contextData = context1.KeyContextData;
Assert.IsNotNull(contextData);
Assert.IsNull(contextData.PrevContextData);
Assert.IsNotNull(contextData.NextContextData);
contextData = context1.FirstContextData;
Assert.IsNotNull(contextData);
Assert.IsNotNull(contextData.PrevContextData);
Assert.IsNotNull(contextData.NextContextData);
// This should not create a chain
SEALContext context2 = new SEALContext(parms, expandModChain: false);
contextData = context2.KeyContextData;
Assert.IsNotNull(contextData);
Assert.IsNull(contextData.PrevContextData);
Assert.IsNotNull(contextData.NextContextData);
contextData = context2.FirstContextData;
Assert.IsNotNull(contextData);
Assert.IsNotNull(contextData.PrevContextData);
Assert.IsNull(contextData.NextContextData);
}
public void ExceptionsTest()
{
SEALContext context = GlobalContext.BFVContext;
KeyGenerator keygen = new KeyGenerator(context);
SecretKey secret = new SecretKey();
List <uint> elts = new List <uint> {
16385
};
List <uint> elts_null = null;
List <int> steps = new List <int> {
4096
};
List <int> steps_null = null;
Utilities.AssertThrows <ArgumentNullException>(() => keygen = new KeyGenerator(null));
Utilities.AssertThrows <ArgumentNullException>(() => keygen = new KeyGenerator(context, null));
Utilities.AssertThrows <ArgumentNullException>(() => keygen = new KeyGenerator(null, keygen.SecretKey));
Utilities.AssertThrows <ArgumentException>(() => keygen = new KeyGenerator(context, secret));
Utilities.AssertThrows <ArgumentNullException>(() => keygen.CreateGaloisKeys(elts_null));
Utilities.AssertThrows <ArgumentException>(() => keygen.CreateGaloisKeys(elts));
Utilities.AssertThrows <ArgumentNullException>(() => keygen.CreateGaloisKeys(steps_null));
Utilities.AssertThrows <ArgumentException>(() => keygen.CreateGaloisKeys(steps));
EncryptionParameters smallParms = new EncryptionParameters(SchemeType.CKKS);
smallParms.PolyModulusDegree = 128;
smallParms.CoeffModulus = CoeffModulus.Create(smallParms.PolyModulusDegree, new int[] { 60 });
context = new SEALContext(smallParms, true, SecLevelType.None);
keygen = new KeyGenerator(context);
Utilities.AssertThrows <InvalidOperationException>(() => keygen.CreateRelinKeys());
Utilities.AssertThrows <InvalidOperationException>(() => keygen.CreateGaloisKeys());
}
static GlobalContext()
{
EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 8192,
CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
};
encParams.SetPlainModulus(65537ul);
BFVContext = new SEALContext(encParams);
encParams = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 8192,
CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
};
CKKSContext = new SEALContext(encParams);
encParams = new EncryptionParameters(SchemeType.BGV)
{
PolyModulusDegree = 8192,
CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
};
encParams.SetPlainModulus(65537ul);
BGVContext = new SEALContext(encParams);
}
public void EncodeDecodeVectorDoubleTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 64,
CoeffModulus = CoeffModulus.Create(64, new int[] { 30, 30 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
CKKSEncoder encoder = new CKKSEncoder(context);
Plaintext plain = new Plaintext();
double[] values = new double[] { 0.1, 2.3, 34.4 };
encoder.Encode(values, scale: Math.Pow(2, 20), destination: plain);
List <double> result = new List <double>();
encoder.Decode(plain, result);
Assert.IsNotNull(result);
Assert.AreEqual(0.1, result[0], delta: 0.001);
Assert.AreEqual(2.3, result[1], delta: 0.001);
Assert.AreEqual(34.4, result[2], delta: 0.001);
}
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 ContextManager()
{
EncryptionParams = new EncryptionParameters(SchemeType.BFV);
const ulong polyModulusDegree = 2048;
EncryptionParams.PolyModulusDegree = polyModulusDegree;
EncryptionParams.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
EncryptionParams.PlainModulus = new Modulus(1024);
Context = new SEALContext(EncryptionParams);
}
public void SEALContextParamsTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 128,
PlainModulus = new SmallModulus(1 << 6),
CoeffModulus = CoeffModulus.Create(128, new int[] { 30, 30, 30 })
};
SEALContext context = new SEALContext(parms,
expandModChain: true,
secLevel: SecLevelType.None);
SEALContext.ContextData data = context.KeyContextData;
Assert.IsNotNull(data);
EncryptionParameters parms2 = data.Parms;
Assert.AreEqual(parms.PolyModulusDegree, parms2.PolyModulusDegree);
EncryptionParameterQualifiers qualifiers = data.Qualifiers;
Assert.IsNotNull(qualifiers);
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsFalse(qualifiers.UsingBatching);
Assert.IsTrue(qualifiers.UsingFastPlainLift);
Assert.IsTrue(qualifiers.UsingFFT);
Assert.IsTrue(qualifiers.UsingNTT);
Assert.AreEqual(SecLevelType.None, qualifiers.SecLevel);
Assert.IsFalse(qualifiers.UsingDescendingModulusChain);
Assert.IsTrue(context.UsingKeyswitching);
ulong[] cdpm = data.CoeffDivPlainModulus;
Assert.AreEqual(3, cdpm.Length);
Assert.AreEqual(32ul, data.PlainUpperHalfThreshold);
Assert.AreEqual(3, data.PlainUpperHalfIncrement.Length);
Assert.IsNull(data.UpperHalfThreshold);
Assert.IsNotNull(data.UpperHalfIncrement);
Assert.AreEqual(3, data.UpperHalfIncrement.Length);
Assert.AreEqual(2ul, data.ChainIndex);
Assert.IsNull(data.PrevContextData);
SEALContext.ContextData data2 = data.NextContextData;
Assert.IsNotNull(data2);
Assert.AreEqual(1ul, data2.ChainIndex);
Assert.AreEqual(2ul, data2.PrevContextData.ChainIndex);
SEALContext.ContextData data3 = data2.NextContextData;
Assert.IsNotNull(data3);
Assert.AreEqual(0ul, data3.ChainIndex);
Assert.AreEqual(1ul, data3.PrevContextData.ChainIndex);
Assert.IsNull(data3.NextContextData);
}
public void generateKeys(int x, int y, string publicFile, string secretFile, string encryptedXFile, string encryptedYFile)
{
//Console.WriteLine("Rider at ({0},{1})",x,y);
using EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV);
ulong polyModulusDegree = 4096;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
parms.PlainModulus = new Modulus(1024);
using SEALContext context = new SEALContext(parms);
//Console.WriteLine("Set encryption parameters and print");
//Console.WriteLine(context);
//Console.WriteLine("Parameter validation (success): {0}", context.ParameterErrorMessage());
using KeyGenerator keygen = new KeyGenerator(context);
using PublicKey riderPub = keygen.PublicKey;
using SecretKey riderSec = keygen.SecretKey;
using Evaluator evaluator = new Evaluator(context);
using IntegerEncoder encoder = new IntegerEncoder(context);
using Encryptor riderEncryptor = new Encryptor(context, riderPub);
using Decryptor riderDecryptor = new Decryptor(context, riderSec);
using Plaintext riderxPlain = encoder.Encode(x);
using Plaintext rideryPlain = encoder.Encode(y);
using Ciphertext riderxEncrypted = new Ciphertext();
using Ciphertext rideryEncrypted = new Ciphertext();
riderEncryptor.Encrypt(riderxPlain, riderxEncrypted);
riderEncryptor.Encrypt(rideryPlain, rideryEncrypted);
var fileStream = File.Create(publicFile);
riderPub.Save(fileStream);
fileStream.Close();
fileStream = File.Create(secretFile);
riderSec.Save(fileStream);
fileStream.Close();
fileStream = File.Create(encryptedXFile);
riderxEncrypted.Save(fileStream);
fileStream.Close();
fileStream = File.Create(encryptedYFile);
rideryEncrypted.Save(fileStream);
fileStream.Close();
}
public void PropertiesTest()
{
SEALContext context = GlobalContext.BFVContext;
Assert.IsTrue(context.FirstContextData.Qualifiers.ParametersSet);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingBatching);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingFastPlainLift);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingFFT);
Assert.AreEqual(SecLevelType.TC128, context.FirstContextData.Qualifiers.SecLevel);
Assert.IsFalse(context.FirstContextData.Qualifiers.UsingDescendingModulusChain);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingNTT);
Assert.IsTrue(context.UsingKeyswitching);
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 4096,
CoeffModulus = CoeffModulus.BFVDefault(4096)
};
SEALContext context2 = new SEALContext(parms);
Assert.IsTrue(context2.FirstContextData.Qualifiers.ParametersSet);
Assert.IsTrue(context2.FirstContextData.Qualifiers.UsingBatching);
Assert.IsFalse(context2.FirstContextData.Qualifiers.UsingFastPlainLift);
Assert.IsTrue(context2.FirstContextData.Qualifiers.UsingFFT);
Assert.AreEqual(SecLevelType.TC128, context2.FirstContextData.Qualifiers.SecLevel);
Assert.IsFalse(context.FirstContextData.Qualifiers.UsingDescendingModulusChain);
Assert.IsTrue(context2.FirstContextData.Qualifiers.UsingNTT);
Assert.IsTrue(context.UsingKeyswitching);
EncryptionParameterQualifiers qualifiers = new EncryptionParameterQualifiers(context2.FirstContextData.Qualifiers);
Assert.IsNotNull(qualifiers);
Assert.IsTrue(qualifiers.ParametersSet);
Assert.IsTrue(qualifiers.UsingBatching);
Assert.IsFalse(qualifiers.UsingFastPlainLift);
Assert.IsTrue(qualifiers.UsingFFT);
Assert.AreEqual(SecLevelType.TC128, qualifiers.SecLevel);
Assert.IsTrue(qualifiers.UsingDescendingModulusChain);
Assert.IsTrue(qualifiers.UsingNTT);
SEALContext context3 = GlobalContext.BGVContext;
Assert.IsTrue(context.FirstContextData.Qualifiers.ParametersSet);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingBatching);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingFastPlainLift);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingFFT);
Assert.AreEqual(SecLevelType.TC128, context.FirstContextData.Qualifiers.SecLevel);
Assert.IsFalse(context.FirstContextData.Qualifiers.UsingDescendingModulusChain);
Assert.IsTrue(context.FirstContextData.Qualifiers.UsingNTT);
Assert.IsTrue(context.UsingKeyswitching);
}
public EncounterContext()
{
@params = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = polyModDeg, // Must be a positive power of 2
CoeffModulus = CoeffModulus.BFVDefault(polyModDeg),
PlainModulus = new SmallModulus(256) // Try to keep this as small as possible
};
SealContext = new SEALContext(@params);
KeyGen = new KeyGenerator(SealContext);
Decryptor = new Decryptor(SealContext, KeyGen.SecretKey);
Encryptor = new Encryptor(SealContext, KeyGen.PublicKey);
}
public SalaryComputation()
{
//Constructor.
parms = new EncryptionParameters(SchemeType.CKKS);
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.Create(
polyModulusDegree, new int[] { 60, 40, 40, 60 });
//parms.PlainModulus = PlainModulus.Batching(polyModulusDegree, 20);
context = new SEALContext(parms);
evaluator = new Evaluator(context);
encoder = new CKKSEncoder(context);
SetConstants();
}
public void CreateTest()
{
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 64,
PlainModulus = new Modulus(1 << 6),
CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
KeyGenerator keygen = new KeyGenerator(context);
keygen.CreatePublicKey(out PublicKey pub);
PublicKey copy = new PublicKey(pub);
Assert.IsNotNull(copy);
Assert.AreEqual(2ul, copy.Data.Size);
Assert.IsTrue(copy.Data.IsNTTForm);
PublicKey copy2 = new PublicKey();
copy2.Set(copy);
Assert.AreEqual(2ul, copy2.Data.Size);
Assert.IsTrue(copy2.Data.IsNTTForm);
}
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BGV)
{
PolyModulusDegree = 64,
PlainModulus = new Modulus(1 << 6),
CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
KeyGenerator keygen = new KeyGenerator(context);
keygen.CreatePublicKey(out PublicKey pub);
PublicKey copy = new PublicKey(pub);
Assert.IsNotNull(copy);
Assert.AreEqual(2ul, copy.Data.Size);
Assert.IsTrue(copy.Data.IsNTTForm);
PublicKey copy2 = new PublicKey();
copy2.Set(copy);
Assert.AreEqual(2ul, copy2.Data.Size);
Assert.IsTrue(copy2.Data.IsNTTForm);
}
}
public void EqualsTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 8,
PlainModulus = new SmallModulus(257),
CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40 })
};
EncryptionParameters parms2 = new EncryptionParameters(SchemeType.CKKS);
Assert.AreNotEqual(parms, parms2);
Assert.IsFalse(parms.Equals(null));
}
public BMIComputation(RelinKeys Keys)
{
parms = new EncryptionParameters(SchemeType.CKKS);
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.Create(
polyModulusDegree, new int[] { 60, 40, 40, 60 });
//parms.PlainModulus = PlainModulus.Batching(polyModulusDegree, 20);
context = new SEALContext(parms);
evaluator = new Evaluator(context);
encoder = new CKKSEncoder(context);
scale = Math.Pow(2.0, 40);
SetConstants();
KeysRelin = Keys;
}
//private static bool _firstTime = true;
//private static Decryptor _decryptor;
public SecureSvc(int nRows, double[][] vectors, double[][] coefficients, double[] intercepts,
String kernel, double gamma, double coef0, ulong degree , int power)
{
//this._nRows = nRows;
this._vectors = vectors;
this._coefficients = coefficients;
this._intercepts = intercepts;
this._kernel = Enum.Parse<Kernel>(kernel, true);
this._gamma = gamma;
this._coef0 = coef0;
this._degree = degree;
this._power = power;
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS);
ulong polyModulusDegree = 16384;
if (power >= 20 && power < 40 )
{
parms.CoeffModulus = CoeffModulus.Create(polyModulusDegree,
new int[] { 60, 20, 21, 22, 23, 24, 25, 26, 27, 60 });
}
else if (power >= 40 && power < 60)
{
parms.CoeffModulus = CoeffModulus.Create(polyModulusDegree,
new int[] { 60, 40, 40, 40, 40, 40, 40, 40 , 60 });
}
else if (power == 60)
{
polyModulusDegree = 32768;
parms.CoeffModulus = CoeffModulus.Create(polyModulusDegree,
new int[] { 60, 60, 60, 60, 60, 60, 60, 60, 60 });
}
parms.PolyModulusDegree = polyModulusDegree;
_context = new SEALContext(parms);
KeyGenerator keygen = new KeyGenerator(_context);
_publicKey = keygen.PublicKey;
_secretKey = keygen.SecretKey;
_relinKeys = keygen.RelinKeys();
_galoisKeys = keygen.GaloisKeys();
_encryptor = new Encryptor(_context, _publicKey);
_evaluator = new Evaluator(_context);
_decryptor = new Decryptor(_context, _secretKey);
_encoder = new CKKSEncoder(_context);
}
public void SaveLoadTest()
{
TestDelegate save_load_test = delegate(SchemeType scheme)
{
List <SmallModulus> coeffModulus = (List <SmallModulus>)CoeffModulus.Create(8, new int[] { 40, 40 });
EncryptionParameters parms = new EncryptionParameters(scheme)
{
PolyModulusDegree = 8,
CoeffModulus = coeffModulus
};
if (scheme == SchemeType.BFV)
{
parms.SetPlainModulus(257);
}
EncryptionParameters loaded = null;
using (MemoryStream stream = new MemoryStream())
{
EncryptionParameters.Save(parms, stream);
stream.Seek(offset: 0, loc: SeekOrigin.Begin);
loaded = EncryptionParameters.Load(stream);
}
Assert.AreEqual(scheme, loaded.Scheme);
Assert.AreEqual(8ul, loaded.PolyModulusDegree);
if (scheme == SchemeType.BFV)
{
Assert.AreEqual(257ul, loaded.PlainModulus.Value);
}
else if (scheme == SchemeType.CKKS)
{
Assert.AreEqual(0ul, loaded.PlainModulus.Value);
}
List <SmallModulus> loadedCoeffModulus = new List <SmallModulus>(loaded.CoeffModulus);
Assert.AreEqual(2, loadedCoeffModulus.Count);
Assert.AreNotSame(coeffModulus[0], loadedCoeffModulus[0]);
Assert.AreNotSame(coeffModulus[1], loadedCoeffModulus[1]);
Assert.AreEqual(coeffModulus[0], loadedCoeffModulus[0]);
Assert.AreEqual(coeffModulus[1], loadedCoeffModulus[1]);
};
save_load_test(SchemeType.BFV);
save_load_test(SchemeType.CKKS);
}
private static void ExampleBFVPerformanceDefault()
{
Utilities.PrintExampleBanner("BFV Performance Test with Degrees: 4096, 8192, and 16384");
using EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV);
ulong polyModulusDegree = 4096;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
parms.PlainModulus = new Modulus(786433);
using (SEALContext context = new SEALContext(parms))
{
BFVPerformanceTest(context);
}
Console.WriteLine();
polyModulusDegree = 8192;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
parms.PlainModulus = new Modulus(786433);
using (SEALContext context = new SEALContext(parms))
{
BFVPerformanceTest(context);
}
Console.WriteLine();
polyModulusDegree = 16384;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
parms.PlainModulus = new Modulus(786433);
using (SEALContext context = new SEALContext(parms))
{
BFVPerformanceTest(context);
}
/*
* Comment out the following to run the biggest example.
*/
//Console.WriteLine();
//polyModulusDegree = 32768;
//parms.PolyModulusDegree = polyModulusDegree;
//parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
//parms.PlainModulus = new Modulus(786433);
//using (SEALContext context = new SEALContext(parms))
//{
// BFVPerformanceTest(context);
//}
}
public void SchemeIsCKKSTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 8,
CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40, 40, 40 })
};
SEALContext context = new SEALContext(parms,
expandModChain: false,
secLevel: SecLevelType.None);
Utilities.AssertThrows <ArgumentException>(() =>
{
BatchEncoder encoder = new BatchEncoder(context);
});
}
public CKKSEncryptor()
{
//Set scheme Primes and encryption parameters.
parms = new EncryptionParameters(SchemeType.CKKS);
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.Create(
polyModulusDegree, new int[] { 60, 40, 40, 60 });
scale = Math.Pow(2.0, 40);
context = new SEALContext(parms);
keygen = new KeyGenerator(context);
//Generate private and public key.
publicKey = keygen.PublicKey;
secretKey = keygen.SecretKey;
encryptor = new Encryptor(context, publicKey);
encoder = new CKKSEncoder(context);
KeysRelin = keygen.RelinKeys();
}
public void encryptDriverLocation(int x, int y, string publicFile, string encryptedXFile, string encryptedYFile)
{
//Console.WriteLine("Driver at ({0},{1})",x,y);
using EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV);
ulong polyModulusDegree = 4096;
parms.PolyModulusDegree = polyModulusDegree;
parms.CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree);
parms.PlainModulus = new Modulus(1024);
using SEALContext context = new SEALContext(parms);
using KeyGenerator keygen = new KeyGenerator(context);
using PublicKey riderPub = new PublicKey();
using Ciphertext xEncrypted = new Ciphertext();
using (var sr = new StreamReader(publicFile))
{
riderPub.Load(context, sr.BaseStream);
}
using Evaluator evaluator = new Evaluator(context);
using IntegerEncoder encoder = new IntegerEncoder(context);
using Encryptor riderEncryptor = new Encryptor(context, riderPub);
using Plaintext driverxPlain = encoder.Encode(x);
using Plaintext driveryPlain = encoder.Encode(y);
using Ciphertext driverxEncrypted = new Ciphertext();
using Ciphertext driveryEncrypted = new Ciphertext();
riderEncryptor.Encrypt(driverxPlain, driverxEncrypted);
riderEncryptor.Encrypt(driveryPlain, driveryEncrypted);
var fileStream = File.Create(encryptedXFile);
driverxEncrypted.Save(fileStream);
fileStream.Close();
fileStream = File.Create(encryptedYFile);
driveryEncrypted.Save(fileStream);
fileStream.Close();
}
