/// <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>
/// Loads a KSwitchKeys from an input stream overwriting the current KSwitchKeys.
/// </summary>
/// <remarks>
/// Loads a KSwitchKeys from an input stream overwriting the current KSwitchKeys.
/// No checking of the validity of the KSwitchKeys data against encryption
/// parameters is performed. This function should not be used unless the
/// KSwitchKeys comes from a fully trusted source.
/// </remarks>
/// <param name="stream">The stream to load the KSwitchKeys from</param>
/// <exception cref="ArgumentNullException">if stream is null</exception>
/// <exception cref="ArgumentException">if KSwitchKeys 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 size
ulong size = reader.ReadUInt64();
// Clear current data and reserve new size
NativeMethods.KSwitchKeys_ClearDataAndReserve(NativePtr, size);
// Read all lists
for (ulong i = 0; i < size; i++)
{
// Read size of second list
ulong keySize = reader.ReadUInt64();
List <PublicKey> key = new List <PublicKey>(checked ((int)keySize));
// Load all ciphertexts
for (ulong j = 0; j < keySize; j++)
{
PublicKey pkey = new PublicKey();
pkey.UnsafeLoad(reader.BaseStream);
key.Add(pkey);
}
IntPtr[] pointers = key.Select(c =>
{
return(c.NativePtr);
}).ToArray();
NativeMethods.KSwitchKeys_AddKeyList(NativePtr, (ulong)pointers.LongLength, pointers);
}
}
}
catch (EndOfStreamException ex)
{
throw new ArgumentException("Stream ended unexpectedly", ex);
}
catch (IOException ex)
{
throw new ArgumentException("Could not load KSwitchKeys", ex);
}
}
/// <summary>
/// Loads a ciphertext from an input stream overwriting the current ciphertext.
/// No checking of the validity of the ciphertext data against encryption
/// parameters is performed. This function should not be used unless the
/// ciphertext comes from a fully trusted source.
/// </summary>
/// <param name="stream">The stream to load the ciphertext from</param>
/// <exception cref="ArgumentNullException">if stream is null</exception>
/// <exception cref="ArgumentException">if a valid ciphertext could not be read from stream</exception>
public void UnsafeLoad(Stream stream)
{
if (null == stream)
{
throw new ArgumentNullException(nameof(stream));
}
try
{
using (BinaryReader reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true))
{
ParmsId parms = new ParmsId();
parms.Load(reader.BaseStream);
ParmsId = parms;
bool isNTT = reader.ReadBoolean();
ulong size = reader.ReadUInt64();
ulong polyModulusDegree = reader.ReadUInt64();
ulong coeffModCount = reader.ReadUInt64();
ulong ulongCount = size * polyModulusDegree * coeffModCount;
IsNTTForm = isNTT;
Resize(size, polyModulusDegree, coeffModCount);
for (ulong i = 0; i < ulongCount; i++)
{
this[i] = reader.ReadUInt64();
}
}
}
catch (EndOfStreamException ex)
{
throw new ArgumentException("Stream ended unexpectedly", ex);
}
catch (IOException ex)
{
throw new ArgumentException("Error reading ciphertext", ex);
}
}
/// <summary>
/// Loads a plaintext from an input stream overwriting the current plaintext.
/// No checking of the validity of the plaintext data against encryption
/// parameters is performed. This function should not be used unless the
/// plaintext comes from a fully trusted source.
/// </summary>
/// <param name="stream">The stream to load the plaintext from</param>
/// <exception cref="ArgumentNullException">if stream is null</exception>
/// <exception cref="ArgumentException">if a valid plaintext could not be read from stream</exception>
public void UnsafeLoad(Stream stream)
{
if (null == stream)
{
throw new ArgumentNullException(nameof(stream));
}
try
{
ParmsId parms = new ParmsId();
parms.Load(stream);
ParmsId = parms;
using (BinaryReader reader = new BinaryReader(stream))
{
double scale = reader.ReadDouble();
ulong coeffCount = reader.ReadUInt64();
Scale = scale;
ulong[] newData = new ulong[coeffCount];
for (ulong i = 0; i < coeffCount; i++)
{
newData[i] = reader.ReadUInt64();
}
NativeMethods.Plaintext_SwapData(NativePtr, coeffCount, newData);
}
}
catch (EndOfStreamException ex)
{
throw new ArgumentException("Stream ended unexpectedly", ex);
}
catch (IOException ex)
{
throw new ArgumentException("Could not read Plaintext", ex);
}
}
