/// <summary> /// Encrypts a zero plaintext with the secret key and stores the result in /// destination. /// </summary> /// <remarks> /// The encryption parameters for the resulting ciphertext correspond to the /// highest (data) level in the modulus switching chain. Dynamic memory /// allocations in the process are allocated from the memory pool pointed to /// by the given MemoryPoolHandle. /// /// Half of the polynomials in relinearization keys are randomly generated /// and are replaced with the seed used to compress output size. The output /// is in binary format and not human-readable. The output stream must have /// the "binary" flag set. /// </remarks> /// <param name="stream">The stream to save the Ciphertext to</param> /// <param name="comprMode">The desired compression mode</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory /// pool</param> /// <exception cref="ArgumentNullException">if stream is null</exception> /// <exception cref="InvalidOperationException">if a secret key is not /// set</exception> /// <exception cref="ArgumentException">if the stream is closed or does not /// support writing</exception> /// <exception cref="IOException">if I/O operations failed</exception> /// <exception cref="InvalidOperationException">if compression mode is not /// supported, or if compression failed</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public long EncryptZeroSymmetricSave( Stream stream, ComprModeType?comprMode = null, MemoryPoolHandle pool = null) { if (null == stream) { throw new ArgumentNullException(nameof(stream)); } comprMode = comprMode ?? Serialization.ComprModeDefault; if (!Serialization.IsSupportedComprMode(comprMode.Value)) { throw new InvalidOperationException("Unsupported compression mode"); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; using (Ciphertext destination = new Ciphertext(pool)) { NativeMethods.Encryptor_EncryptZeroSymmetric2( NativePtr, true, destination.NativePtr, poolHandle); return(destination.Save(stream, comprMode)); } }
/// <summary> /// Encrypts a zero plaintext with the public key and returns the ciphertext /// as a serializable object. /// </summary> /// <remarks> /// <para> /// Encrypts a zero plaintext with the public key and returns the ciphertext /// as a serializable object. /// </para> /// <para> /// The encryption parameters for the resulting ciphertext correspond to the /// highest (data) level in the modulus switching chain. Dynamic memory /// allocations in the process are allocated from the memory pool pointed to /// by the given MemoryPoolHandle. /// </para> /// </remarks> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory /// pool</param> /// <exception cref="InvalidOperationException">if a public key is not /// set</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Serializable <Ciphertext> EncryptZero(MemoryPoolHandle pool = null) { Ciphertext destination = new Ciphertext(); EncryptZero(destination, pool); return(new Serializable <Ciphertext>(destination)); }
/// <summary> /// Loads a RelinKeys from an input stream overwriting the current RelinKeys. /// No checking of the validity of the RelinKeys data against encryption /// parameters is performed. This function should not be used unless the /// RelinKeys comes from a fully trusted source. /// </summary> /// <param name="stream">The stream to load the RelinKeys from</param> /// <exception cref="ArgumentNullException">if stream is null</exception> /// <exception cref="ArgumentException">if valid RelinKeys could not be read /// from stream</exception> public void UnsafeLoad(Stream stream) { if (null == stream) { throw new ArgumentNullException(nameof(stream)); } try { // Read the ParmsId ParmsId parmsId = new ParmsId(); parmsId.Load(stream); ParmsId = parmsId; using (BinaryReader reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true)) { // Read the decomposition bit count int dbc = reader.ReadInt32(); DecompositionBitCount = dbc; // Read the size ulong size = reader.ReadUInt64(); // Clear current data and reserve new size NativeMethods.RelinKeys_ClearDataAndReserve(NativePtr, size); // Read all lists for (ulong i = 0; i < size; i++) { // Read size of second list ulong keySize = reader.ReadUInt64(); List <Ciphertext> ciphers = new List <Ciphertext>((int)keySize); // Load all ciphertexts for (ulong j = 0; j < keySize; j++) { Ciphertext cipher = new Ciphertext(); cipher.UnsafeLoad(reader.BaseStream); ciphers.Add(cipher); } IntPtr[] pointers = ciphers.Select(c => { return(c.NativePtr); }).ToArray(); NativeMethods.RelinKeys_AddKeyList(NativePtr, (ulong)pointers.LongLength, pointers); } } } catch (EndOfStreamException ex) { throw new ArgumentException("Stream ended unexpectedly", ex); } catch (IOException ex) { throw new ArgumentException("Error reading keys", ex); } }
/// <summary> /// Copies a given ciphertext to the current one. /// </summary> /// /// <param name="assign">The ciphertext to copy from</param> /// <exception cref="ArgumentNullException">if assign is null</exception> public void Set(Ciphertext assign) { if (null == assign) { throw new ArgumentNullException(nameof(assign)); } NativeMethods.Ciphertext_Set(NativePtr, assign.NativePtr); }
/// <summary> /// Constructs a new ciphertext by copying a given one. /// </summary> /// <param name="copy">The ciphertext to copy from</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if either copy or pool are null</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Ciphertext(Ciphertext copy, MemoryPoolHandle pool) : this(pool) { if (null == copy) { throw new ArgumentNullException(nameof(copy)); } Set(copy); }
/// <summary> /// Encrypts a zero plaintext with the secret key and returns the ciphertext /// as a serializable object. /// </summary> /// <remarks> /// <para> /// Encrypts a zero plaintext with the secret key and returns the ciphertext /// as a serializable object. /// </para> /// <para> /// Half of the ciphertext data is pseudo-randomly generated from a seed to /// reduce the object size. The resulting serializable object cannot be used /// directly and is meant to be serialized for the size reduction to have an /// impact. /// </para> /// <para> /// The encryption parameters for the resulting ciphertext correspond to the /// highest (data) level in the modulus switching chain. Dynamic memory /// allocations in the process are allocated from the memory pool pointed to /// by the given MemoryPoolHandle. /// </para> /// </remarks> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory /// pool</param> /// <exception cref="InvalidOperationException">if a secret key is not /// set</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Serializable <Ciphertext> EncryptZeroSymmetric(MemoryPoolHandle pool = null) { IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; Ciphertext destination = new Ciphertext(); NativeMethods.Encryptor_EncryptZeroSymmetric2( NativePtr, true, destination.NativePtr, poolHandle); return(new Serializable <Ciphertext>(destination)); }
/// <summary> /// Computes the invariant noise budget (in bits) of a ciphertext. The invariant noise /// budget measures the amount of room there is for the noise to grow while ensuring /// correct decryptions. Dynamic memory allocations in the process are allocated from /// the memory pool pointed to by the given MemoryPoolHandle. This function works only /// with the BFV scheme. /// </summary> /// <remarks> /// <para> /// Invariant Noise Budget /// The invariant noise polynomial of a ciphertext is a rational coefficient polynomial, /// such that a ciphertext decrypts correctly as long as the coefficients of the invariant /// noise polynomial are of absolute value less than 1/2. Thus, we call the infinity-norm /// of the invariant noise polynomial the invariant noise, and for correct decryption require /// it to be less than 1/2. If v denotes the invariant noise, we define the invariant noise /// budget as -log2(2v). Thus, the invariant noise budget starts from some initial value, /// which depends on the encryption parameters, and decreases when computations are performed. /// When the budget reaches zero, the ciphertext becomes too noisy to decrypt correctly. /// </para> /// </remarks> /// <param name="encrypted">The ciphertext</param> /// <exception cref="ArgumentNullException">if encrypted is null</exception> /// <exception cref="ArgumentException">if the scheme is not BFV or BGV</exception> /// <exception cref="ArgumentException">if encrypted is not valid for the encryption parameters</exception> /// <exception cref="ArgumentException">if encrypted is in NTT form</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public int InvariantNoiseBudget(Ciphertext encrypted) { if (null == encrypted) { throw new ArgumentNullException(nameof(encrypted)); } NativeMethods.Decryptor_InvariantNoiseBudget(NativePtr, encrypted.NativePtr, out int result); return(result); }
/// <summary> /// Constructs a new ciphertext by copying a given one. /// </summary> /// <param name="copy">The ciphertext to copy from</param> /// <exception cref="ArgumentNullException">if copy is null</exception> public Ciphertext(Ciphertext copy) { if (null == copy) { throw new ArgumentNullException(nameof(copy)); } NativeMethods.Ciphertext_Create2(copy.NativePtr, out IntPtr ptr); NativePtr = ptr; }
/// <summary> /// Encrypts a zero plaintext with the public key and stores the result in /// destination. /// </summary> /// <remarks> /// <para> /// Encrypts a zero plaintext with the public key and stores the result in /// destination. /// </para> /// <para> /// The encryption parameters for the resulting ciphertext correspond to the /// highest (data) level in the modulus switching chain. Dynamic memory allocations /// in the process are allocated from the memory pool pointed to by the given /// MemoryPoolHandle. /// </para> /// </remarks> /// <param name="destination">The ciphertext to overwrite with the encrypted /// plaintext</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if destination is null</exception> /// <exception cref="InvalidOperationException">if a public key is not set</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void EncryptZero(Ciphertext destination, MemoryPoolHandle pool = null) { if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Encryptor_EncryptZero2(NativePtr, destination.NativePtr, poolHandle); }
/// <summary> /// Decrypts a Ciphertext and stores the result in the destination parameter. Dynamic /// memory allocations in the process are allocated from the memory pool pointed to by /// the given MemoryPoolHandle. /// </summary> /// <param name="encrypted">The ciphertext to decrypt</param> /// <param name="destination">The plaintext to overwrite with the decrypted ciphertext</param> /// <exception cref="ArgumentNullException">if either encrypted or destination are null</exception> /// <exception cref="ArgumentException">if encrypted is not valid for the encryption parameters</exception> /// <exception cref="ArgumentException">if encrypted is not in the default NTT form</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Decrypt(Ciphertext encrypted, Plaintext destination) { if (null == encrypted) { throw new ArgumentNullException(nameof(encrypted)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } NativeMethods.Decryptor_Decrypt(NativePtr, encrypted.NativePtr, destination.NativePtr); }
/// <summary> /// Check whether the given ciphertext is valid for a given SEALContext. If the /// given SEALContext is not set, the encryption parameters are invalid, or the /// ciphertext data does not match the SEALContext, this function returns false. /// Otherwise, returns true. /// </summary> /// <param name="ciphertext">The ciphertext to check</param> /// <param name="context">The SEALContext</param> /// <exception cref="ArgumentNullException">if either ciphertext or context is null</exception> public static bool IsValidFor(Ciphertext ciphertext, SEALContext context) { if (null == ciphertext) { throw new ArgumentNullException(nameof(ciphertext)); } if (null == context) { throw new ArgumentNullException(nameof(context)); } NativeMethods.ValCheck_Ciphertext_IsValidFor(ciphertext.NativePtr, context.NativePtr, out bool result); return(result); }
/// <summary> /// Encrypts a zero plaintext with the secret key and stores the result in destination. /// </summary> /// <remarks> /// The encryption parameters for the resulting ciphertext correspond to the /// highest (data) level in the modulus switching chain. Dynamic memory allocations in /// the process are allocated from the memory pool pointed to by the given MemoryPoolHandle. /// /// Half of the polynomials in relinearization keys are randomly generated /// and are replaced with the seed used to compress output size. The output /// is in binary format and not human-readable. The output stream must have /// the "binary" flag set. /// </remarks> /// <param name="stream">The stream to save the Ciphertext to</param> /// <param name="comprMode">The desired compression mode</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if stream is null</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public long EncryptZeroSymmetricSave(Stream stream, ComprModeType?comprMode = null, MemoryPoolHandle pool = null) { if (null == stream) { throw new ArgumentNullException(nameof(stream)); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; using (Ciphertext destination = new Ciphertext(pool)) { NativeMethods.Encryptor_EncryptZeroSymmetric2(NativePtr, true, destination.NativePtr, poolHandle); return(destination.Save(stream, comprMode)); } }
/// <summary> /// Encrypts a zero plaintext with the secret key and stores the result in destination. /// </summary> /// <remarks> /// The encryption parameters for the resulting ciphertext correspond to the given /// parms_id. Dynamic memory allocations in the process are allocated from the memory /// pool pointed to by the given MemoryPoolHandle. /// </remarks> /// <param name="parmsId">The ParmsId for the resulting ciphertext</param> /// <param name="destination">The ciphertext to overwrite with the encrypted plaintext</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if either parmsId or destination are null</exception> /// <exception cref="ArgumentException">if parmsId is not valid for the encryption parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void EncryptZeroSymmetric(ParmsId parmsId, Ciphertext destination, MemoryPoolHandle pool = null) { if (null == parmsId) { throw new ArgumentNullException(nameof(parmsId)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Encryptor_EncryptZeroSymmetric1(NativePtr, parmsId.Block, false, destination.NativePtr, poolHandle); }
/// <summary> /// Encrypts a plaintext with the secret key and stores the result in destination. /// </summary> /// <remarks> /// The encryption parameters for the resulting ciphertext correspond to: /// 1) in BFV, the highest (data) level in the modulus switching chain, /// 2) in CKKS, the encryption parameters of the plaintext. /// Dynamic memory allocations in the process are allocated from the memory /// pool pointed to by the given MemoryPoolHandle. /// </remarks> /// <param name="plain">The plaintext to encrypt</param> /// <param name="destination">The ciphertext to overwrite with the encrypted plaintext</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if either plain or destination are null</exception> /// <exception cref="ArgumentException">if plain is not valid for the encryption parameters</exception> /// <exception cref="ArgumentException">if plain is not in default NTT form</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void EncryptSymmetric(Plaintext plain, Ciphertext destination, MemoryPoolHandle pool = null) { if (null == plain) { throw new ArgumentNullException(nameof(plain)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Encryptor_EncryptSymmetric(NativePtr, plain.NativePtr, false, destination.NativePtr, poolHandle); }
/// <summary> /// Encrypts a zero plaintext with the secret key and returns the ciphertext /// as a serializable object. /// </summary> /// <remarks> /// <para> /// Encrypts a zero plaintext with the secret key and returns the ciphertext /// as a serializable object. /// </para> /// <para> /// Half of the ciphertext data is pseudo-randomly generated from a seed to /// reduce the object size. The resulting serializable object cannot be used /// directly and is meant to be serialized for the size reduction to have an /// impact. /// </para> /// <para> /// The encryption parameters for the resulting ciphertext correspond to /// the given ParmsId. Dynamic memory allocations in the process are allocated /// from the memory pool pointed to by the given MemoryPoolHandle. /// </para> /// </remarks> /// <param name="parmsId">The ParmsId for the resulting ciphertext</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory /// pool</param> /// <exception cref="ArgumentNullException">if parmsId is null</exception> /// <exception cref="InvalidOperationException">if a secret key is not /// set</exception> /// <exception cref="ArgumentException">if parmsId is not valid for the /// encryption parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Serializable <Ciphertext> EncryptZeroSymmetric( ParmsId parmsId, MemoryPoolHandle pool = null) { if (null == parmsId) { throw new ArgumentNullException(nameof(parmsId)); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; Ciphertext destination = new Ciphertext(); NativeMethods.Encryptor_EncryptZeroSymmetric1( NativePtr, parmsId.Block, true, destination.NativePtr, poolHandle); return(new Serializable <Ciphertext>(destination)); }
/// <summary> /// Encrypts a plaintext with the secret key and returns the ciphertext as /// a serializable object. /// </summary> /// <remarks> /// <para> /// Encrypts a plaintext with the secret key and returns the ciphertext as /// a serializable object. /// </para> /// <para> /// Half of the ciphertext data is pseudo-randomly generated from a seed to /// reduce the object size. The resulting serializable object cannot be used /// directly and is meant to be serialized for the size reduction to have an /// impact. /// </para> /// <para> /// The encryption parameters for the resulting ciphertext correspond to: /// 1) in BFV, the highest (data) level in the modulus switching chain, /// 2) in CKKS, the encryption parameters of the plaintext. /// Dynamic memory allocations in the process are allocated from the memory /// pool pointed to by the given MemoryPoolHandle. /// </para> /// </remarks> /// <param name="plain">The plaintext to encrypt</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if plain is null</exception> /// <exception cref="InvalidOperationException">if a secret key is not set</exception> /// <exception cref="ArgumentException">if plain is not valid for the encryption /// parameters</exception> /// <exception cref="ArgumentException">if plain is not in default NTT /// form</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Serializable <Ciphertext> EncryptSymmetric( Plaintext plain, MemoryPoolHandle pool = null) { if (null == plain) { throw new ArgumentNullException(nameof(plain)); } IntPtr poolHandle = pool?.NativePtr ?? IntPtr.Zero; Ciphertext destination = new Ciphertext(); NativeMethods.Encryptor_EncryptSymmetric( NativePtr, plain.NativePtr, true, destination.NativePtr, poolHandle); return(new Serializable <Ciphertext>(destination)); }