< prev index next >

src/java.base/share/classes/sun/security/ssl/ServerHello.java

Print this page




  30 import java.security.AlgorithmConstraints;
  31 import java.security.GeneralSecurityException;
  32 import java.text.MessageFormat;
  33 import java.util.Arrays;
  34 import java.util.LinkedList;
  35 import java.util.List;
  36 import java.util.Locale;
  37 import java.util.Map;
  38 import javax.crypto.SecretKey;
  39 import javax.crypto.spec.IvParameterSpec;
  40 import javax.net.ssl.SSLException;
  41 import javax.net.ssl.SSLHandshakeException;
  42 import javax.net.ssl.SSLProtocolException;
  43 import sun.security.ssl.CipherSuite.KeyExchange;
  44 import sun.security.ssl.ClientHello.ClientHelloMessage;
  45 import sun.security.ssl.SSLCipher.SSLReadCipher;
  46 import sun.security.ssl.SSLCipher.SSLWriteCipher;
  47 import sun.security.ssl.SSLHandshake.HandshakeMessage;
  48 import sun.security.ssl.SupportedVersionsExtension.SHSupportedVersionsSpec;
  49 
  50 import static sun.security.ssl.SSLExtension.SH_SESSION_TICKET;
  51 
  52 /**
  53  * Pack of the ServerHello/HelloRetryRequest handshake message.
  54  */
  55 final class ServerHello {
  56     static final SSLConsumer handshakeConsumer =
  57         new ServerHelloConsumer();
  58     static final HandshakeProducer t12HandshakeProducer =
  59         new T12ServerHelloProducer();
  60     static final HandshakeProducer t13HandshakeProducer =
  61         new T13ServerHelloProducer();
  62     static final HandshakeProducer hrrHandshakeProducer =
  63         new T13HelloRetryRequestProducer();
  64 
  65     static final HandshakeProducer hrrReproducer =
  66         new T13HelloRetryRequestReproducer();
  67 
  68     private static final HandshakeConsumer t12HandshakeConsumer =
  69         new T12ServerHelloConsumer();
  70     private static final HandshakeConsumer t13HandshakeConsumer =
  71         new T13ServerHelloConsumer();


 322                     }
 323                 }
 324 
 325                 if ((ke != null) &&
 326                         (shc.sslConfig.clientAuthType !=
 327                                 ClientAuthType.CLIENT_AUTH_NONE) &&
 328                         !shc.negotiatedCipherSuite.isAnonymous()) {
 329                     for (SSLHandshake hs :
 330                             ke.getRelatedHandshakers(shc)) {
 331                         if (hs == SSLHandshake.CERTIFICATE) {
 332                             shc.handshakeProducers.put(
 333                                     SSLHandshake.CERTIFICATE_REQUEST.id,
 334                                     SSLHandshake.CERTIFICATE_REQUEST);
 335                             break;
 336                         }
 337                     }
 338                 }
 339                 shc.handshakeProducers.put(SSLHandshake.SERVER_HELLO_DONE.id,
 340                         SSLHandshake.SERVER_HELLO_DONE);
 341             } else {
 342                 // stateless and use the client session id (RFC 5077 3.4)
 343                 if (shc.statelessResumption) {
 344                     shc.resumingSession = new SSLSessionImpl(shc.resumingSession,
 345                             (clientHello.sessionId.length() == 0) ?
 346                                     new SessionId(true,
 347                                             shc.sslContext.getSecureRandom()) :
 348                                     new SessionId(clientHello.sessionId.getId())
 349                     );
 350                 }
 351                 shc.handshakeSession = shc.resumingSession;
 352                 shc.negotiatedProtocol =
 353                         shc.resumingSession.getProtocolVersion();
 354                 shc.negotiatedCipherSuite = shc.resumingSession.getSuite();
 355                 shc.handshakeHash.determine(
 356                         shc.negotiatedProtocol, shc.negotiatedCipherSuite);
 357             }
 358 
 359             // Generate the ServerHello handshake message.
 360             ServerHelloMessage shm = new ServerHelloMessage(shc,
 361                     shc.negotiatedProtocol,
 362                     shc.handshakeSession.getSessionId(),
 363                     shc.negotiatedCipherSuite,
 364                     new RandomCookie(shc),
 365                     clientHello);
 366             shc.serverHelloRandom = shm.serverRandom;
 367 
 368             // Produce extensions for ServerHello handshake message.
 369             SSLExtension[] serverHelloExtensions =
 370                 shc.sslConfig.getEnabledExtensions(


 485         }
 486     }
 487 
 488     /**
 489      * The "ServerHello" handshake message producer.
 490      */
 491     private static final
 492             class T13ServerHelloProducer implements HandshakeProducer {
 493         // Prevent instantiation of this class.
 494         private T13ServerHelloProducer() {
 495             // blank
 496         }
 497 
 498         @Override
 499         public byte[] produce(ConnectionContext context,
 500                 HandshakeMessage message) throws IOException {
 501             // The producing happens in server side only.
 502             ServerHandshakeContext shc = (ServerHandshakeContext)context;
 503             ClientHelloMessage clientHello = (ClientHelloMessage)message;
 504 
 505             SSLSessionContextImpl sessionCache = (SSLSessionContextImpl)
 506                     shc.sslContext.engineGetServerSessionContext();
 507 
 508             // If client hasn't specified a session we can resume, start a
 509             // new one and choose its cipher suite and compression options,
 510             // unless new session creation is disabled for this connection!
 511             if (!shc.isResumption || shc.resumingSession == null) {
 512                 if (!shc.sslConfig.enableSessionCreation) {
 513                     throw new SSLException(
 514                         "Not resumption, and no new session is allowed");
 515                 }
 516 
 517                 if (shc.localSupportedSignAlgs == null) {
 518                     shc.localSupportedSignAlgs =
 519                         SignatureScheme.getSupportedAlgorithms(
 520                                 shc.algorithmConstraints, shc.activeProtocols);
 521                 }
 522 
 523                 SSLSessionImpl session =
 524                         new SSLSessionImpl(shc, CipherSuite.C_NULL);
 525                 session.setMaximumPacketSize(shc.sslConfig.maximumPacketSize);
 526                 shc.handshakeSession = session;
 527 


 543                         shc.negotiatedProtocol, shc.negotiatedCipherSuite);
 544             } else {
 545                 shc.handshakeSession = shc.resumingSession;
 546 
 547                 // consider the handshake extension impact
 548                 SSLExtension[] enabledExtensions =
 549                 shc.sslConfig.getEnabledExtensions(
 550                 SSLHandshake.CLIENT_HELLO, shc.negotiatedProtocol);
 551                 clientHello.extensions.consumeOnTrade(shc, enabledExtensions);
 552 
 553                 shc.negotiatedProtocol =
 554                         shc.resumingSession.getProtocolVersion();
 555                 shc.negotiatedCipherSuite = shc.resumingSession.getSuite();
 556                 shc.handshakeHash.determine(
 557                         shc.negotiatedProtocol, shc.negotiatedCipherSuite);
 558 
 559                 setUpPskKD(shc,
 560                         shc.resumingSession.consumePreSharedKey());
 561 
 562                 // The session can't be resumed again---remove it from cache


 563                 sessionCache.remove(shc.resumingSession.getSessionId());
 564             }
 565 
 566             // update the responders
 567             shc.handshakeProducers.put(SSLHandshake.ENCRYPTED_EXTENSIONS.id,
 568                     SSLHandshake.ENCRYPTED_EXTENSIONS);
 569             shc.handshakeProducers.put(SSLHandshake.FINISHED.id,
 570                     SSLHandshake.FINISHED);
 571 
 572             // Generate the ServerHello handshake message.
 573             ServerHelloMessage shm = new ServerHelloMessage(shc,
 574                     ProtocolVersion.TLS12,      // use legacy version
 575                     clientHello.sessionId,      // echo back
 576                     shc.negotiatedCipherSuite,
 577                     new RandomCookie(shc),
 578                     clientHello);
 579             shc.serverHelloRandom = shm.serverRandom;
 580 
 581             // Produce extensions for ServerHello handshake message.
 582             SSLExtension[] serverHelloExtensions =


 674             } catch (GeneralSecurityException gse) {
 675                 // unlikely
 676                 throw shc.conContext.fatal(Alert.HANDSHAKE_FAILURE,
 677                         "Missing cipher algorithm", gse);
 678             }
 679 
 680             if (writeCipher == null) {
 681                 throw shc.conContext.fatal(Alert.ILLEGAL_PARAMETER,
 682                     "Illegal cipher suite (" + shc.negotiatedCipherSuite +
 683                     ") and protocol version (" + shc.negotiatedProtocol +
 684                     ")");
 685             }
 686 
 687             shc.baseWriteSecret = writeSecret;
 688             shc.conContext.outputRecord.changeWriteCiphers(
 689                     writeCipher, (clientHello.sessionId.length() != 0));
 690 
 691             // Update the context for master key derivation.
 692             shc.handshakeKeyDerivation = kd;
 693 
 694             // Check if the server supports stateless resumption
 695             if (sessionCache.statelessEnabled()) {
 696                 shc.statelessResumption = true;
 697             }
 698 
 699             // The handshake message has been delivered.
 700             return null;
 701         }
 702 
 703         private static CipherSuite chooseCipherSuite(
 704                 ServerHandshakeContext shc,
 705                 ClientHelloMessage clientHello) throws IOException {
 706             List<CipherSuite> preferred;
 707             List<CipherSuite> proposed;
 708             if (shc.sslConfig.preferLocalCipherSuites) {
 709                 preferred = shc.activeCipherSuites;
 710                 proposed = clientHello.cipherSuites;
 711             } else {
 712                 preferred = clientHello.cipherSuites;
 713                 proposed = shc.activeCipherSuites;
 714             }
 715 
 716             CipherSuite legacySuite = null;
 717             AlgorithmConstraints legacyConstraints =
 718                     ServerHandshakeContext.legacyAlgorithmConstraints;


1098                     }
1099                 }
1100             }
1101 
1102             // Check and launch ClientHello extensions.
1103             extTypes = chc.sslConfig.getEnabledExtensions(
1104                     SSLHandshake.SERVER_HELLO);
1105             serverHello.extensions.consumeOnLoad(chc, extTypes);
1106 
1107             if (!chc.isResumption) {
1108                 if (chc.resumingSession != null) {
1109                     // in case the resumption happens next time.
1110                     chc.resumingSession.invalidate();
1111                     chc.resumingSession = null;
1112                 }
1113 
1114                 if (!chc.sslConfig.enableSessionCreation) {
1115                     throw chc.conContext.fatal(Alert.PROTOCOL_VERSION,
1116                         "New session creation is disabled");
1117                 }
1118 
1119                 if (serverHello.sessionId.length() == 0 &&
1120                         chc.statelessResumption) {
1121                     SessionId newId = new SessionId(true,
1122                             chc.sslContext.getSecureRandom());
1123                     chc.handshakeSession = new SSLSessionImpl(chc,
1124                             chc.negotiatedCipherSuite, newId);
1125 
1126                     if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
1127                         SSLLogger.fine("Locally assigned Session Id: " +
1128                                 newId.toString());
1129                     }
1130                 } else {
1131                     chc.handshakeSession = new SSLSessionImpl(chc,
1132                             chc.negotiatedCipherSuite,
1133                             serverHello.sessionId);
1134                 }
1135                 chc.handshakeSession.setMaximumPacketSize(
1136                         chc.sslConfig.maximumPacketSize);
1137             }
1138 
1139             //
1140             // update
1141             //
1142             serverHello.extensions.consumeOnTrade(chc, extTypes);
1143 
1144             // update the consumers and producers
1145             if (chc.isResumption) {
1146                 SSLTrafficKeyDerivation kdg =
1147                         SSLTrafficKeyDerivation.valueOf(chc.negotiatedProtocol);
1148                 if (kdg == null) {
1149                     // unlikely
1150                     throw chc.conContext.fatal(Alert.INTERNAL_ERROR,
1151                             "Not supported key derivation: " +
1152                             chc.negotiatedProtocol);
1153                 } else {
1154                     chc.handshakeKeyDerivation = kdg.createKeyDerivation(
1155                             chc, chc.resumingSession.getMasterSecret());
1156                 }
1157 
1158                 chc.conContext.consumers.putIfAbsent(
1159                         ContentType.CHANGE_CIPHER_SPEC.id,
1160                         ChangeCipherSpec.t10Consumer);
1161                 if (chc.statelessResumption) {
1162                     chc.handshakeConsumers.putIfAbsent(
1163                             SSLHandshake.NEW_SESSION_TICKET.id,
1164                             SSLHandshake.NEW_SESSION_TICKET);
1165                 }
1166                 chc.handshakeConsumers.put(
1167                         SSLHandshake.FINISHED.id,
1168                         SSLHandshake.FINISHED);
1169             } else {
1170                 SSLKeyExchange ke = SSLKeyExchange.valueOf(
1171                         chc.negotiatedCipherSuite.keyExchange,
1172                         chc.negotiatedProtocol);
1173                 chc.handshakeKeyExchange = ke;
1174                 if (ke != null) {
1175                     for (SSLHandshake handshake :
1176                             ke.getRelatedHandshakers(chc)) {
1177                         chc.handshakeConsumers.put(handshake.id, handshake);
1178                     }
1179                 }
1180 
1181                 chc.handshakeConsumers.put(SSLHandshake.SERVER_HELLO_DONE.id,
1182                         SSLHandshake.SERVER_HELLO_DONE);
1183             }
1184 
1185             //




  30 import java.security.AlgorithmConstraints;
  31 import java.security.GeneralSecurityException;
  32 import java.text.MessageFormat;
  33 import java.util.Arrays;
  34 import java.util.LinkedList;
  35 import java.util.List;
  36 import java.util.Locale;
  37 import java.util.Map;
  38 import javax.crypto.SecretKey;
  39 import javax.crypto.spec.IvParameterSpec;
  40 import javax.net.ssl.SSLException;
  41 import javax.net.ssl.SSLHandshakeException;
  42 import javax.net.ssl.SSLProtocolException;
  43 import sun.security.ssl.CipherSuite.KeyExchange;
  44 import sun.security.ssl.ClientHello.ClientHelloMessage;
  45 import sun.security.ssl.SSLCipher.SSLReadCipher;
  46 import sun.security.ssl.SSLCipher.SSLWriteCipher;
  47 import sun.security.ssl.SSLHandshake.HandshakeMessage;
  48 import sun.security.ssl.SupportedVersionsExtension.SHSupportedVersionsSpec;
  49 


  50 /**
  51  * Pack of the ServerHello/HelloRetryRequest handshake message.
  52  */
  53 final class ServerHello {
  54     static final SSLConsumer handshakeConsumer =
  55         new ServerHelloConsumer();
  56     static final HandshakeProducer t12HandshakeProducer =
  57         new T12ServerHelloProducer();
  58     static final HandshakeProducer t13HandshakeProducer =
  59         new T13ServerHelloProducer();
  60     static final HandshakeProducer hrrHandshakeProducer =
  61         new T13HelloRetryRequestProducer();
  62 
  63     static final HandshakeProducer hrrReproducer =
  64         new T13HelloRetryRequestReproducer();
  65 
  66     private static final HandshakeConsumer t12HandshakeConsumer =
  67         new T12ServerHelloConsumer();
  68     private static final HandshakeConsumer t13HandshakeConsumer =
  69         new T13ServerHelloConsumer();


 320                     }
 321                 }
 322 
 323                 if ((ke != null) &&
 324                         (shc.sslConfig.clientAuthType !=
 325                                 ClientAuthType.CLIENT_AUTH_NONE) &&
 326                         !shc.negotiatedCipherSuite.isAnonymous()) {
 327                     for (SSLHandshake hs :
 328                             ke.getRelatedHandshakers(shc)) {
 329                         if (hs == SSLHandshake.CERTIFICATE) {
 330                             shc.handshakeProducers.put(
 331                                     SSLHandshake.CERTIFICATE_REQUEST.id,
 332                                     SSLHandshake.CERTIFICATE_REQUEST);
 333                             break;
 334                         }
 335                     }
 336                 }
 337                 shc.handshakeProducers.put(SSLHandshake.SERVER_HELLO_DONE.id,
 338                         SSLHandshake.SERVER_HELLO_DONE);
 339             } else {









 340                 shc.handshakeSession = shc.resumingSession;
 341                 shc.negotiatedProtocol =
 342                         shc.resumingSession.getProtocolVersion();
 343                 shc.negotiatedCipherSuite = shc.resumingSession.getSuite();
 344                 shc.handshakeHash.determine(
 345                         shc.negotiatedProtocol, shc.negotiatedCipherSuite);
 346             }
 347 
 348             // Generate the ServerHello handshake message.
 349             ServerHelloMessage shm = new ServerHelloMessage(shc,
 350                     shc.negotiatedProtocol,
 351                     shc.handshakeSession.getSessionId(),
 352                     shc.negotiatedCipherSuite,
 353                     new RandomCookie(shc),
 354                     clientHello);
 355             shc.serverHelloRandom = shm.serverRandom;
 356 
 357             // Produce extensions for ServerHello handshake message.
 358             SSLExtension[] serverHelloExtensions =
 359                 shc.sslConfig.getEnabledExtensions(


 474         }
 475     }
 476 
 477     /**
 478      * The "ServerHello" handshake message producer.
 479      */
 480     private static final
 481             class T13ServerHelloProducer implements HandshakeProducer {
 482         // Prevent instantiation of this class.
 483         private T13ServerHelloProducer() {
 484             // blank
 485         }
 486 
 487         @Override
 488         public byte[] produce(ConnectionContext context,
 489                 HandshakeMessage message) throws IOException {
 490             // The producing happens in server side only.
 491             ServerHandshakeContext shc = (ServerHandshakeContext)context;
 492             ClientHelloMessage clientHello = (ClientHelloMessage)message;
 493 



 494             // If client hasn't specified a session we can resume, start a
 495             // new one and choose its cipher suite and compression options,
 496             // unless new session creation is disabled for this connection!
 497             if (!shc.isResumption || shc.resumingSession == null) {
 498                 if (!shc.sslConfig.enableSessionCreation) {
 499                     throw new SSLException(
 500                         "Not resumption, and no new session is allowed");
 501                 }
 502 
 503                 if (shc.localSupportedSignAlgs == null) {
 504                     shc.localSupportedSignAlgs =
 505                         SignatureScheme.getSupportedAlgorithms(
 506                                 shc.algorithmConstraints, shc.activeProtocols);
 507                 }
 508 
 509                 SSLSessionImpl session =
 510                         new SSLSessionImpl(shc, CipherSuite.C_NULL);
 511                 session.setMaximumPacketSize(shc.sslConfig.maximumPacketSize);
 512                 shc.handshakeSession = session;
 513 


 529                         shc.negotiatedProtocol, shc.negotiatedCipherSuite);
 530             } else {
 531                 shc.handshakeSession = shc.resumingSession;
 532 
 533                 // consider the handshake extension impact
 534                 SSLExtension[] enabledExtensions =
 535                 shc.sslConfig.getEnabledExtensions(
 536                 SSLHandshake.CLIENT_HELLO, shc.negotiatedProtocol);
 537                 clientHello.extensions.consumeOnTrade(shc, enabledExtensions);
 538 
 539                 shc.negotiatedProtocol =
 540                         shc.resumingSession.getProtocolVersion();
 541                 shc.negotiatedCipherSuite = shc.resumingSession.getSuite();
 542                 shc.handshakeHash.determine(
 543                         shc.negotiatedProtocol, shc.negotiatedCipherSuite);
 544 
 545                 setUpPskKD(shc,
 546                         shc.resumingSession.consumePreSharedKey());
 547 
 548                 // The session can't be resumed again---remove it from cache
 549                 SSLSessionContextImpl sessionCache = (SSLSessionContextImpl)
 550                     shc.sslContext.engineGetServerSessionContext();
 551                 sessionCache.remove(shc.resumingSession.getSessionId());
 552             }
 553 
 554             // update the responders
 555             shc.handshakeProducers.put(SSLHandshake.ENCRYPTED_EXTENSIONS.id,
 556                     SSLHandshake.ENCRYPTED_EXTENSIONS);
 557             shc.handshakeProducers.put(SSLHandshake.FINISHED.id,
 558                     SSLHandshake.FINISHED);
 559 
 560             // Generate the ServerHello handshake message.
 561             ServerHelloMessage shm = new ServerHelloMessage(shc,
 562                     ProtocolVersion.TLS12,      // use legacy version
 563                     clientHello.sessionId,      // echo back
 564                     shc.negotiatedCipherSuite,
 565                     new RandomCookie(shc),
 566                     clientHello);
 567             shc.serverHelloRandom = shm.serverRandom;
 568 
 569             // Produce extensions for ServerHello handshake message.
 570             SSLExtension[] serverHelloExtensions =


 662             } catch (GeneralSecurityException gse) {
 663                 // unlikely
 664                 throw shc.conContext.fatal(Alert.HANDSHAKE_FAILURE,
 665                         "Missing cipher algorithm", gse);
 666             }
 667 
 668             if (writeCipher == null) {
 669                 throw shc.conContext.fatal(Alert.ILLEGAL_PARAMETER,
 670                     "Illegal cipher suite (" + shc.negotiatedCipherSuite +
 671                     ") and protocol version (" + shc.negotiatedProtocol +
 672                     ")");
 673             }
 674 
 675             shc.baseWriteSecret = writeSecret;
 676             shc.conContext.outputRecord.changeWriteCiphers(
 677                     writeCipher, (clientHello.sessionId.length() != 0));
 678 
 679             // Update the context for master key derivation.
 680             shc.handshakeKeyDerivation = kd;
 681 





 682             // The handshake message has been delivered.
 683             return null;
 684         }
 685 
 686         private static CipherSuite chooseCipherSuite(
 687                 ServerHandshakeContext shc,
 688                 ClientHelloMessage clientHello) throws IOException {
 689             List<CipherSuite> preferred;
 690             List<CipherSuite> proposed;
 691             if (shc.sslConfig.preferLocalCipherSuites) {
 692                 preferred = shc.activeCipherSuites;
 693                 proposed = clientHello.cipherSuites;
 694             } else {
 695                 preferred = clientHello.cipherSuites;
 696                 proposed = shc.activeCipherSuites;
 697             }
 698 
 699             CipherSuite legacySuite = null;
 700             AlgorithmConstraints legacyConstraints =
 701                     ServerHandshakeContext.legacyAlgorithmConstraints;


1081                     }
1082                 }
1083             }
1084 
1085             // Check and launch ClientHello extensions.
1086             extTypes = chc.sslConfig.getEnabledExtensions(
1087                     SSLHandshake.SERVER_HELLO);
1088             serverHello.extensions.consumeOnLoad(chc, extTypes);
1089 
1090             if (!chc.isResumption) {
1091                 if (chc.resumingSession != null) {
1092                     // in case the resumption happens next time.
1093                     chc.resumingSession.invalidate();
1094                     chc.resumingSession = null;
1095                 }
1096 
1097                 if (!chc.sslConfig.enableSessionCreation) {
1098                     throw chc.conContext.fatal(Alert.PROTOCOL_VERSION,
1099                         "New session creation is disabled");
1100                 }
1101                 chc.handshakeSession = new SSLSessionImpl(chc,
1102                         chc.negotiatedCipherSuite,
1103                         serverHello.sessionId);














1104                 chc.handshakeSession.setMaximumPacketSize(
1105                         chc.sslConfig.maximumPacketSize);
1106             }
1107 
1108             //
1109             // update
1110             //
1111             serverHello.extensions.consumeOnTrade(chc, extTypes);
1112 
1113             // update the consumers and producers
1114             if (chc.isResumption) {
1115                 SSLTrafficKeyDerivation kdg =
1116                         SSLTrafficKeyDerivation.valueOf(chc.negotiatedProtocol);
1117                 if (kdg == null) {
1118                     // unlikely
1119                     throw chc.conContext.fatal(Alert.INTERNAL_ERROR,
1120                             "Not supported key derivation: " +
1121                             chc.negotiatedProtocol);
1122                 } else {
1123                     chc.handshakeKeyDerivation = kdg.createKeyDerivation(
1124                             chc, chc.resumingSession.getMasterSecret());
1125                 }
1126 
1127                 chc.conContext.consumers.putIfAbsent(
1128                         ContentType.CHANGE_CIPHER_SPEC.id,
1129                         ChangeCipherSpec.t10Consumer);





1130                 chc.handshakeConsumers.put(
1131                         SSLHandshake.FINISHED.id,
1132                         SSLHandshake.FINISHED);
1133             } else {
1134                 SSLKeyExchange ke = SSLKeyExchange.valueOf(
1135                         chc.negotiatedCipherSuite.keyExchange,
1136                         chc.negotiatedProtocol);
1137                 chc.handshakeKeyExchange = ke;
1138                 if (ke != null) {
1139                     for (SSLHandshake handshake :
1140                             ke.getRelatedHandshakers(chc)) {
1141                         chc.handshakeConsumers.put(handshake.id, handshake);
1142                     }
1143                 }
1144 
1145                 chc.handshakeConsumers.put(SSLHandshake.SERVER_HELLO_DONE.id,
1146                         SSLHandshake.SERVER_HELLO_DONE);
1147             }
1148 
1149             //


< prev index next >