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)); }