/// <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> /// Inverse of encode. This function "unbatches" a given plaintext into a matrix /// of integers modulo the plaintext modulus, and stores the result in the destination /// parameter. The input plaintext must have degress less than the polynomial modulus, /// and coefficients less than the plaintext modulus, i.e. it must be a valid plaintext /// for the encryption parameters. Dynamic memory allocations in the process are /// allocated from the memory pool pointed to by the given MemoryPoolHandle. /// </summary> /// <param name="plain">The plaintext polynomial to unbatch</param> /// <param name="destination">The matrix to be overwritten with the values in the slots</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 in NTT form</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Decode(Plaintext plain, ICollection <long> destination, MemoryPoolHandle pool = null) { if (null == plain) { throw new ArgumentNullException(nameof(plain)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; ulong count = 0; NativeMethods.BatchEncoder_Decode(NativePtr, plain.NativePtr, ref count, (long[])null, poolPtr); long[] dest = new long[count]; NativeMethods.BatchEncoder_Decode(NativePtr, plain.NativePtr, ref count, dest, poolPtr); destination.Clear(); for (ulong i = 0; i < count; i++) { destination.Add(dest[i]); } }
/// <summary> /// Constructs an empty ciphertext allocating no memory. /// </summary> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="System.ArgumentException">if pool is uninitialized</exception> public Ciphertext(MemoryPoolHandle pool) { IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Ciphertext_Create1(poolPtr, out IntPtr ptr); NativePtr = ptr; }
/// <summary> /// Returns a MemoryPoolHandle pointing to a pool selected by internal logic /// in a derived class. /// </summary> public MemoryPoolHandle GetPool() { NativeMethods.MMProf_GetPool(NativePtr, out IntPtr pool); MemoryPoolHandle handle = new MemoryPoolHandle(pool); return(handle); }
/// <summary> /// Encodes a vector of double-precision floating-point complex numbers into a plaintext /// polynomial. /// </summary> /// <remark> /// Append zeros if vector size is less than N/2. Dynamic memory allocations in the process /// are allocated from the memory pool pointed to by the given MemoryPoolHandle. /// </remark> /// <param name="values">The enumeration of double-precision complex numbers /// to encode</param> /// <param name="parmsId">parmsId determining the encryption parameters to be used /// by the result plaintext</param> /// <param name="scale">Scaling parameter defining encoding precision</param> /// <param name="destination">The plaintext polynomial to overwrite with the result</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if either values, parmsId or destionation are null.</exception> /// <exception cref="ArgumentException">if values has invalid size</exception> /// <exception cref="ArgumentException">if parmsId is not valid for the encryption /// parameters </exception> /// <exception cref="ArgumentException">if scale is not strictly positive</exception> /// <exception cref="ArgumentException">if encoding is too large for the encryption /// parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Encode(IEnumerable <Complex> values, ParmsId parmsId, double scale, Plaintext destination, MemoryPoolHandle pool = null) { if (null == values) { throw new ArgumentNullException(nameof(values)); } if (null == parmsId) { throw new ArgumentNullException(nameof(parmsId)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; double[] valuearray = new double[values.LongCount() * 2]; ulong idx = 0; foreach (Complex complex in values) { valuearray[idx++] = complex.Real; valuearray[idx++] = complex.Imaginary; } // Note that we should pass values.Count as the length instead of valuearray.Length, // since we are using two doubles in the array per element. NativeMethods.CKKSEncoder_EncodeComplex(NativePtr, (ulong)values.LongCount(), valuearray, parmsId.Block, scale, destination.NativePtr, poolPtr); }
/// <summary> /// Decodes a plaintext polynomial into double-precision floating-point complex numbers. /// </summary> /// <remark> /// Dynamic memory allocations in the process are allocated from the memory pool pointed to /// by the given MemoryPoolHandle. /// </remark> /// <param name="plain">plain The plaintext to decode</param> /// <param name="destination">The collection to be overwritten with the values in the slots</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 in NTT form or is invalid for the /// encryption parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Decode(Plaintext plain, ICollection <Complex> destination, MemoryPoolHandle pool = null) { if (null == plain) { throw new ArgumentNullException(nameof(plain)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; ulong destCount = 0; // Find out what is the actual result size NativeMethods.CKKSEncoder_DecodeComplex(NativePtr, plain.NativePtr, ref destCount, null, poolPtr); // Now get the result double[] destarray = new double[destCount * 2]; NativeMethods.CKKSEncoder_DecodeComplex(NativePtr, plain.NativePtr, ref destCount, destarray, poolPtr); // Transfer result to actual destination destination.Clear(); for (ulong i = 0; i < destCount; i++) { destination.Add(new Complex(destarray[i * 2], destarray[i * 2 + 1])); } }
/// <summary> /// Returns a MemoryPoolHandle pointing to a new thread-safe memory pool. /// </summary> /// <param name="clearOnDestruction">Indicates whether the memory pool data /// should be cleared when destroyed.This can be important when memory pools /// are used to store private data.</param> public static MemoryPoolHandle New(bool clearOnDestruction = false) { NativeMethods.MemoryPoolHandle_New(clearOnDestruction, out IntPtr handlePtr); MemoryPoolHandle handle = new MemoryPoolHandle(handlePtr); return(handle); }
/// <summary> /// Returns a MemoryPoolHandle pointing to the thread-local memory pool. Note /// that the thread-local memory pool cannot be used to communicate across /// different threads. /// </summary> public static MemoryPoolHandle ThreadLocal() { NativeMethods.MemoryPoolHandle_ThreadLocal(out IntPtr handlePtr); MemoryPoolHandle handle = new MemoryPoolHandle(handlePtr); return(handle); }
/// <summary> /// Constructs a plaintext representing a constant polynomial 0. The /// coefficient count of the polynomial is set to the given value. The /// capacity is set to the same value. /// </summary> /// <param name="coeffCount">The number of (zeroed) coefficients in the /// plaintext polynomial</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentException">if coeffCount is negative</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Plaintext(ulong coeffCount, MemoryPoolHandle pool = null) { IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Plaintext_Create(coeffCount, poolPtr, out IntPtr ptr); NativePtr = ptr; }
/// <summary> /// Constructs an empty plaintext allocating no memory. /// </summary> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Plaintext(MemoryPoolHandle pool = null) { IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Plaintext_Create1(poolPtr, out IntPtr ptr); NativePtr = ptr; }
/// <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> /// Constructs a new plaintext by copying a given one. /// </summary> /// <param name="copy">The plaintext 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 Plaintext(Plaintext copy, MemoryPoolHandle pool) : this(pool) { if (null == copy) { throw new ArgumentNullException(nameof(copy)); } Set(copy); }
/// <summary> /// Overwrites the MemoryPoolHandle instance with the specified instance. As /// a result, the current MemoryPoolHandle will point to the same underlying /// memory pool as the assigned instance. /// </summary> /// <param name="assign">The MemoryPoolHandle instance to assign to the current /// instance</param> /// <exception cref="ArgumentNullException">if assign is null.</exception> public void Set(MemoryPoolHandle assign) { if (null == assign) { throw new ArgumentNullException(nameof(assign)); } NativeMethods.MemoryPoolHandle_Set(NativePtr, assign.NativePtr); }
/// <summary> /// Encodes a double-precision complex number into a plaintext polynomial. The /// encryption parameters used are the top level parameters for the given context. /// Dynamic memory allocations in the process are allocated from the memory pool /// pointed to by the given MemoryPoolHandle. /// </summary> /// <param name="value">The double-precision complex number to encode</param> /// <param name="scale">Scaling parameter defining encoding precision</param> /// <param name="destination">The plaintext polynomial to overwrite with the result</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if destination is null</exception> /// <exception cref="ArgumentException">if scale is not strictly positive</exception> /// <exception cref="ArgumentException">if encoding is too large for the encryption /// parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Encode(Complex value, double scale, Plaintext destination, MemoryPoolHandle pool = null) { if (null == destination) { throw new ArgumentNullException(nameof(destination)); } Encode(value, context_.FirstParmsId, scale, destination, pool); }
/// <summary> /// Creates a copy of a given MemoryPoolHandle. As a result, the created /// MemoryPoolHandle will point to the same underlying memory pool as the /// copied instance. /// </summary> /// <param name="copy">The MemoryPoolHandle to copy from.</param> /// <exception cref="ArgumentNullException">if copy is null.</exception> public MemoryPoolHandle(MemoryPoolHandle copy) { if (null == copy) { throw new ArgumentNullException(nameof(copy)); } NativeMethods.MemoryPoolHandle_Create(copy.NativePtr, out IntPtr handlePtr); NativePtr = handlePtr; }
/// <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> /// Inverse of encode. This function "unbatches" a given plaintext in-place into /// a matrix of integers modulo the plaintext modulus. The input plaintext must have /// degress less than the polynomial modulus, and coefficients less than the plaintext /// modulus, i.e. it must be a valid plaintext for the encryption parameters. Dynamic /// memory allocations in the process are allocated from the memory pool pointed to by /// the given MemoryPoolHandle. /// </summary> /// <param name="plain">The plaintext polynomial to unbatch</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if plain is null</exception> /// <exception cref="ArgumentException">if plain is not valid for the encryption parameters</exception> /// <exception cref="ArgumentException">if plain is in NTT form</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Decode(Plaintext plain, MemoryPoolHandle pool = null) { if (null == plain) { throw new ArgumentNullException(nameof(plain)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.BatchEncoder_Decode(NativePtr, plain.NativePtr, poolPtr); }
/// <summary> /// Compares MemoryPoolHandles. This function returns whether the current /// MemoryPoolHandle points to the same memory pool as a given MemoryPoolHandle. /// </summary> /// <param name="obj">Object to compare to.</param> public override bool Equals(object obj) { MemoryPoolHandle other = obj as MemoryPoolHandle; if (null == other) { return(false); } NativeMethods.MemoryPoolHandle_Equals(NativePtr, other.NativePtr, out bool result); return(result); }
/// <summary> /// Constructs a plaintext from a given hexadecimal string describing the /// plaintext polynomial. /// </summary> /// <remarks> /// The string description of the polynomial must adhere to the format /// returned by ToString(), which is of the form "7FFx^3 + 1x^1 + 3" /// and summarized by the following /// rules: /// 1. Terms are listed in order of strictly decreasing exponent /// 2. Coefficient values are non-negative and in hexadecimal format (upper /// and lower case letters are both supported) /// 3. Exponents are positive and in decimal format /// 4. Zero coefficient terms (including the constant term) may be (but do /// not have to be) omitted /// 5. Term with the exponent value of one must be exactly written as x^1 /// 6. Term with the exponent value of zero (the constant term) must be written /// as just a hexadecimal number without exponent /// 7. Terms must be separated by exactly [space]+[space] and minus is not /// allowed /// 8. Other than the +, no other terms should have whitespace /// </remarks> /// <param name="hexPoly">The formatted polynomial string specifying the plaintext /// polynomial</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if hexPoly is null</exception> /// <exception cref="ArgumentException">if hexPoly does not adhere to the expected /// format</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Plaintext(string hexPoly, MemoryPoolHandle pool = null) { if (null == hexPoly) { throw new ArgumentNullException(nameof(hexPoly)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Plaintext_Create4(hexPoly, poolPtr, out IntPtr ptr); NativePtr = ptr; }
/// <summary> /// Constructs an empty ciphertext with capacity 2. In addition to the /// capacity, the allocation size is determined by the highest-level /// parameters associated to the given SEALContext. /// </summary> /// <param name="context">The SEALContext</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if context is null</exception> /// <exception cref="ArgumentException">if the context is not set or encryption /// parameters are not valid</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Ciphertext(SEALContext context, MemoryPoolHandle pool = null) { if (null == context) { throw new ArgumentNullException(nameof(context)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Ciphertext_Create3(context.NativePtr, poolPtr, out IntPtr ptr); NativePtr = ptr; }
/// <summary> /// Create a new instance of MMProfFixed /// </summary> /// <param name="pool">Fixed memory pool handle to use</param> /// <exception cref="ArgumentNullException">if pool is null</exception> public MMProfFixed(MemoryPoolHandle pool) { if (null == pool) { throw new ArgumentNullException(nameof(pool)); } // Create a copy of MemoryPoolHandle, as the profile will take ownership // of the pointer and will attempt to delete it when destroyed. NativeMethods.MemoryPoolHandle_Create(pool.NativePtr, out IntPtr poolCopy); NativeMethods.MMProf_CreateFixed(poolCopy, out IntPtr profile); NativePtr = profile; }
/// <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 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 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)); }
/// <summary> /// Encodes a double-precision complex number into a plaintext polynomial. Dynamic /// memory allocations in the process are allocated from the memory pool pointed to /// by the given MemoryPoolHandle. /// </summary> /// <param name="value">The double-precision complex number to encode</param> /// <param name="parmsId">parmsId determining the encryption parameters to be used /// by the result plaintext</param> /// <param name="scale">Scaling parameter defining encoding precision</param> /// <param name="destination">The plaintext polynomial to overwrite with the result</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 scale is not strictly positive</exception> /// <exception cref="ArgumentException">if encoding is too large for the encryption /// parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Encode(Complex value, ParmsId parmsId, double scale, Plaintext destination, MemoryPoolHandle pool = null) { if (null == parmsId) { throw new ArgumentNullException(nameof(parmsId)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.CKKSEncoder_Encode(NativePtr, value.Real, value.Imaginary, parmsId.Block, scale, destination.NativePtr, poolPtr); }
/// <summary> /// Constructs an empty ciphertext with given capacity. In addition to /// the capacity, the allocation size is determined by the given /// encryption parameters. /// </summary> /// <param name="context">The SEALContext</param> /// <param name="parmsId">The ParmsId corresponding to the encryption /// parameters to be used</param> /// <param name="sizeCapacity">The capacity</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if either context or parmsId are null</exception> /// <exception cref="ArgumentException">if the context is not set or encryption /// parameters are not valid</exception> /// <exception cref="ArgumentException">if parmsId is not valid for the encryption /// parameters</exception> /// <exception cref="ArgumentException">if sizeCapacity is less than 2 or too large</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public Ciphertext(SEALContext context, ParmsId parmsId, ulong sizeCapacity, MemoryPoolHandle pool = null) { if (null == context) { throw new ArgumentNullException(nameof(context)); } if (null == parmsId) { throw new ArgumentNullException(nameof(parmsId)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; NativeMethods.Ciphertext_Create5(context.NativePtr, parmsId.Block, sizeCapacity, poolPtr, out IntPtr ptr); NativePtr = ptr; }
/// <summary> /// Encodes double-precision floating-point real numbers into a plaintext /// polynomial. Dynamic memory allocations in the process are allocated from the /// memory pool pointed to by the given MemoryPoolHandle. /// </summary> /// <param name="values">The enumeration of double-precision floating-point numbers /// to encode</param> /// <param name="parmsId">parmsId determining the encryption parameters to be used /// by the result plaintext</param> /// <param name="scale">Scaling parameter defining encoding precision</param> /// <param name="destination">The plaintext polynomial to overwrite with the result</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentNullException">if either values, parmsId or destionation are null.</exception> /// <exception cref="ArgumentException">if values has invalid size</exception> /// <exception cref="ArgumentException">if parmsId is not valid for the encryption /// parameters </exception> /// <exception cref="ArgumentException">if scale is not strictly positive</exception> /// <exception cref="ArgumentException">if encoding is too large for the encryption /// parameters</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> public void Encode(IEnumerable <double> values, ParmsId parmsId, double scale, Plaintext destination, MemoryPoolHandle pool = null) { if (null == values) { throw new ArgumentNullException(nameof(values)); } if (null == parmsId) { throw new ArgumentNullException(nameof(parmsId)); } if (null == destination) { throw new ArgumentNullException(nameof(destination)); } IntPtr poolPtr = pool?.NativePtr ?? IntPtr.Zero; double[] valuearray = values.ToArray(); NativeMethods.CKKSEncoder_EncodeDouble(NativePtr, (ulong)valuearray.LongLength, valuearray, parmsId.Block, scale, destination.NativePtr, poolPtr); }
/// <summary> /// Constructs a plaintext representing a polynomial with given coefficient values. /// </summary> /// <remarks> /// Constructs a plaintext representing a polynomial with given coefficient values. /// The coefficient count of the polynomial is set to the number of coefficient /// values provided, and the capacity is set to the same value. /// </remarks> /// <param name="coeffs">Desired values of the plaintext coefficients</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentException">if pool is uninitialized</exception> /// <exception cref="ArgumentNullException">if coeffs is null</exception> public Plaintext(IEnumerable <ulong> coeffs, MemoryPoolHandle pool = null) : this(pool) { Set(coeffs); }
/// <summary> /// Constructs a plaintext representing a polynomial with given coefficient values. /// </summary> /// <remarks> /// Constructs a plaintext representing a polynomial with given coefficient values. /// The coefficient count of the polynomial is set to the number of coefficient /// values provided, and the capacity is set to the given value. /// </remarks> /// <param name="coeffs">Desired values of the plaintext coefficients</param> /// <param name="capacity">The capacity</param> /// <param name="pool">The MemoryPoolHandle pointing to a valid memory pool</param> /// <exception cref="ArgumentException">if capacity is less than the size of coeffs</exception> /// <exception cref="ArgumentException">if pool is uninitialized</exception> /// <exception cref="ArgumentNullException">if coeffs is null</exception> public Plaintext(IEnumerable <ulong> coeffs, ulong capacity, MemoryPoolHandle pool = null) : this(capacity, 0, pool) { Set(coeffs); }