Microsoft SEAL is an easy-to-use and powerful homomorphic encryption library.
BUILD_SHARED_LIBS=ON and SEAL_BUILD_SEAL_C=ON (Issue 284).seal::random_bytes function in randomgen.h.is_metadata_valid_for invocations reported in (Issue 313).BUILD_SHARED_LIBS=ON.BUILD_SHARED_LIBS=ON and SEAL_BUILD_DEPS=ON resulted in Zstandard header files not being visible to the build (Issue 242).FETCHCONTENT_BASE_DIR (Issue 242).seal.sln) for Windows.
There is a separate solution file for the dotnet library (dotnet/SEALNet.sln).enum labels are consistently in lowercase. Most importantly, scheme_type::BFV and scheme_type::CKKS are changed to scheme_type::bfv and scheme_type::ckks.seal::SEAL_BYTE to seal::seal_byte; all uppercase names are used only for preprocessor macros.BatchEncoder API for encoding and decoding Plaintext objects inplace.
This is because a Plaintext object with slot-data written into the coefficients is (confusingly) not valid to be used for encryption.IntegerEncoder and BigUInt classes.
IntegerEncoder results in inefficient homomorphic evaluation and lacks sane correctness properties, so it was basically impossible to use in real applications.
The BigUInt class was only used by the IntegerEncoder.Encryptor::encrypt variants have now two overloads: one that takes a Ciphertext out-parameter, and one that returns a Serializable<Ciphertext>.KeyGenerator::create_public_key.KeyGenerator::relin_keys_local and KeyGenerator::galois_keys_local functions.
These were poorly named and have been replaced with overloads of KeyGenerator::create_relin_keys and KeyGenerator::create_galois_keys that take an out-parameter of type RelinKeys or GaloisKeys.IntArray to DynArray (dynamic array) and removed unnecessary limitations on the object type template parameter.Modulus class.DynArray and Plaintext objects from a gsl::span<std::uint64_t> (C++) or IEnumerable<ulong> (C#).std::hash implementation for EncryptionParameters (in addition to parms_id_type) so it is possible to create e.g. std::unordered_map of EncryptionParameters.UniformRandomGeneratorFactory to find whether the factory uses a default seed and to retrieve that seed.DynArray::begin and DynArray::end.Shake256PRNG and Shake256PRNGFactory classes.
Renamed BlakePRNG class to Blake2xbPRNG, and BlakePRNGFactory class to Blake2xbPRNGFactory.UniformRandomGeneratorInfo class that represents the type of an extendable output function and a seed value.SEALVersion.
This is used internally to route deserialization logic to correct functions depending on loaded SEALHeader version.SEAL_BUILD_DEPS controls whether dependencies are downloaded and built into Microsoft SEAL or searched from the system.BUILD_SHARED_LIBS is set to ON. Previously a static library was always built.SEAL_USE_GAUSSIAN_NOISE is set to ON.
Sampling from a CBD is constant-time and faster than sampling from a Gaussian distribution, which is why it is used by many of the NIST PQC finalists.SEAL_DEFAULT_PRNG controls which XOF is used for pseudo-random number generation.
The available values are Blake2xb (default) and Shake256.seal_shared.pc for compiling against a shared Microsoft SEAL if BUILD_SHARED_LIBS is set to ON..pre-commit-config.yaml (check out pre-commit if you are not familiar with this tool).seal::util::DWTHandler and seal::util::Arithmetic class templates that unify the implementation of FFT (used by CKKSEncoder) and NTT (used by polynomial arithmetic).native/src/seal/intarray.h to native/src/seal/dynarray.h
dotnet/src/SEALNet.csproj to dotnet/src/SEALNet.csproj.in
dotnet/tests/SEALNetTest.csproj to dotnet/tests/SEALNetTest.csproj.in
dotnet/examples/SEALNetExamples.csproj to dotnet/examples/SEALNetExamples.csproj.in
dotnet/src/BigUInt.cs
dotnet/src/IntegerEncoder.cs
dotnet/tests/BigUIntTests.cs
dotnet/tests/IntegerEncoderTests.cs
native/examples/SEALExamples.vcxproj
native/examples/SEALExamples.vcxproj.filters
native/src/CMakeConfig.cmd
native/src/SEAL_C.vcxproj
native/src/SEAL_C.vcxproj.filters
native/src/SEAL.vcxproj
native/src/SEAL.vcxproj.filters
native/src/seal/biguint.h
native/src/seal/biguint.cpp
native/src/seal/intencoder.h
native/src/seal/intencoder.cpp
native/tests/packages.config
native/tests/SEALTest.vcxproj
native/tests/SEALTest.vcxproj.filters
native/tests/seal/biguint.cpp
native/tests/seal/intencoder.cpp
thirdparty/
SEAL.sln
RtlGenRandom if the BCrypt API fails.parms_id of a Plaintext was not cleared correctly before resizing in Decryptor::bfv_decrypt.
As a result, a plaintext in NTT form could not be used as the destination for decrypting a BFV ciphertext.seal::util::MultiplyUIntModOperand in native/src/seal/util/uintarithsmallmod.h.
This struct handles precomputation data for Barrett style modular multiplication.MultiplyUIntModOperand instance for improved performance when the same operand is used repeatedly.seal::util::barrett_reduce_63 to seal::util::barrett_reduce_64; the name was misleading and only referred to the size of the modulus.seal::util::StrideIter in native/src/seal/util/iterator.h.SEAL_ALLOCATE_GET_PTR_ITER and SEAL_ALLOCATE_GET_STRIDE_ITER in native/src/seal/util/defines.h.std::void_t was introduced only in C++17; switched to using a custom implementation (Issue 180).native/src/CMakeConfig.cmd: The first prevented SEAL to be built in a directory with spaces in the path due to missing quotation marks. Another issue caused MSVC to fail when building SEAL for multiple architectures.RNSBase::decompose_array had incorrect semantics that caused Evaluator::multiply_plain_normal and Evaluator::transform_to_ntt_inplace (for Plaintext) to behave incorrectly for some plaintexts.seal::util::PtrIter<T *> now dereferences correctly to T & instead of T *.
This results in simpler code, where inside SEAL_ITERATE lambda functions dereferences of seal::util::PtrIter<T *> do not need to be dereferenced a second time, as was particularly common when iterating over ModulusIter and NTTTablesIter types.seal::util::IterTuple now dereferences to an std::tuple of dereferences of its component iterators, so it is no longer possible to directly pass a dereferenced seal::util::IterTuple to an inner lambda function in nested SEAL_ITERATE calls.
Instead, the outer lambda function parameter should be wrapped inside another call to seal::util::iter before passed on to the inner SEAL_ITERATE to produce an appropriate seal::util::IterTuple.