src/java.base/share/classes/sun/security/ssl/ClientKeyExchange.java
branchJDK-8145252-TLS13-branch
changeset 56542 56aaa6cb3693
parent 47216 71c04702a3d5
child 56704 c3ee22c3a0f6
equal deleted inserted replaced
56541:92cbbfc996f3 56542:56aaa6cb3693
     1 /*
     1 /*
     2  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     5  * This code is free software; you can redistribute it and/or modify it
     6  * under the terms of the GNU General Public License version 2 only, as
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.  Oracle designates this
     7  * published by the Free Software Foundation.  Oracle designates this
    23  * questions.
    23  * questions.
    24  */
    24  */
    25 
    25 
    26 package sun.security.ssl;
    26 package sun.security.ssl;
    27 
    27 
    28 import javax.crypto.SecretKey;
       
    29 import java.io.IOException;
    28 import java.io.IOException;
    30 import java.io.PrintStream;
    29 import java.nio.ByteBuffer;
    31 import java.security.Principal;
    30 import java.util.Map;
       
    31 import sun.security.ssl.SSLHandshake.HandshakeMessage;
    32 
    32 
    33 /**
    33 /**
    34  * Models a non-certificate based ClientKeyExchange
    34  * Pack of the "ClientKeyExchange" handshake message.
    35  */
    35  */
    36 public abstract class ClientKeyExchange extends HandshakeMessage {
    36 final class ClientKeyExchange {
       
    37     static final SSLConsumer handshakeConsumer =
       
    38             new ClientKeyExchangeConsumer();
       
    39     static final HandshakeProducer handshakeProducer =
       
    40             new ClientKeyExchangeProducer();
    37 
    41 
    38     public ClientKeyExchange() {
    42 
       
    43     /**
       
    44      * The "ClientKeyExchange" handshake message producer.
       
    45      */
       
    46     private static final
       
    47             class ClientKeyExchangeProducer implements HandshakeProducer {
       
    48         // Prevent instantiation of this class.
       
    49         private ClientKeyExchangeProducer() {
       
    50             // blank
       
    51         }
       
    52 
       
    53         @Override
       
    54         public byte[] produce(ConnectionContext context,
       
    55                 HandshakeMessage message) throws IOException {
       
    56             // The producing happens in client side only.
       
    57             ClientHandshakeContext chc = (ClientHandshakeContext)context;
       
    58             SSLKeyExchange ke =
       
    59                 SSLKeyExchange.valueOf(chc.negotiatedCipherSuite.keyExchange);
       
    60             if (ke != null) {
       
    61                 for (Map.Entry<Byte, HandshakeProducer> hp :
       
    62                         ke.getHandshakeProducers(chc)) {
       
    63                     if (hp.getKey() == SSLHandshake.CLIENT_KEY_EXCHANGE.id) {
       
    64                         return hp.getValue().produce(context, message);
       
    65                     }
       
    66                 }
       
    67             }
       
    68 
       
    69             // not comsumer defined.
       
    70             chc.conContext.fatal(Alert.UNEXPECTED_MESSAGE,
       
    71                         "Unexpected ClientKeyExchange handshake message.");
       
    72             return null;    // make the compiler happe
       
    73         }
    39     }
    74     }
    40 
    75 
    41     @Override
    76     /**
    42     int messageType() {
    77      * The "ClientKeyExchange" handshake message consumer.
    43         return ht_client_key_exchange;
    78      */
       
    79     private static final
       
    80             class ClientKeyExchangeConsumer implements SSLConsumer {
       
    81         // Prevent instantiation of this class.
       
    82         private ClientKeyExchangeConsumer() {
       
    83             // blank
       
    84         }
       
    85 
       
    86         @Override
       
    87         public void consume(ConnectionContext context,
       
    88                 ByteBuffer message) throws IOException {
       
    89             // The consuming happens in server side only.
       
    90             ServerHandshakeContext shc = (ServerHandshakeContext)context;
       
    91             // clean up this consumer
       
    92             shc.handshakeConsumers.remove(SSLHandshake.CLIENT_KEY_EXCHANGE.id);
       
    93             SSLKeyExchange ke =
       
    94                 SSLKeyExchange.valueOf(shc.negotiatedCipherSuite.keyExchange);
       
    95             if (ke != null) {
       
    96                 for (Map.Entry<Byte, SSLConsumer> hc :
       
    97                         ke.getHandshakeConsumers(shc)) {
       
    98                     if (hc.getKey() == SSLHandshake.CLIENT_KEY_EXCHANGE.id) {
       
    99                         hc.getValue().consume(context, message);
       
   100                         return;
       
   101                     }
       
   102                 }
       
   103             }
       
   104 
       
   105             // not comsumer defined.
       
   106             shc.conContext.fatal(Alert.UNEXPECTED_MESSAGE,
       
   107                         "Unexpected ClientKeyExchange handshake message.");
       
   108         }
    44     }
   109     }
       
   110 }
    45 
   111 
    46     @Override
       
    47     public abstract int messageLength();
       
    48 
       
    49     @Override
       
    50     public abstract void send(HandshakeOutStream s) throws IOException;
       
    51 
       
    52     @Override
       
    53     public abstract void print(PrintStream s) throws IOException;
       
    54 
       
    55     public abstract SecretKey clientKeyExchange();
       
    56 
       
    57     public abstract Principal getPeerPrincipal();
       
    58 
       
    59     public abstract Principal getLocalPrincipal();
       
    60 }