Пример #1
0
        public static ECDomainParameters ReadECParameters(int[] namedCurves, byte[] ecPointFormats, Stream input)
        {
            try
            {
                switch (TlsUtilities.ReadUint8(input))
                {
                case 1:
                {
                    CheckNamedCurve(namedCurves, 65281);
                    BigInteger bigInteger3 = ReadECParameter(input);
                    BigInteger a2          = ReadECFieldElement(bigInteger3.BitLength, input);
                    BigInteger b3          = ReadECFieldElement(bigInteger3.BitLength, input);
                    byte[]     encoding2   = TlsUtilities.ReadOpaque8(input);
                    BigInteger bigInteger4 = ReadECParameter(input);
                    BigInteger bigInteger5 = ReadECParameter(input);
                    ECCurve    curve2      = new FpCurve(bigInteger3, a2, b3, bigInteger4, bigInteger5);
                    ECPoint    g2          = DeserializeECPoint(ecPointFormats, curve2, encoding2);
                    return(new ECDomainParameters(curve2, g2, bigInteger4, bigInteger5));
                }

                case 2:
                {
                    CheckNamedCurve(namedCurves, 65282);
                    int  num = TlsUtilities.ReadUint16(input);
                    byte b   = TlsUtilities.ReadUint8(input);
                    if (!ECBasisType.IsValid(b))
                    {
                        throw new TlsFatalAlert(47);
                    }
                    int num2 = ReadECExponent(num, input);
                    int k    = -1;
                    int k2   = -1;
                    if (b == 2)
                    {
                        k  = ReadECExponent(num, input);
                        k2 = ReadECExponent(num, input);
                    }
                    BigInteger a           = ReadECFieldElement(num, input);
                    BigInteger b2          = ReadECFieldElement(num, input);
                    byte[]     encoding    = TlsUtilities.ReadOpaque8(input);
                    BigInteger bigInteger  = ReadECParameter(input);
                    BigInteger bigInteger2 = ReadECParameter(input);
                    ECCurve    curve       = (b != 2) ? new F2mCurve(num, num2, a, b2, bigInteger, bigInteger2) : new F2mCurve(num, num2, k, k2, a, b2, bigInteger, bigInteger2);
                    ECPoint    g           = DeserializeECPoint(ecPointFormats, curve, encoding);
                    return(new ECDomainParameters(curve, g, bigInteger, bigInteger2));
                }

                case 3:
                {
                    int namedCurve = TlsUtilities.ReadUint16(input);
                    if (!NamedCurve.RefersToASpecificNamedCurve(namedCurve))
                    {
                        throw new TlsFatalAlert(47);
                    }
                    CheckNamedCurve(namedCurves, namedCurve);
                    return(GetParametersForNamedCurve(namedCurve));
                }

                default:
                    throw new TlsFatalAlert(47);
                }
IL_01ac:
                ECDomainParameters result;
                return(result);
            }
            catch (Exception alertCause)
            {
                throw new TlsFatalAlert(47, alertCause);
IL_01bd:
                ECDomainParameters result;
                return(result);
            }
        }
Пример #2
0
        public static ECDomainParameters ReadECParameters(int[] namedCurves, byte[] ecPointFormats, Stream input)
        {
            try
            {
                byte curveType = TlsUtilities.ReadUint8(input);

                switch (curveType)
                {
                case ECCurveType.explicit_prime:
                {
                    CheckNamedCurve(namedCurves, NamedCurve.arbitrary_explicit_prime_curves);

                    BigInteger prime_p      = ReadECParameter(input);
                    BigInteger a            = ReadECFieldElement(prime_p.BitLength, input);
                    BigInteger b            = ReadECFieldElement(prime_p.BitLength, input);
                    byte[]     baseEncoding = TlsUtilities.ReadOpaque8(input);
                    BigInteger order        = ReadECParameter(input);
                    BigInteger cofactor     = ReadECParameter(input);
                    ECCurve    curve        = new FpCurve(prime_p, a, b, order, cofactor);
                    ECPoint    basePoint    = DeserializeECPoint(ecPointFormats, curve, baseEncoding);
                    return(new ECDomainParameters(curve, basePoint, order, cofactor));
                }

                case ECCurveType.explicit_char2:
                {
                    CheckNamedCurve(namedCurves, NamedCurve.arbitrary_explicit_char2_curves);

                    int  m     = TlsUtilities.ReadUint16(input);
                    byte basis = TlsUtilities.ReadUint8(input);
                    if (!ECBasisType.IsValid(basis))
                    {
                        throw new TlsFatalAlert(AlertDescription.illegal_parameter);
                    }

                    int k1 = ReadECExponent(m, input), k2 = -1, k3 = -1;
                    if (basis == ECBasisType.ec_basis_pentanomial)
                    {
                        k2 = ReadECExponent(m, input);
                        k3 = ReadECExponent(m, input);
                    }

                    BigInteger a            = ReadECFieldElement(m, input);
                    BigInteger b            = ReadECFieldElement(m, input);
                    byte[]     baseEncoding = TlsUtilities.ReadOpaque8(input);
                    BigInteger order        = ReadECParameter(input);
                    BigInteger cofactor     = ReadECParameter(input);

                    ECCurve curve = (basis == ECBasisType.ec_basis_pentanomial)
                        ? new F2mCurve(m, k1, k2, k3, a, b, order, cofactor)
                        : new F2mCurve(m, k1, a, b, order, cofactor);

                    ECPoint basePoint = DeserializeECPoint(ecPointFormats, curve, baseEncoding);

                    return(new ECDomainParameters(curve, basePoint, order, cofactor));
                }

                case ECCurveType.named_curve:
                {
                    int namedCurve = TlsUtilities.ReadUint16(input);
                    if (!NamedCurve.RefersToASpecificNamedCurve(namedCurve))
                    {
                        /*
                         * RFC 4492 5.4. All those values of NamedCurve are allowed that refer to a
                         * specific curve. Values of NamedCurve that indicate support for a class of
                         * explicitly defined curves are not allowed here [...].
                         */
                        throw new TlsFatalAlert(AlertDescription.illegal_parameter);
                    }

                    CheckNamedCurve(namedCurves, namedCurve);

                    return(GetParametersForNamedCurve(namedCurve));
                }

                default:
                    throw new TlsFatalAlert(AlertDescription.illegal_parameter);
                }
            }
            catch (Exception e)
            {
                throw new TlsFatalAlert(AlertDescription.illegal_parameter, e);
            }
        }
Пример #3
0
        public static ECDomainParameters ReadECParameters(int[] namedCurves, byte[] ecPointFormats, Stream input)
        {
            ECDomainParameters parametersForNamedCurve;

            try
            {
                int  num2;
                byte num3;
                int  num7;
                switch (TlsUtilities.ReadUint8(input))
                {
                case 1:
                {
                    CheckNamedCurve(namedCurves, 0xff01);
                    BigInteger q        = ReadECParameter(input);
                    BigInteger integer2 = ReadECFieldElement(q.BitLength, input);
                    BigInteger integer3 = ReadECFieldElement(q.BitLength, input);
                    byte[]     buffer   = TlsUtilities.ReadOpaque8(input);
                    BigInteger integer4 = ReadECParameter(input);
                    BigInteger integer5 = ReadECParameter(input);
                    ECCurve    curve    = new FpCurve(q, integer2, integer3, integer4, integer5);
                    return(new ECDomainParameters(curve, DeserializeECPoint(ecPointFormats, curve, buffer), integer4, integer5));
                }

                case 2:
                    CheckNamedCurve(namedCurves, 0xff02);
                    num2 = TlsUtilities.ReadUint16(input);
                    num3 = TlsUtilities.ReadUint8(input);
                    if (!ECBasisType.IsValid(num3))
                    {
                        throw new TlsFatalAlert(0x2f);
                    }
                    break;

                case 3:
                    num7 = TlsUtilities.ReadUint16(input);
                    if (!NamedCurve.RefersToASpecificNamedCurve(num7))
                    {
                        throw new TlsFatalAlert(0x2f);
                    }
                    goto Label_018A;

                default:
                    throw new TlsFatalAlert(0x2f);
                }
                int k    = ReadECExponent(num2, input);
                int num5 = -1;
                int num6 = -1;
                if (num3 == 2)
                {
                    num5 = ReadECExponent(num2, input);
                    num6 = ReadECExponent(num2, input);
                }
                BigInteger a        = ReadECFieldElement(num2, input);
                BigInteger b        = ReadECFieldElement(num2, input);
                byte[]     encoding = TlsUtilities.ReadOpaque8(input);
                BigInteger order    = ReadECParameter(input);
                BigInteger cofactor = ReadECParameter(input);
                ECCurve    curve2   = (num3 != 2) ? new F2mCurve(num2, k, a, b, order, cofactor) : new F2mCurve(num2, k, num5, num6, a, b, order, cofactor);
                return(new ECDomainParameters(curve2, DeserializeECPoint(ecPointFormats, curve2, encoding), order, cofactor));

Label_018A:
                CheckNamedCurve(namedCurves, num7);
                parametersForNamedCurve = GetParametersForNamedCurve(num7);
            }
            catch (Exception exception)
            {
                throw new TlsFatalAlert(0x2f, exception);
            }
            return(parametersForNamedCurve);
        }