IsEccCipherSuite() public static method

public static IsEccCipherSuite ( int cipherSuite ) : bool
cipherSuite int
return bool
Beispiel #1
0
        public virtual int GetSelectedCipherSuite()
        {
            /*
             * TODO RFC 5246 7.4.3. In order to negotiate correctly, the server MUST check any candidate
             * cipher suites against the "signature_algorithms" extension before selecting them. This is
             * somewhat inelegant but is a compromise designed to minimize changes to the original
             * cipher suite design.
             */

            /*
             * RFC 4429 5.1. A server that receives a ClientHello containing one or both of these
             * extensions MUST use the client's enumerated capabilities to guide its selection of an
             * appropriate cipher suite. One of the proposed ECC cipher suites must be negotiated only
             * if the server can successfully complete the handshake while using the curves and point
             * formats supported by the client [...].
             */
            bool eccCipherSuitesEnabled = SupportsClientEccCapabilities(this.mNamedCurves, this.mClientECPointFormats);

            int[] cipherSuites = GetCipherSuites();
            for (int i = 0; i < cipherSuites.Length; ++i)
            {
                int cipherSuite = cipherSuites[i];

                if (Arrays.Contains(this.mOfferedCipherSuites, cipherSuite) &&
                    (eccCipherSuitesEnabled || !TlsEccUtilities.IsEccCipherSuite(cipherSuite)) &&
                    TlsUtilities.IsValidCipherSuiteForVersion(cipherSuite, mServerVersion))
                {
                    return(this.mSelectedCipherSuite = cipherSuite);
                }
            }
            throw new TlsFatalAlert(AlertDescription.handshake_failure);
        }
Beispiel #2
0
        public virtual void ProcessServerExtensions(IDictionary serverExtensions)
        {
            /*
             * TlsProtocol implementation validates that any server extensions received correspond to
             * client extensions sent. By default, we don't send any, and this method is not called.
             */
            if (serverExtensions != null)
            {
                /*
                 * RFC 5246 7.4.1.4.1. Servers MUST NOT send this extension.
                 */
                if (serverExtensions.Contains(ExtensionType.signature_algorithms))
                {
                    throw new TlsFatalAlert(AlertDescription.illegal_parameter);
                }

                int[] namedCurves = TlsEccUtilities.GetSupportedEllipticCurvesExtension(serverExtensions);
                if (namedCurves != null)
                {
                    throw new TlsFatalAlert(AlertDescription.illegal_parameter);
                }

                this.mServerECPointFormats = TlsEccUtilities.GetSupportedPointFormatsExtension(serverExtensions);
                if (this.mServerECPointFormats != null && !TlsEccUtilities.IsEccCipherSuite(this.mSelectedCipherSuite))
                {
                    throw new TlsFatalAlert(AlertDescription.illegal_parameter);
                }
            }
        }
Beispiel #3
0
        public virtual void ProcessServerExtensions(IDictionary serverExtensions)
        {
            /*
             * TlsProtocol implementation validates that any server extensions received correspond to
             * client extensions sent. By default, we don't send any, and this method is not called.
             */
            if (serverExtensions != null)
            {
                /*
                 * RFC 5246 7.4.1.4.1. Servers MUST NOT send this extension.
                 */
                CheckForUnexpectedServerExtension(serverExtensions, ExtensionType.signature_algorithms);

                CheckForUnexpectedServerExtension(serverExtensions, ExtensionType.elliptic_curves);

                if (TlsEccUtilities.IsEccCipherSuite(this.mSelectedCipherSuite))
                {
                    this.mServerECPointFormats = TlsEccUtilities.GetSupportedPointFormatsExtension(serverExtensions);
                }
                else
                {
                    CheckForUnexpectedServerExtension(serverExtensions, ExtensionType.ec_point_formats);
                }
            }
        }
 public virtual IDictionary GetServerExtensions()
 {
     if (mEncryptThenMacOffered && AllowEncryptThenMac && TlsUtilities.IsBlockCipherSuite(mSelectedCipherSuite))
     {
         TlsExtensionsUtilities.AddEncryptThenMacExtension(CheckServerExtensions());
     }
     if (mMaxFragmentLengthOffered >= 0 && TlsUtilities.IsValidUint8(mMaxFragmentLengthOffered) && MaxFragmentLength.IsValid((byte)mMaxFragmentLengthOffered))
     {
         TlsExtensionsUtilities.AddMaxFragmentLengthExtension(CheckServerExtensions(), (byte)mMaxFragmentLengthOffered);
     }
     if (mTruncatedHMacOffered && AllowTruncatedHMac)
     {
         TlsExtensionsUtilities.AddTruncatedHMacExtension(CheckServerExtensions());
     }
     if (mClientECPointFormats != null && TlsEccUtilities.IsEccCipherSuite(mSelectedCipherSuite))
     {
         mServerECPointFormats = new byte[3]
         {
             0,
             1,
             2
         };
         TlsEccUtilities.AddSupportedPointFormatsExtension(CheckServerExtensions(), mServerECPointFormats);
     }
     return(mServerExtensions);
 }
 public static bool ContainsEccCipherSuites(int[] cipherSuites)
 {
     for (int i = 0; i < cipherSuites.Length; i++)
     {
         if (TlsEccUtilities.IsEccCipherSuite(cipherSuites[i]))
         {
             return(true);
         }
     }
     return(false);
 }
Beispiel #6
0
        public virtual int GetSelectedCipherSuite()
        {
            bool flag = this.SupportsClientEccCapabilities(this.mNamedCurves, this.mClientECPointFormats);

            foreach (int num2 in this.GetCipherSuites())
            {
                if ((Arrays.Contains(this.mOfferedCipherSuites, num2) && (flag || !TlsEccUtilities.IsEccCipherSuite(num2))) && TlsUtilities.IsValidCipherSuiteForVersion(num2, this.mServerVersion))
                {
                    return(this.mSelectedCipherSuite = num2);
                }
            }
            throw new TlsFatalAlert(40);
        }
        public virtual int GetSelectedCipherSuite()
        {
            bool flag = SupportsClientEccCapabilities(mNamedCurves, mClientECPointFormats);

            int[] cipherSuites = GetCipherSuites();
            foreach (int num in cipherSuites)
            {
                if (Arrays.Contains(mOfferedCipherSuites, num) && (flag || !TlsEccUtilities.IsEccCipherSuite(num)) && TlsUtilities.IsValidCipherSuiteForVersion(num, mServerVersion))
                {
                    return(mSelectedCipherSuite = num);
                }
            }
            throw new TlsFatalAlert(40);
        }
 public virtual void ProcessServerExtensions(IDictionary serverExtensions)
 {
     if (serverExtensions != null)
     {
         this.CheckForUnexpectedServerExtension(serverExtensions, 13);
         this.CheckForUnexpectedServerExtension(serverExtensions, 10);
         if (TlsEccUtilities.IsEccCipherSuite(this.mSelectedCipherSuite))
         {
             this.mServerECPointFormats = TlsEccUtilities.GetSupportedPointFormatsExtension(serverExtensions);
             return;
         }
         this.CheckForUnexpectedServerExtension(serverExtensions, 11);
     }
 }
        public virtual int GetSelectedCipherSuite()
        {
            bool flag = this.SupportsClientEccCapabilities(this.mNamedCurves, this.mClientECPointFormats);

            int[] cipherSuites = this.GetCipherSuites();
            for (int i = 0; i < cipherSuites.Length; i++)
            {
                int num = cipherSuites[i];
                if (Arrays.Contains(this.mOfferedCipherSuites, num) && (flag || !TlsEccUtilities.IsEccCipherSuite(num)) && TlsUtilities.IsValidCipherSuiteForVersion(num, this.mServerVersion))
                {
                    return(this.mSelectedCipherSuite = num);
                }
            }
            throw new TlsFatalAlert(40);
        }
Beispiel #10
0
        // IDictionary is (Int32 -> byte[])
        public virtual IDictionary GetServerExtensions()
        {
            if (this.mEncryptThenMacOffered && AllowEncryptThenMac)
            {
                /*
                 * RFC 7366 3. If a server receives an encrypt-then-MAC request extension from a client
                 * and then selects a stream or Authenticated Encryption with Associated Data (AEAD)
                 * ciphersuite, it MUST NOT send an encrypt-then-MAC response extension back to the
                 * client.
                 */
                if (TlsUtilities.IsBlockCipherSuite(this.mSelectedCipherSuite))
                {
                    TlsExtensionsUtilities.AddEncryptThenMacExtension(CheckServerExtensions());
                }
            }

            if (this.mMaxFragmentLengthOffered >= 0 &&
                TlsUtilities.IsValidUint8(mMaxFragmentLengthOffered) &&
                MaxFragmentLength.IsValid((byte)mMaxFragmentLengthOffered))
            {
                TlsExtensionsUtilities.AddMaxFragmentLengthExtension(CheckServerExtensions(), (byte)mMaxFragmentLengthOffered);
            }

            if (this.mTruncatedHMacOffered && AllowTruncatedHMac)
            {
                TlsExtensionsUtilities.AddTruncatedHMacExtension(CheckServerExtensions());
            }

            if (this.mClientECPointFormats != null && TlsEccUtilities.IsEccCipherSuite(this.mSelectedCipherSuite))
            {
                /*
                 * RFC 4492 5.2. A server that selects an ECC cipher suite in response to a ClientHello
                 * message including a Supported Point Formats Extension appends this extension (along
                 * with others) to its ServerHello message, enumerating the point formats it can parse.
                 */
                this.mServerECPointFormats = new byte[] { ECPointFormat.uncompressed,
                                                          ECPointFormat.ansiX962_compressed_prime, ECPointFormat.ansiX962_compressed_char2, };

                TlsEccUtilities.AddSupportedPointFormatsExtension(CheckServerExtensions(), mServerECPointFormats);
            }

            return(mServerExtensions);
        }
Beispiel #11
0
 public virtual IDictionary GetServerExtensions()
 {
     if ((this.mEncryptThenMacOffered && this.AllowEncryptThenMac) && TlsUtilities.IsBlockCipherSuite(this.mSelectedCipherSuite))
     {
         TlsExtensionsUtilities.AddEncryptThenMacExtension(this.CheckServerExtensions());
     }
     if (((this.mMaxFragmentLengthOffered >= 0) && TlsUtilities.IsValidUint8((int)this.mMaxFragmentLengthOffered)) && MaxFragmentLength.IsValid((byte)this.mMaxFragmentLengthOffered))
     {
         TlsExtensionsUtilities.AddMaxFragmentLengthExtension(this.CheckServerExtensions(), (byte)this.mMaxFragmentLengthOffered);
     }
     if (this.mTruncatedHMacOffered && this.AllowTruncatedHMac)
     {
         TlsExtensionsUtilities.AddTruncatedHMacExtension(this.CheckServerExtensions());
     }
     if ((this.mClientECPointFormats != null) && TlsEccUtilities.IsEccCipherSuite(this.mSelectedCipherSuite))
     {
         byte[] buffer1 = new byte[3];
         buffer1[1] = 1;
         buffer1[2] = 2;
         this.mServerECPointFormats = buffer1;
         TlsEccUtilities.AddSupportedPointFormatsExtension(this.CheckServerExtensions(), this.mServerECPointFormats);
     }
     return(this.mServerExtensions);
 }