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);
}
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 TestSmallEncryptDecrypt()
{
IDataStore sourceFileInfo = New <IDataStore>(_testTextPath);
IDataStore destinationFileInfo = sourceFileInfo.CreateEncryptedName();
Assert.That(destinationFileInfo.Name, Is.EqualTo("test-txt.axx"), "Wrong encrypted file name based on the plain text file name.");
EncryptionParameters encryptionParameters = new EncryptionParameters(new V1Aes128CryptoFactory().CryptoId, new Passphrase("axcrypt"));
new AxCryptFile().Encrypt(sourceFileInfo, destinationFileInfo, encryptionParameters, AxCryptOptions.EncryptWithCompression, new ProgressContext());
using (IAxCryptDocument document = New <AxCryptFile>().Document(destinationFileInfo, new LogOnIdentity("axcrypt"), new ProgressContext()))
{
Assert.That(document.PassphraseIsValid, Is.True, "The passphrase should be ok.");
Assert.That(document.FileName, Is.EqualTo("test.txt"), "Unexpected file name in headers.");
Assert.That(document.CreationTimeUtc, Is.EqualTo(FakeDataStore.TestDate1Utc));
Assert.That(document.LastAccessTimeUtc, Is.EqualTo(FakeDataStore.TestDate2Utc));
Assert.That(document.LastWriteTimeUtc, Is.EqualTo(FakeDataStore.TestDate3Utc));
IDataStore decryptedFileInfo = New <IDataStore>(Path.Combine(_rootPath, "decrypted test.txt"));
using (FileLock decryptFileLock = New <FileLocker>().Acquire(decryptedFileInfo))
{
New <AxCryptFile>().Decrypt(document, decryptFileLock, AxCryptOptions.SetFileTimes, new ProgressContext());
}
using (Stream decryptedStream = decryptedFileInfo.OpenRead())
{
string decrypted = new StreamReader(decryptedStream, Encoding.UTF8).ReadToEnd();
Assert.That(decrypted, Is.EqualTo("This is a short file"));
}
Assert.That(decryptedFileInfo.CreationTimeUtc, Is.EqualTo(document.CreationTimeUtc), "We're expecting file times to be set as the original from the headers.");
Assert.That(decryptedFileInfo.LastAccessTimeUtc, Is.EqualTo(document.LastAccessTimeUtc), "We're expecting file times to be set as the original from the headers.");
Assert.That(decryptedFileInfo.LastWriteTimeUtc, Is.EqualTo(document.LastWriteTimeUtc), "We're expecting file times to be set as the original from the headers.");
}
}
public V2DocumentHeaders(EncryptionParameters encryptionParameters, long keyWrapIterations)
{
if (encryptionParameters == null)
{
throw new ArgumentNullException("encryptionParameters");
}
_headers = new Headers();
_headers.HeaderBlocks.Add(new PreambleHeaderBlock());
_headers.HeaderBlocks.Add(new VersionHeaderBlock(_version));
ICryptoFactory cryptoFactory = Resolve.CryptoFactory.Create(encryptionParameters.CryptoId);
IDerivedKey keyEncryptingKey = cryptoFactory.CreateDerivedKey(encryptionParameters.Passphrase);
V2KeyWrapHeaderBlock keyWrap = new V2KeyWrapHeaderBlock(cryptoFactory, keyEncryptingKey, keyWrapIterations);
_headers.HeaderBlocks.Add(keyWrap);
_keyStreamFactory = keyWrap;
foreach (UserPublicKey publicKey in encryptionParameters.PublicKeys)
{
_headers.HeaderBlocks.Add(new V2AsymmetricKeyWrapHeaderBlock(publicKey, keyWrap.MasterKey, keyWrap.MasterIV));
}
_headers.HeaderBlocks.Add(new V2AsymmetricRecipientsEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.AsymmetricRecipients))
{
Recipients = new Recipients(encryptionParameters.PublicKeys)
});
_headers.HeaderBlocks.Add(new FileInfoEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.FileInfo)));
_headers.HeaderBlocks.Add(new V2CompressionEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.Compression)));
_headers.HeaderBlocks.Add(new V2UnicodeFileNameInfoEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.UnicodeFileNameInfo)));
_headers.HeaderBlocks.Add(new V2AlgorithmVerifierEncryptedHeaderBlock(GetHeaderCrypto(HeaderBlockType.AlgorithmVerifier)));
_headers.HeaderBlocks.Add(new DataHeaderBlock());
SetDataEncryptingCryptoForEncryptedHeaderBlocks(_headers.HeaderBlocks);
}
public void EncryptExponentiateDecryptNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 4);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate();
var Encoder = new BinaryEncoder(parms.PlainModulus);
var encryptor = new Encryptor(parms, keygen.PublicKey);
var evaluator = new Evaluator(parms, keygen.EvaluationKeys);
var keygenEvals = keygen.EvaluationKeys;
var evaluatorEvals = keygen.EvaluationKeys;
for (int i = 0; i < keygen.EvaluationKeys.Count; ++i)
{
Assert.AreEqual(keygenEvals[i], evaluatorEvals[i]);
}
var decryptor = new Decryptor(parms, keygen.SecretKey);
var encrypted = encryptor.Encrypt(Encoder.Encode(5));
var power = evaluator.Exponentiate(encrypted, 1);
Assert.AreEqual(5, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(5));
power = evaluator.Exponentiate(encrypted, 0);
Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(5));
power = evaluator.Exponentiate(encrypted, 0);
Assert.AreEqual(1, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(7));
power = evaluator.Exponentiate(encrypted, 2);
Assert.AreEqual(49, Encoder.DecodeInt32(decryptor.Decrypt(power)));
encrypted = encryptor.Encrypt(Encoder.Encode(-7));
power = evaluator.Exponentiate(encrypted, 3);
Assert.AreEqual(-343, Encoder.DecodeInt32(decryptor.Decrypt(power)));
}
private static string EncryptPrivateKey(UserKeyPair keys, Passphrase passphrase)
{
if (keys.KeyPair.PrivateKey == null)
{
return(String.Empty);
}
byte[] privateKeyPemBytes = Encoding.UTF8.GetBytes(keys.KeyPair.PrivateKey.ToString());
if (passphrase == Passphrase.Empty)
{
byte[] encryptedPrivateKeyBytes = New <IProtectedData>().Protect(privateKeyPemBytes, null);
return(Convert.ToBase64String(encryptedPrivateKeyBytes));
}
StringBuilder encryptedPrivateKey = new StringBuilder();
using (StringWriter writer = new StringWriter(encryptedPrivateKey))
{
using (Stream stream = new MemoryStream(privateKeyPemBytes))
{
EncryptionParameters encryptionParameters = new EncryptionParameters(Resolve.CryptoFactory.Preferred.CryptoId, passphrase);
EncryptedProperties properties = new EncryptedProperties("private-key.pem");
using (MemoryStream encryptedStream = new MemoryStream())
{
AxCryptFile.Encrypt(stream, encryptedStream, properties, encryptionParameters, AxCryptOptions.EncryptWithCompression, new ProgressContext());
writer.Write(Convert.ToBase64String(encryptedStream.ToArray()));
}
}
}
return(encryptedPrivateKey.ToString());
}
public virtual void Encrypt(IDataStore sourceFile, Stream destinationStream, EncryptionParameters encryptionParameters, AxCryptOptions options, IProgressContext progress)
{
if (sourceFile == null)
{
throw new ArgumentNullException("sourceFile");
}
if (destinationStream == null)
{
throw new ArgumentNullException("destinationStream");
}
if (encryptionParameters == null)
{
throw new ArgumentNullException("encryptionParameters");
}
if (progress == null)
{
throw new ArgumentNullException("progress");
}
using (Stream sourceStream = new ProgressStream(sourceFile.OpenRead(), progress))
{
using (IAxCryptDocument document = New <AxCryptFactory>().CreateDocument(encryptionParameters))
{
document.FileName = sourceFile.Name;
document.CreationTimeUtc = sourceFile.CreationTimeUtc;
document.LastAccessTimeUtc = sourceFile.LastAccessTimeUtc;
document.LastWriteTimeUtc = sourceFile.LastWriteTimeUtc;
document.EncryptTo(sourceStream, destinationStream, options);
}
}
}
public void CreateTest()
{
List <SmallModulus> coeffModulus = new List <SmallModulus>
{
DefaultParams.SmallMods40Bit(0)
};
EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
{
PolyModulusDegree = 64,
PlainModulus = new SmallModulus(1 << 6),
CoeffModulus = coeffModulus
};
SEALContext context = SEALContext.Create(parms);
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 CreateTest()
{
EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV);
Assert.IsNotNull(encParams);
Assert.AreEqual(SchemeType.BFV, encParams.Scheme);
EncryptionParameters encParams2 = new EncryptionParameters(SchemeType.CKKS);
Assert.IsNotNull(encParams2);
Assert.AreEqual(SchemeType.CKKS, encParams2.Scheme);
EncryptionParameters encParams3 = new EncryptionParameters(SchemeType.CKKS);
Assert.IsNotNull(encParams3);
Assert.AreEqual(SchemeType.CKKS, encParams3.Scheme);
EncryptionParameters copy = new EncryptionParameters(encParams);
Assert.AreEqual(SchemeType.BFV, copy.Scheme);
Assert.AreEqual(encParams, copy);
Assert.AreEqual(encParams.GetHashCode(), copy.GetHashCode());
EncryptionParameters third = new EncryptionParameters(SchemeType.CKKS);
third.Set(copy);
Assert.AreEqual(SchemeType.BFV, third.Scheme);
Assert.AreEqual(encParams, third);
Assert.AreEqual(encParams.GetHashCode(), third.GetHashCode());
}
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());
}
public void SEALContextCreateTest()
{
EncryptionParameters encParams1 = new EncryptionParameters(SchemeType.BFV);
EncryptionParameters encParams2 = new EncryptionParameters(SchemeType.CKKS);
SEALContext context1 = new SEALContext(encParams1);
SEALContext context2 = new SEALContext(encParams2);
Assert.IsNotNull(context1);
Assert.IsNotNull(context2);
Assert.IsFalse(context1.ParametersSet);
Assert.IsFalse(context2.ParametersSet);
Assert.AreNotSame(context1.FirstParmsId, context1.LastParmsId);
Assert.AreEqual(context1.FirstParmsId, context1.LastParmsId);
SEALContext.ContextData data1 = context2.FirstContextData;
SEALContext.ContextData data2 = context2.GetContextData(context2.FirstParmsId);
Assert.AreNotSame(data1, data2);
ulong[] totalCoeffMod1 = data1.TotalCoeffModulus;
ulong[] totalCoeffMod2 = data2.TotalCoeffModulus;
int bitCount1 = data1.TotalCoeffModulusBitCount;
int bitCount2 = data2.TotalCoeffModulusBitCount;
Assert.AreEqual(bitCount1, bitCount2);
Assert.AreEqual(totalCoeffMod1.Length, totalCoeffMod2.Length);
for (int i = 0; i < totalCoeffMod1.Length; i++)
{
Assert.AreEqual(totalCoeffMod1[i], totalCoeffMod2[i]);
}
}
private void Save(EncryptionParameters Parameters)
{
Bitmap image = Encrypt(Parameters.Text, Parameters.Password);
if (image == null)
{
return;
}
var fileDialog = new SaveFileDialog
{
Filter = "Bitmap Image | *.bmp",
FileName = "Obrázek"
};
fileDialog.OverwritePrompt = true;
fileDialog.ShowDialog(MainWindowViewModel.GetInstance.AppWindow);
if (fileDialog.FileName == "Obrázek")
{
return;
}
var fs = (FileStream)fileDialog.OpenFile();
image.Save(fs, ImageFormat.Bmp);
fs.Close();
image.Dispose();
}
public void FVKeyGenerationNoEVKNET()
{
var parms = new EncryptionParameters
{
DecompositionBitCount = 0,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
var keygen = new KeyGenerator(parms);
keygen.Generate(0);
Assert.IsFalse(keygen.PublicKey[0].IsZero);
Assert.IsFalse(keygen.PublicKey[1].IsZero);
Assert.IsFalse(keygen.SecretKey.IsZero);
}
public static async Task ChangeKeySharingAsync(this IEnumerable <string> files, IEnumerable <UserPublicKey> publicKeys)
{
EncryptionParameters encryptionParameters = new EncryptionParameters(Resolve.CryptoFactory.Default(New <ICryptoPolicy>()).CryptoId, New <KnownIdentities>().DefaultEncryptionIdentity);
await encryptionParameters.AddAsync(await publicKeys.GetKnownPublicKeysAsync(New <KnownIdentities>().DefaultEncryptionIdentity));
await ChangeEncryptionAsync(files, encryptionParameters);
}
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);
}
private static Task ChangeEncryptionAsync(IEnumerable <string> files, EncryptionParameters encryptionParameters)
{
return(Resolve.ParallelFileOperation.DoFilesAsync(files.Select(f => New <IDataStore>(f)),
async(IDataStore file, IProgressContext progress) =>
{
ActiveFile activeFile = New <FileSystemState>().FindActiveFileFromEncryptedPath(file.FullName);
LogOnIdentity decryptIdentity = activeFile?.Identity ?? New <KnownIdentities>().DefaultEncryptionIdentity;
await New <AxCryptFile>().ChangeEncryptionAsync(file, decryptIdentity, encryptionParameters, progress);
if (activeFile != null)
{
New <FileSystemState>().Add(new ActiveFile(activeFile, encryptionParameters.CryptoId, New <KnownIdentities>().DefaultEncryptionIdentity));
await New <FileSystemState>().Save();
}
return new FileOperationContext(file.FullName, ErrorStatus.Success);
},
async(FileOperationContext foc) =>
{
if (foc.ErrorStatus != ErrorStatus.Success)
{
New <IStatusChecker>().CheckStatusAndShowMessage(foc.ErrorStatus, foc.FullName, foc.InternalMessage);
return;
}
await Resolve.SessionNotify.NotifyAsync(new SessionNotification(SessionNotificationType.ActiveFileChange, files));
}));
}
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 EncryptionParamsWriteReadNET()
{
// Create encryption parameters.
var parms = new EncryptionParameters
{
DecompositionBitCount = 4,
NoiseStandardDeviation = 3.19,
NoiseMaxDeviation = 35.06,
};
var coeffModulus = parms.CoeffModulus;
coeffModulus.Resize(48);
coeffModulus.Set("FFFFFFFFC001");
var plainModulus = parms.PlainModulus;
plainModulus.Resize(7);
plainModulus.Set(1 << 6);
var polyModulus = parms.PolyModulus;
polyModulus.Resize(64, 1);
polyModulus[0].Set(1);
polyModulus[63].Set(1);
Assert.AreEqual(4, parms.DecompositionBitCount);
Assert.AreEqual(3.19, parms.NoiseStandardDeviation);
Assert.AreEqual(35.06, parms.NoiseMaxDeviation);
Assert.AreEqual("FFFFFFFFC001", parms.CoeffModulus.ToString());
Assert.AreEqual("40", parms.PlainModulus.ToString());
Assert.AreEqual("1x^63 + 1", parms.PolyModulus.ToString());
}
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 SerializeResult TrySerialize(IDictionary <string, object> data, EncryptionParameters encryption = null)
{
var result = new SerializeResult();
var settings = new XmlWriterSettings {
Encoding = new UTF8Encoding(), Indent = true
};
var stream = new MemoryStream();
logger.Debug("Starting to serialize data...");
using (var writer = XmlWriter.Create(stream, settings))
{
writer.WriteStartDocument();
writer.WriteDocType("plist", "-//Apple Computer//DTD PLIST 1.0//EN", "http://www.apple.com/DTDs/PropertyList-1.0.dtd", null);
writer.WriteStartElement(XmlElement.Root);
writer.WriteAttributeString("version", "1.0");
result.Status = WriteDictionary(writer, data);
result.Data = stream;
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
}
logger.Debug($"Finished serialization -> Result: {result.Status}.");
return(result);
}
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 SerializeResult TrySerialize(IDictionary <string, object> data, EncryptionParameters encryption = null)
{
var result = new SerializeResult();
switch (encryption)
{
case PasswordParameters p:
result = SerializePasswordBlock(data, p);
break;
case PublicKeyParameters p:
result = SerializePublicKeyHashBlock(data, p);
break;
default:
result = SerializePlainDataBlock(data, true);
break;
}
if (result.Status == SaveStatus.Success)
{
result.Data = compressor.Compress(result.Data);
}
return(result);
}
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);
}
private LoadStatus TryParseData(Stream data, out EncryptionParameters encryption, out FormatType format, out IDictionary <string, object> rawData, PasswordParameters password = null)
{
var parser = dataParsers.FirstOrDefault(p => p.CanParse(data));
var status = LoadStatus.NotSupported;
encryption = default(EncryptionParameters);
format = default(FormatType);
rawData = default(Dictionary <string, object>);
if (parser != null)
{
var result = parser.TryParse(data, password);
encryption = result.Encryption;
format = result.Format;
rawData = result.RawData;
status = result.Status;
logger.Info($"Tried to parse data from '{data}' using {parser.GetType().Name} -> Result: {status}.");
}
else
{
logger.Warn($"No data parser found which can parse '{data}'!");
}
return(status);
}
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 TestEncryptFileWithBackupFileInfoAndWipeNullArguments()
{
string sourceFilePath = _davidCopperfieldTxtPath;
string destinationFilePath = Path.Combine(Path.GetDirectoryName(sourceFilePath), "David Copperfield-txt.axx");
IDataStore sourceFileInfo = New <IDataStore>(sourceFilePath);
IDataStore destinationFileInfo = New <IDataStore>(destinationFilePath);
using (FileLock destinationFileLock = New <FileLocker>().Acquire(destinationFileInfo))
{
IDataStore nullFileInfo = null;
FileLock nullFileLock = null;
EncryptionParameters nullEncryptionParameters = null;
EncryptionParameters encryptionParameters = new EncryptionParameters(Guid.Empty, Passphrase.Empty);
ProgressContext progress = new ProgressContext();
ProgressContext nullProgress = null;
Assert.ThrowsAsync <ArgumentNullException>((async() => { await New <AxCryptFile>().EncryptFileWithBackupAndWipeAsync(nullFileInfo, destinationFileLock, encryptionParameters, progress); }));
Assert.ThrowsAsync <ArgumentNullException>((async() => { await New <AxCryptFile>().EncryptFileWithBackupAndWipeAsync(sourceFileInfo, nullFileLock, encryptionParameters, progress); }));
Assert.ThrowsAsync <ArgumentNullException>((async() => { await New <AxCryptFile>().EncryptFileWithBackupAndWipeAsync(sourceFileInfo, destinationFileLock, nullEncryptionParameters, progress); }));
Assert.ThrowsAsync <ArgumentNullException>((async() => { await New <AxCryptFile>().EncryptFileWithBackupAndWipeAsync(sourceFileInfo, destinationFileLock, encryptionParameters, nullProgress); }));
}
}
public void KeyStepTest()
{
EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
{
PolyModulusDegree = 64,
CoeffModulus = new List <SmallModulus>()
{
DefaultParams.SmallMods60Bit(0)
}
};
SEALContext context = SEALContext.Create(parms);
KeyGenerator keygen = new KeyGenerator(context);
GaloisKeys keys = keygen.GaloisKeys(decompositionBitCount: 15, steps: new int[] { 1, 2, 3 });
Assert.IsNotNull(keys);
Assert.AreEqual(15, keys.DecompositionBitCount);
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));
}
