Exemplo n.º 1
0
    // Adapted from https://github.com/microsoft/SEAL/blob/master/dotnet/tests/CiphertextTests.cs#L113
    static void SaveLoadTest(Func <Ciphertext, SEALContext, Ciphertext> roundtrip)
    {
        SEALContext  context   = GlobalContext.Context;
        KeyGenerator keygen    = new KeyGenerator(context);
        Encryptor    encryptor = new Encryptor(context, keygen.PublicKey);
        Plaintext    plain     = new Plaintext("2x^3 + 4x^2 + 5x^1 + 6");
        Ciphertext   cipher    = new Ciphertext();

        encryptor.Encrypt(plain, cipher);
        Assert.AreEqual(2ul, cipher.Size);
        Assert.AreEqual(8192ul, cipher.PolyModulusDegree);
        Assert.AreEqual(4ul, cipher.CoeffModCount);
        var loaded = roundtrip(cipher, context);

        Assert.AreEqual(2ul, loaded.Size);
        Assert.AreEqual(8192ul, loaded.PolyModulusDegree);
        Assert.AreEqual(4ul, loaded.CoeffModCount);
        Assert.IsTrue(ValCheck.IsValidFor(loaded, context));
        ulong ulongCount = cipher.Size * cipher.PolyModulusDegree * cipher.CoeffModCount;

        for (ulong i = 0; i < ulongCount; i++)
        {
            Assert.AreEqual(cipher[i], loaded[i]);
        }
    }
Exemplo n.º 2
0
        public void ExceptionsTest()
        {
            SEALContext      context     = GlobalContext.BFVContext;
            Plaintext        plain       = new Plaintext();
            MemoryPoolHandle pool        = MemoryManager.GetPool(MMProfOpt.ForceGlobal);
            MemoryPoolHandle pool_uninit = new MemoryPoolHandle();

            Utilities.AssertThrows <ArgumentException>(() => plain     = new Plaintext(pool_uninit));
            Utilities.AssertThrows <ArgumentNullException>(() => plain = new Plaintext((string)null, pool));

            Utilities.AssertThrows <ArgumentNullException>(() => plain.Set((Plaintext)null));
            Utilities.AssertThrows <ArgumentNullException>(() => plain.Set((string)null));

            Utilities.AssertThrows <ArgumentOutOfRangeException>(() => plain.SetZero(100000));
            Utilities.AssertThrows <ArgumentOutOfRangeException>(() => plain.SetZero(1, 100000));
            Utilities.AssertThrows <ArgumentOutOfRangeException>(() => plain.SetZero(100000, 1));

            Utilities.AssertThrows <ArgumentNullException>(() => ValCheck.IsValidFor(plain, null));

            Utilities.AssertThrows <ArgumentNullException>(() => plain.Save(null));

            Utilities.AssertThrows <ArgumentNullException>(() => plain.UnsafeLoad(null, new MemoryStream()));
            Utilities.AssertThrows <ArgumentNullException>(() => plain.UnsafeLoad(context, null));
            Utilities.AssertThrows <EndOfStreamException>(() => plain.UnsafeLoad(context, new MemoryStream()));

            Utilities.AssertThrows <ArgumentNullException>(() => plain.Load(context, null));
            Utilities.AssertThrows <ArgumentNullException>(() => plain.Load(null, new MemoryStream()));
        }
Exemplo n.º 3
0
        public void SaveLoadTest()
        {
            SEALContext  context = GlobalContext.BFVContext;
            KeyGenerator keygen  = new KeyGenerator(context);

            RelinKeys keys = keygen.RelinKeys();

            Assert.IsNotNull(keys);
            Assert.AreEqual(1ul, keys.Size);

            RelinKeys        other  = new RelinKeys();
            MemoryPoolHandle handle = other.Pool;

            Assert.AreEqual(0ul, other.Size);
            ulong alloced = handle.AllocByteCount;

            using (MemoryStream ms = new MemoryStream())
            {
                keys.Save(ms);
                ms.Seek(offset: 0, loc: SeekOrigin.Begin);
                other.Load(context, ms);
            }

            Assert.AreEqual(1ul, other.Size);
            Assert.IsTrue(ValCheck.IsMetadataValidFor(other, context));
            Assert.IsTrue(handle.AllocByteCount > 0ul);

            List <IEnumerable <PublicKey> > keysData  = new List <IEnumerable <PublicKey> >(keys.Data);
            List <IEnumerable <PublicKey> > otherData = new List <IEnumerable <PublicKey> >(other.Data);

            Assert.AreEqual(keysData.Count, otherData.Count);
            for (int i = 0; i < keysData.Count; i++)
            {
                List <PublicKey> keysCiphers  = new List <PublicKey>(keysData[i]);
                List <PublicKey> otherCiphers = new List <PublicKey>(otherData[i]);

                Assert.AreEqual(keysCiphers.Count, otherCiphers.Count);

                for (int j = 0; j < keysCiphers.Count; j++)
                {
                    PublicKey keysCipher  = keysCiphers[j];
                    PublicKey otherCipher = otherCiphers[j];

                    Assert.AreEqual(keysCipher.Data.Size, otherCipher.Data.Size);
                    Assert.AreEqual(keysCipher.Data.PolyModulusDegree, otherCipher.Data.PolyModulusDegree);
                    Assert.AreEqual(keysCipher.Data.CoeffModCount, otherCipher.Data.CoeffModCount);

                    ulong coeffCount = keysCipher.Data.Size * keysCipher.Data.PolyModulusDegree * keysCipher.Data.CoeffModCount;
                    for (ulong k = 0; k < coeffCount; k++)
                    {
                        Assert.AreEqual(keysCipher.Data[k], otherCipher.Data[k]);
                    }
                }
            }
        }
Exemplo n.º 4
0
        public void SaveLoadTest()
        {
            SEALContext  context = GlobalContext.BFVContext;
            KeyGenerator keygen  = new KeyGenerator(context);

            keygen.CreateGaloisKeys(out GaloisKeys keys);
            GaloisKeys other = new GaloisKeys();

            Assert.IsNotNull(keys);
            Assert.AreEqual(24ul, keys.Size);

            using (MemoryStream ms = new MemoryStream())
            {
                keys.Save(ms);
                ms.Seek(offset: 0, loc: SeekOrigin.Begin);
                other.Load(context, ms);
            }

            Assert.AreEqual(24ul, other.Size);
            Assert.IsTrue(ValCheck.IsValidFor(other, context));

            List <IEnumerable <PublicKey> > keysData  = new List <IEnumerable <PublicKey> >(keys.Data);
            List <IEnumerable <PublicKey> > otherData = new List <IEnumerable <PublicKey> >(other.Data);

            Assert.AreEqual(keysData.Count, otherData.Count);
            for (int i = 0; i < keysData.Count; i++)
            {
                List <PublicKey> keysCiphers  = new List <PublicKey>(keysData[i]);
                List <PublicKey> otherCiphers = new List <PublicKey>(otherData[i]);

                Assert.AreEqual(keysCiphers.Count, otherCiphers.Count);

                for (int j = 0; j < keysCiphers.Count; j++)
                {
                    PublicKey keysCipher  = keysCiphers[j];
                    PublicKey otherCipher = otherCiphers[j];

                    Assert.AreEqual(keysCipher.Data.Size, otherCipher.Data.Size);
                    Assert.AreEqual(keysCipher.Data.PolyModulusDegree, otherCipher.Data.PolyModulusDegree);
                    Assert.AreEqual(keysCipher.Data.CoeffModulusSize, otherCipher.Data.CoeffModulusSize);

                    ulong coeffCount = keysCipher.Data.Size * keysCipher.Data.PolyModulusDegree * keysCipher.Data.CoeffModulusSize;
                    for (ulong k = 0; k < coeffCount; k++)
                    {
                        Assert.AreEqual(keysCipher.Data[k], otherCipher.Data[k]);
                    }
                }
            }
        }
Exemplo n.º 5
0
        public void ExceptionsTest()
        {
            SEALContext      context = GlobalContext.BFVContext;
            MemoryPoolHandle pool    = MemoryManager.GetPool(MMProfOpt.ForceGlobal);
            MemoryPoolHandle poolu   = new MemoryPoolHandle();
            Ciphertext       cipher  = new Ciphertext();
            Ciphertext       copy    = null;

            Utilities.AssertThrows <ArgumentNullException>(() => copy = new Ciphertext((Ciphertext)null));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher = new Ciphertext(context, null, pool));
            Utilities.AssertThrows <ArgumentNullException>(() => cipher = new Ciphertext(null, context.FirstParmsId, pool));
            Utilities.AssertThrows <ArgumentException>(() => cipher     = new Ciphertext(context, ParmsId.Zero, pool));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher = new Ciphertext((SEALContext)null, poolu));
            Utilities.AssertThrows <ArgumentException>(() => cipher     = new Ciphertext(context, poolu));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher = new Ciphertext(context, null, 6ul));
            Utilities.AssertThrows <ArgumentNullException>(() => cipher = new Ciphertext(null, context.FirstParmsId, 6ul, poolu));
            Utilities.AssertThrows <ArgumentException>(() => cipher     = new Ciphertext(context, ParmsId.Zero, 6ul, poolu));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Reserve(context, null, 10ul));
            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Reserve(null, ParmsId.Zero, 10ul));
            Utilities.AssertThrows <ArgumentException>(() => cipher.Reserve(context, ParmsId.Zero, 10ul));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Reserve(null, 10ul));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Resize(context, null, 10ul));
            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Resize(null, ParmsId.Zero, 10ul));
            Utilities.AssertThrows <ArgumentException>(() => cipher.Resize(context, ParmsId.Zero, 10ul));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Resize(null, 10ul));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Set(null));

            Utilities.AssertThrows <ArgumentNullException>(() => ValCheck.IsValidFor(cipher, null));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Save(null));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.UnsafeLoad(context, null));
            Utilities.AssertThrows <ArgumentNullException>(() => cipher.UnsafeLoad(null, new MemoryStream()));
            Utilities.AssertThrows <EndOfStreamException>(() => cipher.UnsafeLoad(context, new MemoryStream()));

            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Load(null, new MemoryStream()));
            Utilities.AssertThrows <ArgumentNullException>(() => cipher.Load(context, null));
        }
Exemplo n.º 6
0
        public void SaveLoadTest()
        {
            {
                SEALContext context = GlobalContext.BFVContext;
                Plaintext   plain   = new Plaintext("6x^5 + 5x^4 + 4x^3 + 3x^2 + 2x^1 + 5");
                Plaintext   other   = new Plaintext();

                Assert.AreNotSame(plain, other);
                Assert.AreNotEqual(plain, other);

                using (MemoryStream stream = new MemoryStream())
                {
                    plain.Save(stream);

                    stream.Seek(offset: 0, loc: SeekOrigin.Begin);

                    other.Load(context, stream);
                }

                Assert.AreNotSame(plain, other);
                Assert.AreEqual(plain, other);
                Assert.IsTrue(ValCheck.IsValidFor(other, context));
            }
            {
                SEALContext context = GlobalContext.BGVContext;
                Plaintext   plain   = new Plaintext("6x^5 + 5x^4 + 4x^3 + 3x^2 + 2x^1 + 5");
                Plaintext   other   = new Plaintext();

                Assert.AreNotSame(plain, other);
                Assert.AreNotEqual(plain, other);

                using (MemoryStream stream = new MemoryStream())
                {
                    plain.Save(stream);

                    stream.Seek(offset: 0, loc: SeekOrigin.Begin);

                    other.Load(context, stream);
                }

                Assert.AreNotSame(plain, other);
                Assert.AreEqual(plain, other);
                Assert.IsTrue(ValCheck.IsValidFor(other, context));
            }
        }
Exemplo n.º 7
0
        public void ExceptionsTest()
        {
            RelinKeys   keys    = new RelinKeys();
            SEALContext context = GlobalContext.BFVContext;

            Utilities.AssertThrows <ArgumentNullException>(() => keys = new RelinKeys(null));
            Utilities.AssertThrows <ArgumentNullException>(() => keys.Set(null));

            Utilities.AssertThrows <ArgumentNullException>(() => ValCheck.IsValidFor(keys, null));

            Utilities.AssertThrows <ArgumentNullException>(() => keys.Save(null));

            Utilities.AssertThrows <ArgumentNullException>(() => keys.Load(context, null));
            Utilities.AssertThrows <ArgumentNullException>(() => keys.Load(null, new MemoryStream()));
            Utilities.AssertThrows <EndOfStreamException>(() => keys.Load(context, new MemoryStream()));
            Utilities.AssertThrows <ArgumentNullException>(() => keys.UnsafeLoad(null, new MemoryStream()));
            Utilities.AssertThrows <ArgumentNullException>(() => keys.UnsafeLoad(context, null));
        }
Exemplo n.º 8
0
        public void BGVSaveLoadTest()
        {
            SEALContext  context = GlobalContext.BGVContext;
            KeyGenerator keygen  = new KeyGenerator(context);

            keygen.CreatePublicKey(out PublicKey publicKey);

            Encryptor  encryptor = new Encryptor(context, publicKey);
            Plaintext  plain     = new Plaintext("2x^3 + 4x^2 + 5x^1 + 6");
            Ciphertext cipher    = new Ciphertext();

            encryptor.Encrypt(plain, cipher);

            Assert.AreEqual(2ul, cipher.Size);
            Assert.AreEqual(8192ul, cipher.PolyModulusDegree);
            Assert.AreEqual(4ul, cipher.CoeffModulusSize);

            Ciphertext loaded = new Ciphertext();

            Assert.AreEqual(0ul, loaded.Size);
            Assert.AreEqual(0ul, loaded.PolyModulusDegree);
            Assert.AreEqual(0ul, loaded.CoeffModulusSize);

            using (MemoryStream mem = new MemoryStream())
            {
                cipher.Save(mem);

                mem.Seek(offset: 0, loc: SeekOrigin.Begin);

                loaded.Load(context, mem);
            }

            Assert.AreEqual(2ul, loaded.Size);
            Assert.AreEqual(8192ul, loaded.PolyModulusDegree);
            Assert.AreEqual(4ul, loaded.CoeffModulusSize);
            Assert.IsTrue(ValCheck.IsValidFor(loaded, context));

            ulong ulongCount = cipher.Size * cipher.PolyModulusDegree * cipher.CoeffModulusSize;

            for (ulong i = 0; i < ulongCount; i++)
            {
                Assert.AreEqual(cipher[i], loaded[i]);
            }
        }
Exemplo n.º 9
0
        public void ExceptionsTest()
        {
            RelinKeys   keys    = new RelinKeys();
            SEALContext context = GlobalContext.BFVContext;

            Assert.ThrowsException <ArgumentNullException>(() => keys = new RelinKeys(null));

            Assert.ThrowsException <ArgumentNullException>(() => keys.Set(null));

            Assert.ThrowsException <ArgumentNullException>(() => ValCheck.IsValidFor(keys, null));
            Assert.ThrowsException <ArgumentNullException>(() => ValCheck.IsMetadataValidFor(keys, null));

            Assert.ThrowsException <ArgumentNullException>(() => keys.Save(null));

            Assert.ThrowsException <ArgumentNullException>(() => keys.Load(context, null));
            Assert.ThrowsException <ArgumentNullException>(() => keys.Load(null, new MemoryStream()));
            Assert.ThrowsException <ArgumentException>(() => keys.Load(context, new MemoryStream()));
            Assert.ThrowsException <ArgumentNullException>(() => keys.UnsafeLoad(null));
        }
Exemplo n.º 10
0
        public void ExceptionsTest()
        {
            SEALContext context = GlobalContext.BFVContext;
            SecretKey   key     = new SecretKey();

            Utilities.AssertThrows <ArgumentNullException>(() => key = new SecretKey(null));

            Utilities.AssertThrows <ArgumentNullException>(() => key.Set(null));

            Utilities.AssertThrows <ArgumentNullException>(() => ValCheck.IsValidFor(key, null));

            Utilities.AssertThrows <ArgumentNullException>(() => key.Save(null));

            Utilities.AssertThrows <ArgumentNullException>(() => key.UnsafeLoad(null, new MemoryStream()));
            Utilities.AssertThrows <ArgumentNullException>(() => key.UnsafeLoad(context, null));
            Utilities.AssertThrows <ArgumentNullException>(() => key.Load(context, null));
            Utilities.AssertThrows <ArgumentNullException>(() => key.Load(null, new MemoryStream()));
            Utilities.AssertThrows <EndOfStreamException>(() => key.Load(context, new MemoryStream()));
        }
Exemplo n.º 11
0
        public void ExceptionsTest()
        {
            SEALContext context = GlobalContext.BFVContext;
            SecretKey   key     = new SecretKey();

            Assert.ThrowsException <ArgumentNullException>(() => key = new SecretKey(null));

            Assert.ThrowsException <ArgumentNullException>(() => key.Set(null));

            Assert.ThrowsException <ArgumentNullException>(() => ValCheck.IsValidFor(key, null));
            Assert.ThrowsException <ArgumentNullException>(() => ValCheck.IsMetadataValidFor(key, null));

            Assert.ThrowsException <ArgumentNullException>(() => key.Save(null));
            Assert.ThrowsException <ArgumentNullException>(() => key.UnsafeLoad(null));

            Assert.ThrowsException <ArgumentNullException>(() => key.Load(context, null));
            Assert.ThrowsException <ArgumentNullException>(() => key.Load(null, new MemoryStream()));
            Assert.ThrowsException <ArgumentException>(() => key.Load(context, new MemoryStream()));
        }