/// <summary>
/// Generates and saves Galois keys to an output stream.
/// </summary>
/// <remarks>
/// This function creates specific Galois keys that can be used to apply
/// specific Galois automorphisms on encrypted data. The user needs to give
/// as input a vector of desired Galois rotation step counts, where negative
/// step counts correspond to rotations to the right and positive step counts
/// correspond to rotations to the left. A step count of zero can be used to
/// indicate a column rotation in the BFV scheme complex conjugation in the
/// CKKS scheme.
///
/// 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="steps">The rotation step counts for which to generate keys</param>
/// <param name="stream">The stream to save the Galois keys to</param>
/// <param name="comprMode">The desired compression mode</param>
/// <exception cref="ArgumentNullException">if steps is null</exception>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV</exception>
/// <exception cref="ArgumentException">if the step counts are not valid</exception>
public long GaloisKeysSave(IEnumerable <int> steps, Stream stream, ComprModeType?comprMode = null)
{
if (null == steps)
{
throw new ArgumentNullException(nameof(steps));
}
try
{
int[] stepsArr = steps.ToArray();
NativeMethods.KeyGenerator_GaloisKeysFromSteps(NativePtr,
(ulong)stepsArr.Length, stepsArr, true, out IntPtr galoisKeysPtr);
using (GaloisKeys galoisKeys = new GaloisKeys(galoisKeysPtr))
{
return(galoisKeys.Save(stream, comprMode));
}
}
catch (COMException ex)
{
if ((uint)ex.HResult == NativeMethods.Errors.HRInvalidOperation)
{
throw new InvalidOperationException("Encryption parameters do not support batching and scheme is SchemeType.BFV", ex);
}
throw new InvalidOperationException("Unexpected native library error", ex);
}
}
/// <summary>
/// Generates and saves Galois keys to an output stream.
/// </summary>
/// <remarks>
/// This function creates specific Galois keys that can be used to apply
/// specific Galois automorphisms on encrypted data. The user needs to give
/// as input a vector of desired Galois rotation step counts, where negative
/// step counts correspond to rotations to the right and positive step counts
/// correspond to rotations to the left. A step count of zero can be used to
/// indicate a column rotation in the BFV scheme complex conjugation in the
/// CKKS scheme.
///
/// 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="steps">The rotation step counts for which to generate keys</param>
/// <param name="stream">The stream to save the Galois keys to</param>
/// <param name="comprMode">The desired compression mode</param>
/// <exception cref="ArgumentNullException">if steps or stream is null</exception>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV</exception>
/// <exception cref="InvalidOperationException">if the encryption
/// parameters do not support keyswitching</exception>
/// <exception cref="ArgumentException">if the step counts are not valid</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>
public long GaloisKeysSave(IEnumerable <int> steps, Stream stream, ComprModeType?comprMode = null)
{
if (null == stream)
{
throw new ArgumentNullException(nameof(stream));
}
if (null == steps)
{
throw new ArgumentNullException(nameof(steps));
}
if (!UsingKeyswitching())
{
throw new InvalidOperationException("Encryption parameters do not support keyswitching");
}
comprMode = comprMode ?? Serialization.ComprModeDefault;
if (!Serialization.IsSupportedComprMode(comprMode.Value))
{
throw new InvalidOperationException("Unsupported compression mode");
}
int[] stepsArr = steps.ToArray();
NativeMethods.KeyGenerator_GaloisKeysFromSteps(NativePtr,
(ulong)stepsArr.Length, stepsArr, true, out IntPtr galoisKeysPtr);
using (GaloisKeys galoisKeys = new GaloisKeys(galoisKeysPtr))
{
return(galoisKeys.Save(stream, comprMode));
}
}
/// <summary>
/// Copies a given GaloisKeys instance to the current one.
/// </summary>
///
/// <param name="assign">The GaloisKeys to copy from</param>
/// <exception cref="ArgumentNullException">if assign is null</exception>
public void Set(GaloisKeys assign)
{
if (null == assign)
{
throw new ArgumentNullException(nameof(assign));
}
NativeMethods.GaloisKeys_Set(NativePtr, assign.NativePtr);
}
/// <summary>
/// Generates Galois keys and stores the result in destination.
/// </summary>
/// <remarks>
/// <para>
/// Generates Galois keys and stores the result in destination. Every time
/// this function is called, new Galois keys will be generated.
/// </para>
/// <para>
/// This function creates logarithmically many (in degree of the polynomial
/// modulus) Galois keys that is sufficient to apply any Galois automorphism
/// (e.g., rotations) on encrypted data. Most users will want to use this
/// overload of the function.
/// </para>
/// <para>
/// Precisely it generates 2*log(n)-1 number of Galois keys where n is the
/// degree of the polynomial modulus. When used with batching, these keys
/// support direct left and right rotations of power-of-2 steps of rows in BFV
/// or vectors in CKKS and rotation of columns in BFV or conjugation in CKKS.
/// </para>
/// </remarks>
/// <param name="destination">The Galois keys to overwrite with the generated
/// Galois keys</param>
/// <exception cref="InvalidOperationException">if the encryption
/// parameters do not support keyswitching</exception>
public void CreateGaloisKeys(out GaloisKeys destination)
{
if (!UsingKeyswitching())
{
throw new InvalidOperationException("Encryption parameters do not support keyswitching");
}
NativeMethods.KeyGenerator_CreateGaloisKeysAll(NativePtr, false, out IntPtr galoisKeysPtr);
destination = new GaloisKeys(galoisKeysPtr);
}
/// <summary>
/// Creates a new GaloisKeys instance by copying a given instance.
/// </summary>
/// <param name="copy">The GaloisKeys to copy from</param>
/// <exception cref="ArgumentNullException">if copy is null</exception>
public GaloisKeys(GaloisKeys copy)
{
if (null == copy)
{
throw new ArgumentNullException(nameof(copy));
}
NativeMethods.GaloisKeys_Create(copy.NativePtr, out IntPtr ptr);
NativePtr = ptr;
}
/// <summary>
/// Generates and returns Galois keys as a serializable object.
/// </summary>
/// <remarks>
/// <para>
/// Generates and returns Galois keys as a serializable object. This function
/// creates logarithmically many (in degree of the polynomial modulus) Galois
/// keys that is sufficient to apply any Galois automorphism (e.g. rotations)
/// on encrypted data. Most users will want to use this overload of the function.
/// </para>
/// <para>
/// Half of the key 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>
/// </remarks>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV</exception>
/// <exception cref="InvalidOperationException">if the encryption
/// parameters do not support keyswitching</exception>
public Serializable <GaloisKeys> GaloisKeys()
{
if (!UsingKeyswitching())
{
throw new InvalidOperationException("Encryption parameters do not support keyswitching");
}
NativeMethods.KeyGenerator_GaloisKeysAll(NativePtr, true, out IntPtr galoisKeysPtr);
GaloisKeys galoisKeys = new GaloisKeys(galoisKeysPtr);
return(new Serializable <GaloisKeys>(galoisKeys));
}
/// <summary>
/// Check whether the given GaloisKeys is valid for a given SEALContext. If the
/// given SEALContext is not set, the encryption parameters are invalid, or the
/// GaloisKeys data does not match the SEALContext, this function returns false.
/// Otherwise, returns true.
/// </summary>
/// <param name="galoisKeys">The GaloisKeys to check</param>
/// <param name="context">The SEALContext</param>
/// <exception cref="ArgumentNullException">if either galoisKeys or context is null</exception>
public static bool IsValidFor(GaloisKeys galoisKeys, SEALContext context)
{
if (null == galoisKeys)
{
throw new ArgumentNullException(nameof(galoisKeys));
}
if (null == context)
{
throw new ArgumentNullException(nameof(context));
}
NativeMethods.ValCheck_GaloisKeys_IsValidFor(galoisKeys.NativePtr, context.NativePtr, out bool result);
return(result);
}
/// <summary>
/// Generates Galois keys and stores the result in destination.
/// </summary>
/// <remarks>
/// <para>
/// Generates Galois keys and stores the result in destination. Every time
/// this function is called, new Galois keys will be generated.
/// </para>
/// <para>
/// The user needs to give as input a vector of desired Galois rotation step
/// counts, where negative step counts correspond to rotations to the right
/// and positive step counts correspond to rotations to the left. A step
/// count of zero can be used to indicate a column rotation in the BFV/BGV scheme
/// and complex conjugation in the CKKS scheme.
/// </para>
/// </remarks>
/// <param name="steps">The rotation step counts for which to generate keys</param>
/// <param name="destination">The Galois keys to overwrite with the generated
/// Galois keys</param>
/// <exception cref="ArgumentNullException">if steps is null</exception>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV or SchemeType.BGV</exception>
/// <exception cref="InvalidOperationException">if the encryption
/// parameters do not support keyswitching</exception>
/// <exception cref="ArgumentException">if the step counts are not valid</exception>
public void CreateGaloisKeys(IEnumerable <int> steps, out GaloisKeys destination)
{
if (null == steps)
{
throw new ArgumentNullException(nameof(steps));
}
if (!UsingKeyswitching())
{
throw new InvalidOperationException("Encryption parameters do not support keyswitching");
}
int[] stepsArr = steps.ToArray();
NativeMethods.KeyGenerator_CreateGaloisKeysFromSteps(NativePtr,
(ulong)stepsArr.Length, stepsArr, false, out IntPtr galoisKeysPtr);
destination = new GaloisKeys(galoisKeysPtr);
}
/// <summary>
/// Generates and returns Galois keys as a serializable object.
/// </summary>
/// <remarks>
/// <para>
/// Generates and returns Galois keys as a serializable object. This function
/// creates specific Galois keys that can be used to apply specific Galois
/// automorphisms on encrypted data. The user needs to give as input a vector
/// of desired Galois rotation step counts, where negative step counts
/// correspond to rotations to the right and positive step counts correspond
/// to rotations to the left. A step count of zero can be used to indicate
/// a column rotation in the BFV scheme complex conjugation in the CKKS scheme.
/// </para>
/// <para>
/// Half of the key 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>
/// </remarks>
/// <param name="steps">The rotation step counts for which to generate keys</param>
/// <exception cref="ArgumentNullException">if steps is null</exception>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV</exception>
/// <exception cref="InvalidOperationException">if the encryption
/// parameters do not support keyswitching</exception>
/// <exception cref="ArgumentException">if the step counts are not valid</exception>
public Serializable <GaloisKeys> GaloisKeys(IEnumerable <int> steps)
{
if (null == steps)
{
throw new ArgumentNullException(nameof(steps));
}
if (!UsingKeyswitching())
{
throw new InvalidOperationException("Encryption parameters do not support keyswitching");
}
int[] stepsArr = steps.ToArray();
NativeMethods.KeyGenerator_GaloisKeysFromSteps(NativePtr,
(ulong)stepsArr.Length, stepsArr, true, out IntPtr galoisKeysPtr);
GaloisKeys galoisKeys = new GaloisKeys(galoisKeysPtr);
return(new Serializable <GaloisKeys>(galoisKeys));
}
/// <summary>
/// Generates and saves Galois keys to an output stream.
/// </summary>
/// <remarks>
/// This function creates logarithmically many (in degree of the polynomial modulus)
/// Galois keys that is sufficient to apply any Galois automorphism (e.g. rotations)
/// on encrypted data. Most users will want to use this overload of the function.
///
/// 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 Galois keys to</param>
/// <param name="comprMode">The desired compression mode</param>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV</exception>
public long GaloisKeysSave(Stream stream, ComprModeType?comprMode = null)
{
try
{
NativeMethods.KeyGenerator_GaloisKeysAll(NativePtr, true, out IntPtr galoisKeysPtr);
using (GaloisKeys galoisKeys = new GaloisKeys(galoisKeysPtr))
{
return(galoisKeys.Save(stream, comprMode));
}
}
catch (COMException ex)
{
if ((uint)ex.HResult == NativeMethods.Errors.HRInvalidOperation)
{
throw new InvalidOperationException("Encryption parameters do not support batching and scheme is SchemeType.BFV", ex);
}
throw new InvalidOperationException("Unexpected native library error", ex);
}
}
/// <summary>
/// Generates and saves Galois keys to an output stream.
/// </summary>
/// <remarks>
/// This function creates logarithmically many (in degree of the polynomial modulus)
/// Galois keys that is sufficient to apply any Galois automorphism (e.g. rotations)
/// on encrypted data. Most users will want to use this overload of the function.
///
/// 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 Galois keys to</param>
/// <param name="comprMode">The desired compression mode</param>
/// <exception cref="ArgumentNullException">if stream is null</exception>
/// <exception cref="InvalidOperationException">if the encryption parameters
/// do not support batching and scheme is SchemeType.BFV</exception>
/// <exception cref="InvalidOperationException">if the encryption
/// parameters do not support keyswitching</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>
public long GaloisKeysSave(Stream stream, ComprModeType?comprMode = null)
{
if (null == stream)
{
throw new ArgumentNullException(nameof(stream));
}
if (!UsingKeyswitching())
{
throw new InvalidOperationException("Encryption parameters do not support keyswitching");
}
comprMode = comprMode ?? Serialization.ComprModeDefault;
if (!Serialization.IsSupportedComprMode(comprMode.Value))
{
throw new InvalidOperationException("Unsupported compression mode");
}
NativeMethods.KeyGenerator_GaloisKeysAll(NativePtr, true, out IntPtr galoisKeysPtr);
using (GaloisKeys galoisKeys = new GaloisKeys(galoisKeysPtr))
{
return(galoisKeys.Save(stream, comprMode));
}
}
/// <summary>
/// Creates a new GaloisKeys instance by copying a given instance.
/// </summary>
/// <param name="copy">The GaloisKeys to copy from</param>
/// <exception cref="ArgumentNullException">if copy is null</exception>
public GaloisKeys(GaloisKeys copy)
: base(copy)
{
}
