src/java.base/share/classes/sun/security/ssl/ClientKeyExchange.java
changeset 50768 68fa3d4026ea
parent 47216 71c04702a3d5
child 53064 103ed9569fc8
equal deleted inserted replaced
50767:356eaea05bf0 50768:68fa3d4026ea
     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 = SSLKeyExchange.valueOf(
       
    59                         chc.negotiatedCipherSuite.keyExchange,
       
    60                         chc.negotiatedProtocol);
       
    61             if (ke != null) {
       
    62                 for (Map.Entry<Byte, HandshakeProducer> hp :
       
    63                         ke.getHandshakeProducers(chc)) {
       
    64                     if (hp.getKey() == SSLHandshake.CLIENT_KEY_EXCHANGE.id) {
       
    65                         return hp.getValue().produce(context, message);
       
    66                     }
       
    67                 }
       
    68             }
       
    69 
       
    70             // not consumer defined.
       
    71             chc.conContext.fatal(Alert.UNEXPECTED_MESSAGE,
       
    72                         "Unexpected ClientKeyExchange handshake message.");
       
    73             return null;    // make the compiler happe
       
    74         }
    39     }
    75     }
    40 
    76 
    41     @Override
    77     /**
    42     int messageType() {
    78      * The "ClientKeyExchange" handshake message consumer.
    43         return ht_client_key_exchange;
    79      */
       
    80     private static final
       
    81             class ClientKeyExchangeConsumer implements SSLConsumer {
       
    82         // Prevent instantiation of this class.
       
    83         private ClientKeyExchangeConsumer() {
       
    84             // blank
       
    85         }
       
    86 
       
    87         @Override
       
    88         public void consume(ConnectionContext context,
       
    89                 ByteBuffer message) throws IOException {
       
    90             // The consuming happens in server side only.
       
    91             ServerHandshakeContext shc = (ServerHandshakeContext)context;
       
    92             // clean up this consumer
       
    93             shc.handshakeConsumers.remove(SSLHandshake.CLIENT_KEY_EXCHANGE.id);
       
    94             SSLKeyExchange ke = SSLKeyExchange.valueOf(
       
    95                     shc.negotiatedCipherSuite.keyExchange,
       
    96                     shc.negotiatedProtocol);
       
    97             if (ke != null) {
       
    98                 for (Map.Entry<Byte, SSLConsumer> hc :
       
    99                         ke.getHandshakeConsumers(shc)) {
       
   100                     if (hc.getKey() == SSLHandshake.CLIENT_KEY_EXCHANGE.id) {
       
   101                         hc.getValue().consume(context, message);
       
   102                         return;
       
   103                     }
       
   104                 }
       
   105             }
       
   106 
       
   107             // not consumer defined.
       
   108             shc.conContext.fatal(Alert.UNEXPECTED_MESSAGE,
       
   109                         "Unexpected ClientKeyExchange handshake message.");
       
   110         }
    44     }
   111     }
       
   112 }
    45 
   113 
    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 }