示例#1
0
        protected override ECPoint DecompressPoint(int yTilde, BigInteger X1)
        {
            ECFieldElement xp = FromBigInteger(X1), yp;

            if (xp.IsZero)
            {
                yp = m_b.Sqrt();
            }
            else
            {
                ECFieldElement beta = xp.Square().Invert().Multiply(B).Add(A).Add(xp);
                ECFieldElement z    = SolveQuadradicEquation(beta);

                if (z == null)
                {
                    throw new ArithmeticException("Invalid point compression");
                }

                if (z.TestBitZero() != (yTilde == 1))
                {
                    z = z.AddOne();
                }

                switch (this.CoordinateSystem)
                {
                case COORD_LAMBDA_AFFINE:
                case COORD_LAMBDA_PROJECTIVE:
                {
                    yp = z.Add(xp);
                    break;
                }

                default:
                {
                    yp = z.Multiply(xp);
                    break;
                }
                }
            }

            return(new F2mPoint(this, xp, yp, true));
        }
        protected override ECPoint DecompressPoint(int yTilde, BigInteger X1)
        {
            //IL_009b: Unknown result type (might be due to invalid IL or missing references)
            ECFieldElement eCFieldElement  = FromBigInteger(X1);
            ECFieldElement eCFieldElement2 = null;

            if (eCFieldElement.IsZero)
            {
                eCFieldElement2 = B.Sqrt();
            }
            else
            {
                ECFieldElement beta = eCFieldElement.Square().Invert().Multiply(B)
                                      .Add(A)
                                      .Add(eCFieldElement);
                ECFieldElement eCFieldElement3 = SolveQuadradicEquation(beta);
                if (eCFieldElement3 != null)
                {
                    if (eCFieldElement3.TestBitZero() != (yTilde == 1))
                    {
                        eCFieldElement3 = eCFieldElement3.AddOne();
                    }
                    switch (CoordinateSystem)
                    {
                    case 5:
                    case 6:
                        eCFieldElement2 = eCFieldElement3.Add(eCFieldElement);
                        break;

                    default:
                        eCFieldElement2 = eCFieldElement3.Multiply(eCFieldElement);
                        break;
                    }
                }
            }
            if (eCFieldElement2 == null)
            {
                throw new ArgumentException("Invalid point compression");
            }
            return(CreateRawPoint(eCFieldElement, eCFieldElement2, withCompression: true));
        }
示例#3
0
        protected override ECPoint DecompressPoint(int yTilde, BigInteger X1)
        {
            ECFieldElement eCFieldElement  = this.FromBigInteger(X1);
            ECFieldElement eCFieldElement2 = null;

            if (eCFieldElement.IsZero)
            {
                eCFieldElement2 = this.m_b.Sqrt();
            }
            else
            {
                ECFieldElement beta            = eCFieldElement.Square().Invert().Multiply(this.B).Add(this.A).Add(eCFieldElement);
                ECFieldElement eCFieldElement3 = this.SolveQuadradicEquation(beta);
                if (eCFieldElement3 != null)
                {
                    if (eCFieldElement3.TestBitZero() != (yTilde == 1))
                    {
                        eCFieldElement3 = eCFieldElement3.AddOne();
                    }
                    switch (this.CoordinateSystem)
                    {
                    case 5:
                    case 6:
                        eCFieldElement2 = eCFieldElement3.Add(eCFieldElement);
                        break;

                    default:
                        eCFieldElement2 = eCFieldElement3.Multiply(eCFieldElement);
                        break;
                    }
                }
            }
            if (eCFieldElement2 == null)
            {
                throw new ArgumentException("Invalid point compression");
            }
            return(this.CreateRawPoint(eCFieldElement, eCFieldElement2, true));
        }
        protected override ECPoint DecompressPoint(int yTilde, BigInteger X1)
        {
            ECFieldElement b = this.FromBigInteger(X1);
            ECFieldElement y = null;

            if (b.IsZero)
            {
                y = this.B.Sqrt();
            }
            else
            {
                ECFieldElement beta     = b.Square().Invert().Multiply(this.B).Add(this.A).Add(b);
                ECFieldElement element4 = this.SolveQuadradicEquation(beta);
                if (element4 != null)
                {
                    if (element4.TestBitZero() != (yTilde == 1))
                    {
                        element4 = element4.AddOne();
                    }
                    switch (this.CoordinateSystem)
                    {
                    case 5:
                    case 6:
                        y = element4.Add(b);
                        goto Label_00A9;
                    }
                    y = element4.Multiply(b);
                }
            }
Label_00A9:
            if (y == null)
            {
                throw new ArgumentException("Invalid point compression");
            }
            return(this.CreateRawPoint(b, y, true));
        }
示例#5
0
        public override ECPoint TwicePlus(ECPoint b)
        {
            if (base.IsInfinity)
            {
                return(b);
            }
            if (b.IsInfinity)
            {
                return(Twice());
            }
            ECCurve        curve     = Curve;
            ECFieldElement rawXCoord = base.RawXCoord;

            if (rawXCoord.IsZero)
            {
                return(b);
            }
            int coordinateSystem = curve.CoordinateSystem;
            int num = coordinateSystem;

            if (num == 6)
            {
                ECFieldElement rawXCoord2     = b.RawXCoord;
                ECFieldElement eCFieldElement = b.RawZCoords[0];
                if (rawXCoord2.IsZero || !eCFieldElement.IsOne)
                {
                    return(Twice().Add(b));
                }
                ECFieldElement rawYCoord       = base.RawYCoord;
                ECFieldElement eCFieldElement2 = base.RawZCoords[0];
                ECFieldElement rawYCoord2      = b.RawYCoord;
                ECFieldElement x  = rawXCoord.Square();
                ECFieldElement b2 = rawYCoord.Square();
                ECFieldElement eCFieldElement3 = eCFieldElement2.Square();
                ECFieldElement b3 = rawYCoord.Multiply(eCFieldElement2);
                ECFieldElement b4 = curve.A.Multiply(eCFieldElement3).Add(b2).Add(b3);
                ECFieldElement eCFieldElement4 = rawYCoord2.AddOne();
                ECFieldElement eCFieldElement5 = curve.A.Add(eCFieldElement4).Multiply(eCFieldElement3).Add(b2)
                                                 .MultiplyPlusProduct(b4, x, eCFieldElement3);
                ECFieldElement eCFieldElement6 = rawXCoord2.Multiply(eCFieldElement3);
                ECFieldElement eCFieldElement7 = eCFieldElement6.Add(b4).Square();
                if (eCFieldElement7.IsZero)
                {
                    if (eCFieldElement5.IsZero)
                    {
                        return(b.Twice());
                    }
                    return(curve.Infinity);
                }
                if (eCFieldElement5.IsZero)
                {
                    return(new F2mPoint(curve, eCFieldElement5, curve.B.Sqrt(), base.IsCompressed));
                }
                ECFieldElement x2 = eCFieldElement5.Square().Multiply(eCFieldElement6);
                ECFieldElement eCFieldElement8 = eCFieldElement5.Multiply(eCFieldElement7).Multiply(eCFieldElement3);
                ECFieldElement y = eCFieldElement5.Add(eCFieldElement7).Square().MultiplyPlusProduct(b4, eCFieldElement4, eCFieldElement8);
                return(new F2mPoint(curve, x2, y, new ECFieldElement[1]
                {
                    eCFieldElement8
                }, base.IsCompressed));
            }
            return(Twice().Add(b));
        }
示例#6
0
        public override ECPoint Twice()
        {
            if (base.IsInfinity)
            {
                return(this);
            }
            ECCurve        curve     = Curve;
            ECFieldElement rawXCoord = base.RawXCoord;

            if (!rawXCoord.IsZero)
            {
                switch (curve.CoordinateSystem)
                {
                case 0:
                {
                    ECFieldElement rawYCoord2       = base.RawYCoord;
                    ECFieldElement eCFieldElement11 = rawYCoord2.Divide(rawXCoord).Add(rawXCoord);
                    ECFieldElement x = eCFieldElement11.Square().Add(eCFieldElement11).Add(curve.A);
                    ECFieldElement y = rawXCoord.SquarePlusProduct(x, eCFieldElement11.AddOne());
                    return(new F2mPoint(curve, x, y, base.IsCompressed));
                }

                case 1:
                {
                    ECFieldElement rawYCoord3       = base.RawYCoord;
                    ECFieldElement eCFieldElement12 = base.RawZCoords[0];
                    bool           isOne2           = eCFieldElement12.IsOne;
                    ECFieldElement eCFieldElement13 = (!isOne2) ? rawXCoord.Multiply(eCFieldElement12) : rawXCoord;
                    ECFieldElement b3 = (!isOne2) ? rawYCoord3.Multiply(eCFieldElement12) : rawYCoord3;
                    ECFieldElement eCFieldElement14 = rawXCoord.Square();
                    ECFieldElement eCFieldElement15 = eCFieldElement14.Add(b3);
                    ECFieldElement eCFieldElement16 = eCFieldElement13;
                    ECFieldElement eCFieldElement17 = eCFieldElement16.Square();
                    ECFieldElement eCFieldElement18 = eCFieldElement15.Add(eCFieldElement16);
                    ECFieldElement eCFieldElement19 = eCFieldElement18.MultiplyPlusProduct(eCFieldElement15, eCFieldElement17, curve.A);
                    ECFieldElement x2 = eCFieldElement16.Multiply(eCFieldElement19);
                    ECFieldElement y2 = eCFieldElement14.Square().MultiplyPlusProduct(eCFieldElement16, eCFieldElement19, eCFieldElement18);
                    ECFieldElement eCFieldElement20 = eCFieldElement16.Multiply(eCFieldElement17);
                    return(new F2mPoint(curve, x2, y2, new ECFieldElement[1]
                        {
                            eCFieldElement20
                        }, base.IsCompressed));
                }

                case 6:
                {
                    ECFieldElement rawYCoord       = base.RawYCoord;
                    ECFieldElement eCFieldElement  = base.RawZCoords[0];
                    bool           isOne           = eCFieldElement.IsOne;
                    ECFieldElement eCFieldElement2 = (!isOne) ? rawYCoord.Multiply(eCFieldElement) : rawYCoord;
                    ECFieldElement eCFieldElement3 = (!isOne) ? eCFieldElement.Square() : eCFieldElement;
                    ECFieldElement a = curve.A;
                    ECFieldElement eCFieldElement4 = (!isOne) ? a.Multiply(eCFieldElement3) : a;
                    ECFieldElement eCFieldElement5 = rawYCoord.Square().Add(eCFieldElement2).Add(eCFieldElement4);
                    if (eCFieldElement5.IsZero)
                    {
                        return(new F2mPoint(curve, eCFieldElement5, curve.B.Sqrt(), base.IsCompressed));
                    }
                    ECFieldElement eCFieldElement6 = eCFieldElement5.Square();
                    ECFieldElement eCFieldElement7 = (!isOne) ? eCFieldElement5.Multiply(eCFieldElement3) : eCFieldElement5;
                    ECFieldElement b = curve.B;
                    ECFieldElement eCFieldElement9;
                    if (b.BitLength < curve.FieldSize >> 1)
                    {
                        ECFieldElement eCFieldElement8 = rawYCoord.Add(rawXCoord).Square();
                        ECFieldElement b2 = (!b.IsOne) ? eCFieldElement4.SquarePlusProduct(b, eCFieldElement3.Square()) : eCFieldElement4.Add(eCFieldElement3).Square();
                        eCFieldElement9 = eCFieldElement8.Add(eCFieldElement5).Add(eCFieldElement3).Multiply(eCFieldElement8)
                                          .Add(b2)
                                          .Add(eCFieldElement6);
                        if (a.IsZero)
                        {
                            eCFieldElement9 = eCFieldElement9.Add(eCFieldElement7);
                        }
                        else if (!a.IsOne)
                        {
                            eCFieldElement9 = eCFieldElement9.Add(a.AddOne().Multiply(eCFieldElement7));
                        }
                    }
                    else
                    {
                        ECFieldElement eCFieldElement10 = (!isOne) ? rawXCoord.Multiply(eCFieldElement) : rawXCoord;
                        eCFieldElement9 = eCFieldElement10.SquarePlusProduct(eCFieldElement5, eCFieldElement2).Add(eCFieldElement6).Add(eCFieldElement7);
                    }
                    return(new F2mPoint(curve, eCFieldElement6, eCFieldElement9, new ECFieldElement[1]
                        {
                            eCFieldElement7
                        }, base.IsCompressed));
                }

                default:
                    throw new InvalidOperationException("unsupported coordinate system");
                }
            }
            return(curve.Infinity);
        }
示例#7
0
        public override ECPoint Twice()
        {
            ECFieldElement element26;
            ECFieldElement element27;
            ECFieldElement element29;

            if (base.IsInfinity)
            {
                return(this);
            }
            ECCurve        curve     = this.Curve;
            ECFieldElement rawXCoord = base.RawXCoord;

            if (rawXCoord.IsZero)
            {
                return(curve.Infinity);
            }
            switch (curve.CoordinateSystem)
            {
            case 0:
            {
                ECFieldElement b = base.RawYCoord.Divide(rawXCoord).Add(rawXCoord);
                ECFieldElement x = b.Square().Add(b).Add(curve.A);
                return(new F2mPoint(curve, x, rawXCoord.SquarePlusProduct(x, b.AddOne()), base.IsCompressed));
            }

            case 1:
            {
                ECFieldElement rawYCoord = base.RawYCoord;
                ECFieldElement b         = base.RawZCoords[0];
                bool           isOne     = b.IsOne;
                ECFieldElement element8  = !isOne?rawXCoord.Multiply(b) : rawXCoord;

                ECFieldElement element9 = !isOne?rawYCoord.Multiply(b) : rawYCoord;

                ECFieldElement element10 = rawXCoord.Square();
                ECFieldElement element11 = element10.Add(element9);
                ECFieldElement element12 = element8;
                ECFieldElement x         = element12.Square();
                ECFieldElement y         = element11.Add(element12);
                ECFieldElement element15 = y.MultiplyPlusProduct(element11, x, curve.A);
                ECFieldElement element16 = element12.Multiply(element15);
                ECFieldElement element17 = element10.Square().MultiplyPlusProduct(element12, element15, y);
                ECFieldElement element18 = element12.Multiply(x);
                return(new F2mPoint(curve, element16, element17, new ECFieldElement[] { element18 }, base.IsCompressed));
            }

            case 6:
            {
                ECFieldElement element31;
                ECFieldElement rawYCoord = base.RawYCoord;
                ECFieldElement b         = base.RawZCoords[0];
                bool           isOne     = b.IsOne;
                ECFieldElement element21 = !isOne?rawYCoord.Multiply(b) : rawYCoord;

                ECFieldElement element22 = !isOne?b.Square() : b;

                ECFieldElement a         = curve.A;
                ECFieldElement element24 = !isOne?a.Multiply(element22) : a;

                ECFieldElement x = rawYCoord.Square().Add(element21).Add(element24);
                if (x.IsZero)
                {
                    return(new F2mPoint(curve, x, curve.B.Sqrt(), base.IsCompressed));
                }
                element26 = x.Square();
                element27 = !isOne?x.Multiply(element22) : x;

                ECFieldElement element28 = curve.B;
                if (element28.BitLength >= (curve.FieldSize >> 1))
                {
                    ECFieldElement element32 = !isOne?rawXCoord.Multiply(b) : rawXCoord;

                    element29 = element32.SquarePlusProduct(x, element21).Add(element26).Add(element27);
                    break;
                }
                ECFieldElement element30 = rawYCoord.Add(rawXCoord).Square();
                if (element28.IsOne)
                {
                    element31 = element24.Add(element22).Square();
                }
                else
                {
                    element31 = element24.SquarePlusProduct(element28, element22.Square());
                }
                element29 = element30.Add(x).Add(element22).Multiply(element30).Add(element31).Add(element26);
                if (a.IsZero)
                {
                    element29 = element29.Add(element27);
                }
                else if (!a.IsOne)
                {
                    element29 = element29.Add(a.AddOne().Multiply(element27));
                }
                break;
            }

            default:
                throw new InvalidOperationException("unsupported coordinate system");
            }
            return(new F2mPoint(curve, element26, element29, new ECFieldElement[] { element27 }, base.IsCompressed));
        }
示例#8
0
        public override ECPoint Twice()
        {
            if (base.IsInfinity)
            {
                return(this);
            }
            ECCurve        curve     = this.Curve;
            ECFieldElement rawXCoord = base.RawXCoord;

            if (rawXCoord.IsZero)
            {
                return(curve.Infinity);
            }
            int coordinateSystem = curve.CoordinateSystem;
            int num = coordinateSystem;

            switch (num)
            {
            case 0:
            {
                ECFieldElement rawYCoord      = base.RawYCoord;
                ECFieldElement eCFieldElement = rawYCoord.Divide(rawXCoord).Add(rawXCoord);
                ECFieldElement x = eCFieldElement.Square().Add(eCFieldElement).Add(curve.A);
                ECFieldElement y = rawXCoord.SquarePlusProduct(x, eCFieldElement.AddOne());
                return(new F2mPoint(curve, x, y, base.IsCompressed));
            }

            case 1:
            {
                ECFieldElement rawYCoord2      = base.RawYCoord;
                ECFieldElement eCFieldElement2 = base.RawZCoords[0];
                bool           isOne           = eCFieldElement2.IsOne;
                ECFieldElement eCFieldElement3 = isOne ? rawXCoord : rawXCoord.Multiply(eCFieldElement2);
                ECFieldElement b = isOne ? rawYCoord2 : rawYCoord2.Multiply(eCFieldElement2);
                ECFieldElement eCFieldElement4 = rawXCoord.Square();
                ECFieldElement eCFieldElement5 = eCFieldElement4.Add(b);
                ECFieldElement eCFieldElement6 = eCFieldElement3;
                ECFieldElement eCFieldElement7 = eCFieldElement6.Square();
                ECFieldElement eCFieldElement8 = eCFieldElement5.Add(eCFieldElement6);
                ECFieldElement eCFieldElement9 = eCFieldElement8.MultiplyPlusProduct(eCFieldElement5, eCFieldElement7, curve.A);
                ECFieldElement x2 = eCFieldElement6.Multiply(eCFieldElement9);
                ECFieldElement y2 = eCFieldElement4.Square().MultiplyPlusProduct(eCFieldElement6, eCFieldElement9, eCFieldElement8);
                ECFieldElement eCFieldElement10 = eCFieldElement6.Multiply(eCFieldElement7);
                return(new F2mPoint(curve, x2, y2, new ECFieldElement[]
                    {
                        eCFieldElement10
                    }, base.IsCompressed));
            }

            default:
            {
                if (num != 6)
                {
                    throw new InvalidOperationException("unsupported coordinate system");
                }
                ECFieldElement rawYCoord3       = base.RawYCoord;
                ECFieldElement eCFieldElement11 = base.RawZCoords[0];
                bool           isOne2           = eCFieldElement11.IsOne;
                ECFieldElement eCFieldElement12 = isOne2 ? rawYCoord3 : rawYCoord3.Multiply(eCFieldElement11);
                ECFieldElement eCFieldElement13 = isOne2 ? eCFieldElement11 : eCFieldElement11.Square();
                ECFieldElement a = curve.A;
                ECFieldElement eCFieldElement14 = isOne2 ? a : a.Multiply(eCFieldElement13);
                ECFieldElement eCFieldElement15 = rawYCoord3.Square().Add(eCFieldElement12).Add(eCFieldElement14);
                if (eCFieldElement15.IsZero)
                {
                    return(new F2mPoint(curve, eCFieldElement15, curve.B.Sqrt(), base.IsCompressed));
                }
                ECFieldElement eCFieldElement16 = eCFieldElement15.Square();
                ECFieldElement eCFieldElement17 = isOne2 ? eCFieldElement15 : eCFieldElement15.Multiply(eCFieldElement13);
                ECFieldElement b2 = curve.B;
                ECFieldElement eCFieldElement19;
                if (b2.BitLength < curve.FieldSize >> 1)
                {
                    ECFieldElement eCFieldElement18 = rawYCoord3.Add(rawXCoord).Square();
                    ECFieldElement b3;
                    if (b2.IsOne)
                    {
                        b3 = eCFieldElement14.Add(eCFieldElement13).Square();
                    }
                    else
                    {
                        b3 = eCFieldElement14.SquarePlusProduct(b2, eCFieldElement13.Square());
                    }
                    eCFieldElement19 = eCFieldElement18.Add(eCFieldElement15).Add(eCFieldElement13).Multiply(eCFieldElement18).Add(b3).Add(eCFieldElement16);
                    if (a.IsZero)
                    {
                        eCFieldElement19 = eCFieldElement19.Add(eCFieldElement17);
                    }
                    else if (!a.IsOne)
                    {
                        eCFieldElement19 = eCFieldElement19.Add(a.AddOne().Multiply(eCFieldElement17));
                    }
                }
                else
                {
                    ECFieldElement eCFieldElement20 = isOne2 ? rawXCoord : rawXCoord.Multiply(eCFieldElement11);
                    eCFieldElement19 = eCFieldElement20.SquarePlusProduct(eCFieldElement15, eCFieldElement12).Add(eCFieldElement16).Add(eCFieldElement17);
                }
                return(new F2mPoint(curve, eCFieldElement16, eCFieldElement19, new ECFieldElement[]
                    {
                        eCFieldElement17
                    }, base.IsCompressed));
            }
            }
        }