예제 #1
0
        public void BatchUnbatchPlaintextNET()
        {
            var parms = new EncryptionParameters();

            parms.PolyModulus  = "1x^64 + 1";
            parms.CoeffModulus = new List <SmallModulus> {
                DefaultParams.SmallMods60Bit(0)
            };
            parms.PlainModulus = 257;

            var context = new SEALContext(parms);

            Assert.IsTrue(context.Qualifiers.EnableBatching);

            var crtbuilder = new PolyCRTBuilder(context);

            Assert.AreEqual(64, crtbuilder.SlotCount);
            var plain = new Plaintext(crtbuilder.SlotCount);

            for (int i = 0; i < crtbuilder.SlotCount; i++)
            {
                plain[i] = (UInt64)i;
            }

            crtbuilder.Compose(plain);
            crtbuilder.Decompose(plain);
            for (int i = 0; i < crtbuilder.SlotCount; i++)
            {
                Assert.IsTrue(plain[i] == (UInt64)i);
            }

            for (int i = 0; i < crtbuilder.SlotCount; i++)
            {
                plain[i] = (UInt64)5;
            }
            crtbuilder.Compose(plain);
            Assert.IsTrue(plain.ToString().Equals("5"));
            crtbuilder.Decompose(plain);
            for (int i = 0; i < crtbuilder.SlotCount; i++)
            {
                Assert.IsTrue(plain[i] == (UInt64)5);
            }

            var short_plain = new Plaintext(20);

            for (int i = 0; i < 20; i++)
            {
                short_plain[i] = (UInt64)i;
            }
            crtbuilder.Compose(short_plain);
            crtbuilder.Decompose(short_plain);
            for (int i = 0; i < 20; i++)
            {
                Assert.IsTrue(short_plain[i] == (UInt64)i);
            }
            for (int i = 20; i < crtbuilder.SlotCount; i++)
            {
                Assert.IsTrue(short_plain[i] == 0UL);
            }
        }
예제 #2
0
        public EncCal(BigPolyArray publicKey, string polyMod, int coeffDefault, ulong plainMod)
        {
            // Create encryption parameters.
            parms = new EncryptionParameters();
            parms.PolyModulus.Set(polyMod);
            parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[coeffDefault]);
            parms.PlainModulus.Set(plainMod);
            //parms.DecompositionBitCount = 12;
            // Create encoder (for encoding and decoding)
            encoder = new IntegerEncoder(parms.PlainModulus);
            //encoder = new FractionalEncoder(parms.PlainModulus, parms.PolyModulus, 64, 32, 3);

            //Create Encryptor // not mandatory
            encryptor = new Encryptor(parms, publicKey);

            //Create Evaluator for arithmatic operations
            evaluator = new Evaluator(parms);

            CrtBuilder = new PolyCRTBuilder(parms);
        }
예제 #3
0
 public EncCal(string polyMod, int coeffDefault, ulong plainMod, int dbc, int noOfEvaluationKeys)
 {
     // Create encryption parameters.
     parms = new EncryptionParameters();
     parms.PolyModulus.Set(polyMod);
     parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[coeffDefault]);
     parms.PlainModulus.Set(plainMod);
     // Generate keys.
     generator = new KeyGenerator(parms);
     generator.Generate(noOfEvaluationKeys);     //Integer
     // Generator contains the keys
     publicKey      = generator.PublicKey;
     secretKey      = generator.SecretKey;
     evaluationKeys = generator.EvaluationKeys;
     // Create encoder (for encoding and decoding)
     encoder = new IntegerEncoder(parms.PlainModulus);        //Integer
     //Create Encryptor
     encryptor = new Encryptor(parms, publicKey);
     //Create Decryptor
     decryptor = new Decryptor(parms, secretKey);
     //Create Evaluator for arithmatic operations
     evaluator  = new Evaluator(parms);
     CrtBuilder = new PolyCRTBuilder(parms);
 }
예제 #4
0
        public static void ExampleBatching()
        {
            PrintExampleBanner("Example: Batching using CRT");

            // Create encryption parameters
            var parms = new EncryptionParameters();

            /*
             * For PolyCRTBuilder it is necessary to have PlainModulus be a prime number congruent to 1 modulo
             * 2*degree(PolyModulus). We can use for example the following parameters:
             */
            parms.SetPolyModulus("1x^4096 + 1");
            parms.SetCoeffModulus(ChooserEvaluator.DefaultParameterOptions[4096]);
            parms.SetPlainModulus(40961);
            parms.Validate();

            // Create the PolyCRTBuilder
            var crtbuilder = new PolyCRTBuilder(parms);
            int slotCount  = crtbuilder.SlotCount;

            Console.WriteLine($"Encryption parameters allow {slotCount} slots.");

            // Create a list of values that are to be stored in the slots. We initialize all values to 0 at this point.
            var values = new List <BigUInt>(slotCount);

            for (int i = 0; i < slotCount; ++i)
            {
                values.Add(new BigUInt(parms.PlainModulus.BitCount, 0));
            }

            // Set the first few entries of the values list to be non-zero
            values[0].Set(2);
            values[1].Set(3);
            values[2].Set(5);
            values[3].Set(7);
            values[4].Set(11);
            values[5].Set(13);

            // Now compose these into one polynomial using PolyCRTBuilder
            Console.Write("Plaintext slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + values[i].ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }
            var plainComposedPoly = crtbuilder.Compose(values);

            // Let's do some homomorphic operations now. First we need all the encryption tools.
            // Generate keys.
            Console.WriteLine("Generating keys ...");
            var generator = new KeyGenerator(parms);

            generator.Generate();
            Console.WriteLine("... key generation completed");
            var publicKey = generator.PublicKey;
            var secretKey = generator.SecretKey;

            // Create the encryption tools
            var encryptor = new Encryptor(parms, publicKey);
            var evaluator = new Evaluator(parms);
            var decryptor = new Decryptor(parms, secretKey);

            // Encrypt plainComposed_poly
            Console.Write("Encrypting ... ");
            var encryptedComposedPoly = encryptor.Encrypt(plainComposedPoly);

            Console.WriteLine("done.");

            // Let's square and then decrypt the encryptedComposedPoly
            Console.Write("Squaring the encrypted polynomial ... ");
            var encryptedSquare = evaluator.Square(encryptedComposedPoly);

            Console.WriteLine("done.");

            Console.Write("Decrypting the squared polynomial ... ");
            var plainSquare = decryptor.Decrypt(encryptedSquare);

            Console.WriteLine("done.");

            // Print the squared slots
            crtbuilder.Decompose(plainSquare, values);
            Console.Write("Squared slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + values[i].ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }

            // Now let's try to multiply the squares with the plaintext coefficients (3, 1, 4, 1, 5, 9, 0, 0, ..., 0).
            // First create the coefficient list
            var plainCoeffList = new List <BigUInt>(slotCount);

            for (int i = 0; i < slotCount; ++i)
            {
                plainCoeffList.Add(new BigUInt(parms.PlainModulus.BitCount, 0));
            }

            plainCoeffList[0].Set(3);
            plainCoeffList[1].Set(1);
            plainCoeffList[2].Set(4);
            plainCoeffList[3].Set(1);
            plainCoeffList[4].Set(5);
            plainCoeffList[5].Set(9);

            // Use PolyCRTBuilder to compose plainCoeffList into a polynomial
            var plainCoeffPoly = crtbuilder.Compose(plainCoeffList);

            // Print the coefficient list
            Console.Write("Coefficient slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + plainCoeffList[i].ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }

            // Now use MultiplyPlain to multiply each encrypted slot with the corresponding coefficient
            Console.Write("Multiplying squared slots with the coefficients ... ");
            var encryptedScaledSquare = evaluator.MultiplyPlain(encryptedSquare, plainCoeffPoly);

            Console.WriteLine(" done.");

            // Decrypt it
            Console.Write("Decrypting the scaled squared polynomial ... ");
            var plainScaledSquare = decryptor.Decrypt(encryptedScaledSquare);

            Console.WriteLine("done.");

            // Print the scaled squared slots
            crtbuilder.Decompose(plainScaledSquare, values);
            Console.Write("Scaled squared slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + values[i].ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }

            // How much noise budget are we left with?
            Console.WriteLine("Noise budget in result: {0} bits", decryptor.InvariantNoiseBudget(encryptedScaledSquare));
        }
예제 #5
0
        public static void ExampleBatching()
        {
            PrintExampleBanner("Example: Batching using CRT");

            // Create encryption parameters
            var parms = new EncryptionParameters();

            /*
             * For PolyCRTBuilder we need to use a plain modulus congruent to 1 modulo 2*degree(PolyModulus), and
             * preferably a prime number. We could for example use the following parameters:
             *
             * parms.PolyModulus.Set("1x^2048 + 1");
             * parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[2048]);
             * parms.PlainModulus.Set(12289);
             *
             * However, the primes suggested by ChooserEvaluator.DefaultParameterOptions are highly non-optimal in this
             * case. The reason is that the noise growth in many homomorphic operations depends on the remainder
             * CoeffModulus % PlainModulus, which is typically close to PlainModulus unless the parameters are carefully
             * chosen. The primes in ChooserEvaluator.DefaultParameterOptions are chosen so that this remainder is 1
             * when PlainModulus is a (not too large) power of 2, so in the earlier examples this was not an issue.
             * However, here we are forced to take PlainModulus to be odd, and as a result the default parameters are no
             * longer optimal at all in this sense.
             *
             * Thus, for improved performance when using PolyCRTBuilder, we recommend the user to use their own
             * custom CoeffModulus. It should be a prime of the form 2^A - D, where D is as small as possible.
             * The PlainModulus should be simultaneously chosen to be a prime congruent to 1 modulo 2*degree(PolyModulus),
             * so that in addition CoeffModulus % PlainModulus is 1. Finally, CoeffModulus should be bounded by the
             * same strict upper bounds that were mentioned in ExampleBasics():
             * /------------------------------------\
             | PolyModulus | CoeffModulus bound |
             | -------------|---------------------|
             | 1x^1024 + 1  | 48 bits             |
             | 1x^2048 + 1  | 96 bits             |
             | 1x^4096 + 1  | 192 bits            |
             | 1x^8192 + 1  | 384 bits            |
             | 1x^16384 + 1 | 768 bits            |
             \------------------------------------/
             |
             | One issue with using such custom primes, however, is that they are never NTT primes, i.e. not congruent
             | to 1 modulo 2*degree(PolyModulus), and hence might not allow for certain optimizations to be used in
             | polynomial arithmetic. Another issue is that the search-to-decision reduction of RLWE does not apply to
             | non-NTT primes, but this is not known to result in any concrete reduction in the security level.
             |
             | In this example we use the prime 2^95 - 613077 as our coefficient modulus. The user should try switching
             | between this and ChooserEvaluator.DefaultParameterOptions[2048] to observe the difference in the noise
             | level at the end of the computation. This difference becomes significantly greater when using larger
             | values for PlainModulus.
             */
            parms.PolyModulus.Set("1x^2048 + 1");
            parms.CoeffModulus.Set("7FFFFFFFFFFFFFFFFFF6A52B");
            //parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[2048]);
            parms.PlainModulus.Set(12289);

            Console.WriteLine("Encryption parameters specify {0} coefficients with {1} bits per coefficient",
                              parms.PolyModulus.GetSignificantCoeffCount(), parms.CoeffModulus.GetSignificantBitCount());

            // Create the PolyCRTBuilder
            var crtbuilder = new PolyCRTBuilder(parms.PlainModulus, parms.PolyModulus);
            int slotCount  = crtbuilder.SlotCount;

            // Create a list of values that are to be stored in the slots. We initialize all values to 0 at this point.
            var values = new List <BigUInt>(slotCount);

            for (int i = 0; i < slotCount; ++i)
            {
                values.Add(new BigUInt(parms.PlainModulus.BitCount, 0));
            }

            // Set the first few entries of the values list to be non-zero
            values[0].Set(2);
            values[1].Set(3);
            values[2].Set(5);
            values[3].Set(7);
            values[4].Set(11);
            values[5].Set(13);

            // Now compose these into one polynomial using PolyCRTBuilder
            Console.Write("Plaintext slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + values[i].ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }
            var plainComposedPoly = crtbuilder.Compose(values);

            // Let's do some homomorphic operations now. First we need all the encryption tools.
            // Generate keys.
            Console.WriteLine("Generating keys...");
            var generator = new KeyGenerator(parms);

            generator.Generate();
            Console.WriteLine("... key generation completed");
            var publicKey = generator.PublicKey;
            var secretKey = generator.SecretKey;

            // Create the encryption tools
            var encryptor = new Encryptor(parms, publicKey);
            var evaluator = new Evaluator(parms);
            var decryptor = new Decryptor(parms, secretKey);

            // Encrypt plainComposed_poly
            Console.Write("Encrypting ... ");
            var encryptedComposedPoly = encryptor.Encrypt(plainComposedPoly);

            Console.WriteLine("done.");

            // Let's square and then decrypt the encryptedComposedPoly
            Console.Write("Squaring the encrypted polynomial ... ");
            var encryptedSquare = evaluator.Exponentiate(encryptedComposedPoly, 2);

            Console.WriteLine("done.");

            Console.Write("Decrypting the squared polynomial ... ");
            var plainSquare = decryptor.Decrypt(encryptedSquare);

            Console.WriteLine("done.");

            // Print the squared slots
            Console.Write("Squared slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + crtbuilder.GetSlot(plainSquare, i).ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }

            // Now let's try to multiply the squares with the plaintext coefficients (3, 1, 4, 1, 5, 9, 0, 0, ..., 0).
            // First create the coefficient list
            var plainCoeffList = new List <BigUInt>(slotCount);

            for (int i = 0; i < slotCount; ++i)
            {
                plainCoeffList.Add(new BigUInt(parms.PlainModulus.BitCount, 0));
            }

            plainCoeffList[0].Set(3);
            plainCoeffList[1].Set(1);
            plainCoeffList[2].Set(4);
            plainCoeffList[3].Set(1);
            plainCoeffList[4].Set(5);
            plainCoeffList[5].Set(9);

            // Use PolyCRTBuilder to compose plainCoeffList into a polynomial
            var plainCoeffPoly = crtbuilder.Compose(plainCoeffList);

            // Print the coefficient list
            Console.Write("Coefficient slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + crtbuilder.GetSlot(plainCoeffPoly, i).ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }

            // Now use MultiplyPlain to multiply each encrypted slot with the corresponding coefficient
            Console.Write("Multiplying squared slots with the coefficients ... ");
            var encryptedScaledSquare = evaluator.MultiplyPlain(encryptedSquare, plainCoeffPoly);

            Console.WriteLine(" done.");

            // Decrypt it
            Console.Write("Decrypting the scaled squared polynomial ... ");
            var plainScaledSquare = decryptor.Decrypt(encryptedScaledSquare);

            Console.WriteLine("done.");

            // Print the scaled squared slots
            Console.Write("Scaled squared slot contents (slot, value): ");
            for (int i = 0; i < 6; ++i)
            {
                string toWrite = "(" + i.ToString() + ", " + crtbuilder.GetSlot(plainScaledSquare, i).ToDecimalString() + ")";
                toWrite += (i != 5) ? ", " : "\n";
                Console.Write(toWrite);
            }

            // How much noise did we end up with?
            Console.WriteLine("Noise in the result: {0}/{1} bits", Utilities.InherentNoise(encryptedScaledSquare, parms, secretKey).GetSignificantBitCount(),
                              Utilities.InherentNoiseMax(parms).GetSignificantBitCount());
        }
예제 #6
0
        public void BatchUnbatchIntVectorNET()
        {
            var parms = new EncryptionParameters();

            parms.PolyModulus  = "1x^64 + 1";
            parms.CoeffModulus = new List <SmallModulus> {
                DefaultParams.SmallMods60Bit(0)
            };
            parms.PlainModulus = 257;

            var context = new SEALContext(parms);

            Assert.IsTrue(context.Qualifiers.EnableBatching);

            var crtbuilder = new PolyCRTBuilder(context);

            Assert.AreEqual(64, crtbuilder.SlotCount);
            var plain_vec = new List <Int64>();

            for (int i = 0; i < crtbuilder.SlotCount; i++)
            {
                plain_vec.Add((Int64)i * (1 - 2 * (i % 2)));
            }

            var plain = new Plaintext();

            crtbuilder.Compose(plain_vec, plain);
            var plain_vec2 = new List <Int64>();

            crtbuilder.Decompose(plain, plain_vec2);
            Assert.IsTrue(plain_vec.SequenceEqual(plain_vec2));

            for (int i = 0; i < crtbuilder.SlotCount; i++)
            {
                plain_vec[i] = -5;
            }
            crtbuilder.Compose(plain_vec, plain);
            Assert.IsTrue(plain.ToString().Equals("FC"));
            crtbuilder.Decompose(plain, plain_vec2);
            Assert.IsTrue(plain_vec.SequenceEqual(plain_vec2));

            var short_plain_vec = new List <Int64>();

            for (int i = 0; i < 20; i++)
            {
                short_plain_vec.Add((Int64)i * (1 - 2 * (i % 2)));
            }
            crtbuilder.Compose(short_plain_vec, plain);
            var short_plain_vec2 = new List <Int64>();

            crtbuilder.Decompose(plain, short_plain_vec2);
            Assert.AreEqual(20, short_plain_vec.Count);
            Assert.AreEqual(64, short_plain_vec2.Count);
            for (int i = 0; i < 20; i++)
            {
                Assert.AreEqual(short_plain_vec[i], short_plain_vec2[i]);
            }
            for (int i = 20; i < crtbuilder.SlotCount; i++)
            {
                Assert.AreEqual(0L, short_plain_vec2[i]);
            }
        }