예제 #1
0
        public void One_initializes()
        {
            Fp12 _ = Fp12.One;

            Assert.AreEqual(Fp6.One, _.A, "A");
            Assert.AreEqual(Fp6.Zero, _.B, "B");
        }
예제 #2
0
        public void Zero_initializes()
        {
            Fp12 _ = Fp12.Zero;

            Assert.AreEqual(Fp6.Zero, _.A, "A");
            Assert.AreEqual(Fp6.Zero, _.B, "B");
        }
예제 #3
0
        public void Cyclotomic_square_seems_fine()
        {
            // ReSharper disable once EqualExpressionComparison
            Fp12 cyclotomicSquare = Fp12.One.CyclotomicSquare();

            Assert.AreEqual(Fp6.One, cyclotomicSquare.A, "A");
            Assert.AreEqual(Fp6.Zero, cyclotomicSquare.B, "B");
        }
예제 #4
0
        public void Unitary_inverse_seems_fine()
        {
            // ReSharper disable once EqualExpressionComparison
            Fp6  oneOneOne       = new Fp6(Fp2.One, Fp2.One, Fp2.One);
            Fp12 unitaryInverted = new Fp12(oneOneOne, oneOneOne).UnitaryInverse();

            Assert.AreEqual(oneOneOne, unitaryInverted.A, "A");
            Assert.AreEqual(oneOneOne.Negate(), unitaryInverted.B, "B");
        }
예제 #5
0
        public void Square_cross_check()
        {
            Fp2  a2  = new Fp2(Parameters.P / 2, Parameters.P / 4);
            Fp6  a6  = new Fp6(a2, a2, a2);
            Fp12 a12 = new Fp12(a6, a6);

            Assert.True(a12.IsValid());

            Assert.AreEqual(a12.Squared(), a12.Mul(a12));
        }
예제 #6
0
        public void TestFp12()
        {
            Fp12 x   = new Fp12(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
            Fp12 f   = new Fp12(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
            Fp12 fpx = new Fp12(2, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);

            Assert.Equal(fpx, x + f);
            Assert.Equal(Fp12.OneValue, f / f);
            Assert.Equal((Fp12.OneValue + x) / f, (Fp12.OneValue / f) + (x / f));
            Assert.Equal((Fp12.OneValue + x) * f, (Fp12.OneValue * f) + (x * f));
        }
예제 #7
0
        private static EVMExecutionResult Precompile_ECPairing(MeadowEVM evm)
        {
            // Verify we're past the byzantium fork
            if (evm.Version < EthereumRelease.Byzantium)
            {
                return(new EVMExecutionResult(evm, null, true));
            }

            const int PAIRING_SIZE_PER_POINT = 192;

            // Verify our messatge data is divisible by our size per point.
            if (evm.Message.Data.Length % PAIRING_SIZE_PER_POINT != 0)
            {
                throw new EVMException($"ECPairing precompile failed because the call data was not divisible by the size per point ({PAIRING_SIZE_PER_POINT}).");
            }

            // Charge the gas for the precompile operation before processing.
            BigInteger gasCharge = GasDefinitions.GAS_PRECOMPILE_ECPAIRING_BASE + ((evm.Message.Data.Length / PAIRING_SIZE_PER_POINT) * GasDefinitions.GAS_PRECOMPILE_ECPAIRING_PER_POINT);

            evm.GasState.Deduct(gasCharge);

            // Obtain a memory representation of our data.
            Span <byte> messageData = new Span <byte>(evm.Message.Data);

            // Define some constant variables for arithmetic.
            FpVector3 <Fp2> zero     = new FpVector3 <Fp2>(Fp2.OneValue, Fp2.OneValue, Fp2.ZeroValue);
            Fp12            exponent = Fp12.OneValue;

            // Loop for each point in our data
            for (int i = 0; i < evm.Message.Data.Length; i += PAIRING_SIZE_PER_POINT)
            {
                // Obtain our component data
                BigInteger x1   = BigIntegerConverter.GetBigInteger(messageData.Slice(i + 0, EVMDefinitions.WORD_SIZE));
                BigInteger y1   = BigIntegerConverter.GetBigInteger(messageData.Slice(i + 32, EVMDefinitions.WORD_SIZE));
                BigInteger x2_i = BigIntegerConverter.GetBigInteger(messageData.Slice(i + 64, EVMDefinitions.WORD_SIZE));
                BigInteger x2_r = BigIntegerConverter.GetBigInteger(messageData.Slice(i + 96, EVMDefinitions.WORD_SIZE));
                BigInteger y2_i = BigIntegerConverter.GetBigInteger(messageData.Slice(i + 128, EVMDefinitions.WORD_SIZE));
                BigInteger y2_r = BigIntegerConverter.GetBigInteger(messageData.Slice(i + 160, EVMDefinitions.WORD_SIZE));

                // Parse and verify our point.
                FpVector3 <Fp> point1 = ParsePoint(x1, y1);
                if (point1 == null)
                {
                    throw new EVMException("ECPairing precompile failed because point 1 was deemed invalid when parsing.");
                }

                // If our coordinates exceed our modulo divisor, they are invalid.
                if (x2_i >= Bn128Curve.P || x2_r >= Bn128Curve.P || y2_i >= Bn128Curve.P || y2_r >= Bn128Curve.P)
                {
                    throw new EVMException("ECPairing precompile failed because point 2 was deemed invalid when parsing.");
                }

                Fp2             x2     = new Fp2(x2_r, x2_i);
                Fp2             y2     = new Fp2(y2_r, y2_i);
                FpVector3 <Fp2> point2 = null;
                if (x2 == Fp2.ZeroValue && y2 == Fp2.ZeroValue)
                {
                    // Our point is the zero point.
                    point2 = zero;
                }
                else
                {
                    // Initialize our point from components.
                    point2 = new FpVector3 <Fp2>(x2, y2, Fp2.OneValue);

                    // Verify our desired point is on the curve
                    if (!point2.IsOnCurveCheck(Bn128Curve.B2))
                    {
                        throw new EVMException("ECPairing precompile failed because point 2 was not on the curve.");
                    }
                }

                // Verify multiplying by the curve order is non-zero.
                if (point2.Multiply(Bn128Curve.N).Z != Fp2.ZeroValue)
                {
                    throw new EVMException("ECPairing precompile failed because point 2 was deemed invalid. Points multiplied by the curve order should equal infinity (zero).");
                }

                // Pair our points and multiply the exponent by them.
                exponent *= Bn128Pairing.Pair(point2, point1, false);
            }

            // Return our result
            bool returnStatus = Bn128Pairing.FinalExponentiate(exponent) == Fp12.OneValue;

            byte[] returnData = BigIntegerConverter.GetBytes(returnStatus ? 1 : 0, EVMDefinitions.WORD_SIZE);
            return(new EVMExecutionResult(evm, returnData, true));
        }