1 /*

     2  * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     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

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package sun.security.ssl;

    27 

    28 import java.io.IOException;

    29 import java.nio.ByteBuffer;

    30 import java.text.MessageFormat;

    31 import java.util.List;

    32 import java.util.ArrayList;

    33 import java.util.Locale;

    34 import javax.net.ssl.SSLHandshakeException;

    35 import java.security.cert.X509Certificate;

    36 import sun.security.provider.certpath.OCSPResponse;

    37 import sun.security.ssl.SSLHandshake.HandshakeMessage;

    38 import static sun.security.ssl.CertStatusExtension.*;

    39 import static sun.security.ssl.CertificateMessage.*;

    40 

    41 /**

    42  * Pack of the CertificateStatus handshake message.

    43  */

    44 final class CertificateStatus {

    45     static final SSLConsumer handshakeConsumer =

    46             new CertificateStatusConsumer();

    47     static final HandshakeProducer handshakeProducer =

    48             new CertificateStatusProducer();

    49     static final HandshakeAbsence handshakeAbsence =

    50             new CertificateStatusAbsence();

    51 

    52     /**

    53      * The CertificateStatus handshake message.

    54      */

    55     static final class CertificateStatusMessage extends HandshakeMessage {

    56 

    57         final CertStatusRequestType statusType;

    58         int encodedResponsesLen = 0;

    59         int messageLength = -1;

    60         final List<byte[]> encodedResponses = new ArrayList<>();

    61 

    62         CertificateStatusMessage(HandshakeContext handshakeContext) {

    63             super(handshakeContext);

    64 

    65             ServerHandshakeContext shc =

    66                     (ServerHandshakeContext)handshakeContext;

    67 

    68             // Get the Certificates from the SSLContextImpl amd the Stapling

    69             // parameters

    70             StatusResponseManager.StaplingParameters stapleParams =

    71                     shc.stapleParams;

    72             if (stapleParams == null) {

    73                 throw new IllegalArgumentException(

    74                         "Unexpected null stapling parameters");

    75             }

    76 

    77             X509Certificate[] certChain =

    78                 (X509Certificate[])shc.handshakeSession.getLocalCertificates();

    79             if (certChain == null) {

    80                 throw new IllegalArgumentException(

    81                         "Unexpected null certificate chain");

    82             }

    83 

    84             // Walk the certificate list and add the correct encoded responses

    85             // to the encoded responses list

    86             statusType = stapleParams.statReqType;

    87             if (statusType == CertStatusRequestType.OCSP) {

    88                 // Just worry about the first cert in the chain

    89                 byte[] resp = stapleParams.responseMap.get(certChain[0]);

    90                 if (resp == null) {

    91                     // A not-found return status means we should include

    92                     // a zero-length response in CertificateStatus.

    93                     // This is highly unlikely to happen in practice.

    94                     resp = new byte[0];

    95                 }

    96                 encodedResponses.add(resp);

    97                 encodedResponsesLen += resp.length + 3;

    98             } else if (statusType == CertStatusRequestType.OCSP_MULTI) {

    99                 for (X509Certificate cert : certChain) {

   100                     byte[] resp = stapleParams.responseMap.get(cert);

   101                     if (resp == null) {

   102                         resp = new byte[0];

   103                     }

   104                     encodedResponses.add(resp);

   105                     encodedResponsesLen += resp.length + 3;

   106                 }

   107             } else {

   108                 throw new IllegalArgumentException(

   109                         "Unsupported StatusResponseType: " + statusType);

   110             }

   111 

   112             messageLength = messageLength();

   113         }

   114 

   115         CertificateStatusMessage(HandshakeContext handshakeContext,

   116                 ByteBuffer m) throws IOException {

   117             super(handshakeContext);

   118 

   119             statusType = CertStatusRequestType.valueOf((byte)Record.getInt8(m));

   120             if (statusType == CertStatusRequestType.OCSP) {

   121                 byte[] respDER = Record.getBytes24(m);

   122                 // Convert the incoming bytes to a OCSPResponse strucutre

   123                 if (respDER.length > 0) {

   124                     encodedResponses.add(respDER);

   125                     encodedResponsesLen = 3 + respDER.length;

   126                 } else {

   127                     handshakeContext.conContext.fatal(Alert.HANDSHAKE_FAILURE,

   128                             "Zero-length OCSP Response");

   129                 }

   130             } else if (statusType == CertStatusRequestType.OCSP_MULTI) {

   131                 int respListLen = Record.getInt24(m);

   132                 encodedResponsesLen = respListLen;

   133 

   134                 // Add each OCSP reponse into the array list in the order

   135                 // we receive them off the wire.  A zero-length array is

   136                 // allowed for ocsp_multi, and means that a response for

   137                 // a given certificate is not available.

   138                 while (respListLen > 0) {

   139                     byte[] respDER = Record.getBytes24(m);

   140                     encodedResponses.add(respDER);

   141                     respListLen -= (respDER.length + 3);

   142                 }

   143 

   144                 if (respListLen != 0) {

   145                     handshakeContext.conContext.fatal(Alert.INTERNAL_ERROR,

   146                             "Bad OCSP response list length");

   147                 }

   148             } else {

   149                 handshakeContext.conContext.fatal(Alert.HANDSHAKE_FAILURE,

   150                         "Unsupported StatusResponseType: " + statusType);

   151             }

   152             messageLength = messageLength();

   153         }

   154 

   155         @Override

   156         public SSLHandshake handshakeType() {

   157             return SSLHandshake.CERTIFICATE_STATUS;

   158         }

   159 

   160         @Override

   161         public int messageLength() {

   162             int len = 1;

   163 

   164             if (messageLength == -1) {

   165                 if (statusType == CertStatusRequestType.OCSP) {

   166                     len += encodedResponsesLen;

   167                 } else if (statusType == CertStatusRequestType.OCSP_MULTI) {

   168                     len += 3 + encodedResponsesLen;

   169                 }

   170                 messageLength = len;

   171             }

   172 

   173             return messageLength;

   174         }

   175 

   176         @Override

   177         public void send(HandshakeOutStream s) throws IOException {

   178             s.putInt8(statusType.id);

   179             if (statusType == CertStatusRequestType.OCSP) {

   180                 s.putBytes24(encodedResponses.get(0));

   181             } else if (statusType == CertStatusRequestType.OCSP_MULTI) {

   182                 s.putInt24(encodedResponsesLen);

   183                 for (byte[] respBytes : encodedResponses) {

   184                     if (respBytes != null) {

   185                         s.putBytes24(respBytes);

   186                     } else {

   187                         s.putBytes24(null);

   188                     }

   189                 }

   190             } else {

   191                 // It is highly unlikely that we will fall into this section

   192                 // of the code.

   193                 throw new SSLHandshakeException("Unsupported status_type: " +

   194                         statusType.id);

   195             }

   196         }

   197 

   198         @Override

   199         public String toString() {

   200             StringBuilder sb = new StringBuilder();

   201 

   202             // Stringify the encoded OCSP response list

   203             for (byte[] respDER : encodedResponses) {

   204                 if (respDER.length > 0) {

   205                     try {

   206                         OCSPResponse oResp = new OCSPResponse(respDER);

   207                         sb.append(oResp.toString()).append("\n");

   208                     } catch (IOException ioe) {

   209                         sb.append("OCSP Response Exception: ").append(ioe)

   210                                 .append("\n");

   211                     }

   212                 } else {

   213                     sb.append("<Zero-length entry>\n");

   214                 }

   215             }

   216 

   217             MessageFormat messageFormat = new MessageFormat(

   218                 "\"CertificateStatus\": '{'\n" +

   219                 "  \"type\"                : \"{0}\",\n" +

   220                 "  \"responses \"          : [\n" + "{1}\n" + "  ]\n" +

   221                 "'}'",

   222                 Locale.ENGLISH);

   223             Object[] messageFields = {

   224                 statusType.name,

   225                 Utilities.indent(Utilities.indent(sb.toString()))

   226             };

   227 

   228             return messageFormat.format(messageFields);

   229         }

   230     }

   231 

   232     /**

   233      * The CertificateStatus handshake message consumer.

   234      */

   235     private static final class CertificateStatusConsumer

   236             implements SSLConsumer {

   237         // Prevent instantiation of this class.

   238         private CertificateStatusConsumer() {

   239             // blank

   240         }

   241 

   242         @Override

   243         public void consume(ConnectionContext context,

   244                 ByteBuffer message) throws IOException {

   245             ClientHandshakeContext chc = (ClientHandshakeContext)context;

   246             CertificateStatusMessage cst =

   247                     new CertificateStatusMessage(chc, message);

   248 

   249             // Log the message

   250             if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {

   251                 SSLLogger.fine(

   252                         "Consuming server CertificateStatus handshake message",

   253                         cst);

   254             }

   255 

   256             // Pin the received responses to the SSLSessionImpl.  It will

   257             // be retrieved by the X509TrustManagerImpl during the certficicate

   258             // checking phase.

   259             chc.handshakeSession.setStatusResponses(cst.encodedResponses);

   260 

   261             // Now perform the check

   262             T12CertificateConsumer.checkServerCerts(chc, chc.deferredCerts);

   263         }

   264     }

   265 

   266     /**

   267      * The CertificateStatus handshake message consumer.

   268      */

   269     private static final class CertificateStatusProducer

   270             implements HandshakeProducer {

   271         // Prevent instantiation of this class.

   272         private CertificateStatusProducer() {

   273             // blank

   274         }

   275 

   276         @Override

   277         public byte[] produce(ConnectionContext context,

   278                 HandshakeMessage message) throws IOException {

   279             // Only the server-side should be a producer of this message

   280             ServerHandshakeContext shc = (ServerHandshakeContext)context;

   281 

   282             // If stapling is not active, immediately return without producing

   283             // a message or any further processing.

   284             if (!shc.staplingActive) {

   285                 return null;

   286             }

   287 

   288             // Create the CertificateStatus message from info in the

   289             CertificateStatusMessage csm = new CertificateStatusMessage(shc);

   290             if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {

   291                 SSLLogger.fine(

   292                     "Produced server CertificateStatus handshake message", csm);

   293             }

   294 

   295             // Output the handshake message.

   296             csm.write(shc.handshakeOutput);

   297             shc.handshakeOutput.flush();

   298 

   299             // The handshake message has been delivered.

   300             return null;

   301         }

   302     }

   303 

   304     private static final class CertificateStatusAbsence

   305             implements HandshakeAbsence {

   306         // Prevent instantiation of this class

   307         private CertificateStatusAbsence() {

   308             // blank

   309         }

   310 

   311         @Override

   312         public void absent(ConnectionContext context,

   313                 HandshakeMessage message) throws IOException {

   314             ClientHandshakeContext chc = (ClientHandshakeContext)context;

   315 

   316             // Processing should only continue if stapling is active

   317             if (chc.staplingActive) {

   318                 // Because OCSP stapling is active, it means two things

   319                 // if we're here: 1) The server hello asserted the

   320                 // status_request[_v2] extension.  2) The CertificateStatus

   321                 // message was not sent.  This means that cert path checking

   322                 // was deferred, but must happen immediately.

   323                 if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {

   324                     SSLLogger.fine("Server did not send CertificateStatus, " +

   325                             "checking cert chain without status info.");

   326                 }

   327                 T12CertificateConsumer.checkServerCerts(chc, chc.deferredCerts);

   328             }

   329         }

   330     }

   331 }

   332