mirror of
https://github.com/openjdk/jdk.git
synced 2026-01-30 21:18:25 +00:00
587 lines
23 KiB
Java
587 lines
23 KiB
Java
/*
|
|
* Copyright (c) 2015, 2022, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package sun.security.ssl;
|
|
|
|
import java.io.IOException;
|
|
import java.nio.ByteBuffer;
|
|
import java.security.AlgorithmConstraints;
|
|
import java.text.MessageFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import javax.net.ssl.SSLProtocolException;
|
|
import sun.security.action.GetPropertyAction;
|
|
import sun.security.ssl.NamedGroup.NamedGroupSpec;
|
|
import static sun.security.ssl.SSLExtension.CH_SUPPORTED_GROUPS;
|
|
import static sun.security.ssl.SSLExtension.EE_SUPPORTED_GROUPS;
|
|
import sun.security.ssl.SSLExtension.ExtensionConsumer;
|
|
import sun.security.ssl.SSLExtension.SSLExtensionSpec;
|
|
import sun.security.ssl.SSLHandshake.HandshakeMessage;
|
|
|
|
|
|
/**
|
|
* Pack of the "supported_groups" extensions [RFC 4492/7919].
|
|
*/
|
|
final class SupportedGroupsExtension {
|
|
static final HandshakeProducer chNetworkProducer =
|
|
new CHSupportedGroupsProducer();
|
|
static final ExtensionConsumer chOnLoadConsumer =
|
|
new CHSupportedGroupsConsumer();
|
|
static final HandshakeAbsence chOnTradAbsence =
|
|
new CHSupportedGroupsOnTradeAbsence();
|
|
static final SSLStringizer sgsStringizer =
|
|
new SupportedGroupsStringizer();
|
|
|
|
static final HandshakeProducer eeNetworkProducer =
|
|
new EESupportedGroupsProducer();
|
|
static final ExtensionConsumer eeOnLoadConsumer =
|
|
new EESupportedGroupsConsumer();
|
|
|
|
/**
|
|
* The "supported_groups" extension.
|
|
*/
|
|
static final class SupportedGroupsSpec implements SSLExtensionSpec {
|
|
final int[] namedGroupsIds;
|
|
|
|
private SupportedGroupsSpec(int[] namedGroupsIds) {
|
|
this.namedGroupsIds = namedGroupsIds;
|
|
}
|
|
|
|
private SupportedGroupsSpec(List<NamedGroup> namedGroups) {
|
|
this.namedGroupsIds = new int[namedGroups.size()];
|
|
int i = 0;
|
|
for (NamedGroup ng : namedGroups) {
|
|
namedGroupsIds[i++] = ng.id;
|
|
}
|
|
}
|
|
|
|
private SupportedGroupsSpec(HandshakeContext hc,
|
|
ByteBuffer m) throws IOException {
|
|
if (m.remaining() < 2) { // 2: the length of the list
|
|
throw hc.conContext.fatal(Alert.DECODE_ERROR,
|
|
new SSLProtocolException(
|
|
"Invalid supported_groups extension: insufficient data"));
|
|
}
|
|
|
|
byte[] ngs = Record.getBytes16(m);
|
|
if (m.hasRemaining()) {
|
|
throw hc.conContext.fatal(Alert.DECODE_ERROR,
|
|
new SSLProtocolException(
|
|
"Invalid supported_groups extension: unknown extra data"));
|
|
}
|
|
|
|
if ((ngs == null) || (ngs.length == 0) || (ngs.length % 2 != 0)) {
|
|
throw hc.conContext.fatal(Alert.DECODE_ERROR,
|
|
new SSLProtocolException(
|
|
"Invalid supported_groups extension: incomplete data"));
|
|
}
|
|
|
|
int[] ids = new int[ngs.length / 2];
|
|
for (int i = 0, j = 0; i < ngs.length;) {
|
|
ids[j++] = ((ngs[i++] & 0xFF) << 8) | (ngs[i++] & 0xFF);
|
|
}
|
|
|
|
this.namedGroupsIds = ids;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
MessageFormat messageFormat = new MessageFormat(
|
|
"\"named groups\": '['{0}']'", Locale.ENGLISH);
|
|
|
|
if (namedGroupsIds == null || namedGroupsIds.length == 0) {
|
|
Object[] messageFields = {
|
|
"<no supported named group specified>"
|
|
};
|
|
return messageFormat.format(messageFields);
|
|
} else {
|
|
StringBuilder builder = new StringBuilder(512);
|
|
boolean isFirst = true;
|
|
for (int ngid : namedGroupsIds) {
|
|
if (isFirst) {
|
|
isFirst = false;
|
|
} else {
|
|
builder.append(", ");
|
|
}
|
|
|
|
builder.append(NamedGroup.nameOf(ngid));
|
|
}
|
|
|
|
Object[] messageFields = {
|
|
builder.toString()
|
|
};
|
|
|
|
return messageFormat.format(messageFields);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final
|
|
class SupportedGroupsStringizer implements SSLStringizer {
|
|
@Override
|
|
public String toString(HandshakeContext hc, ByteBuffer buffer) {
|
|
try {
|
|
return (new SupportedGroupsSpec(hc, buffer)).toString();
|
|
} catch (IOException ioe) {
|
|
// For debug logging only, so please swallow exceptions.
|
|
return ioe.getMessage();
|
|
}
|
|
}
|
|
}
|
|
|
|
static class SupportedGroups {
|
|
// To switch off the supported_groups extension for DHE cipher suite.
|
|
static final boolean enableFFDHE =
|
|
Utilities.getBooleanProperty("jsse.enableFFDHE", true);
|
|
|
|
// the supported named groups
|
|
static final NamedGroup[] supportedNamedGroups;
|
|
|
|
static {
|
|
// The value of the System Property defines a list of enabled named
|
|
// groups in preference order, separated with comma. For example:
|
|
//
|
|
// jdk.tls.namedGroups="secp521r1, secp256r1, ffdhe2048"
|
|
//
|
|
// If the System Property is not defined or the value is empty, the
|
|
// default groups and preferences will be used.
|
|
String property = GetPropertyAction
|
|
.privilegedGetProperty("jdk.tls.namedGroups");
|
|
if (property != null && !property.isEmpty()) {
|
|
// remove double quote marks from beginning/end of the property
|
|
if (property.length() > 1 && property.charAt(0) == '"' &&
|
|
property.charAt(property.length() - 1) == '"') {
|
|
property = property.substring(1, property.length() - 1);
|
|
}
|
|
}
|
|
|
|
ArrayList<NamedGroup> groupList;
|
|
if (property != null && !property.isEmpty()) {
|
|
String[] groups = property.split(",");
|
|
groupList = new ArrayList<>(groups.length);
|
|
for (String group : groups) {
|
|
group = group.trim();
|
|
if (!group.isEmpty()) {
|
|
NamedGroup namedGroup = NamedGroup.nameOf(group);
|
|
if (namedGroup != null) {
|
|
if (namedGroup.isAvailable) {
|
|
groupList.add(namedGroup);
|
|
}
|
|
} // ignore unknown groups
|
|
}
|
|
}
|
|
|
|
if (groupList.isEmpty()) {
|
|
throw new IllegalArgumentException(
|
|
"System property jdk.tls.namedGroups(" +
|
|
property + ") contains no supported named groups");
|
|
}
|
|
} else { // default groups
|
|
NamedGroup[] groups = new NamedGroup[] {
|
|
|
|
// Primary XDH (RFC 7748) curves
|
|
NamedGroup.X25519,
|
|
|
|
// Primary NIST Suite B curves
|
|
NamedGroup.SECP256_R1,
|
|
NamedGroup.SECP384_R1,
|
|
NamedGroup.SECP521_R1,
|
|
|
|
// Secondary XDH curves
|
|
NamedGroup.X448,
|
|
|
|
// FFDHE (RFC 7919)
|
|
NamedGroup.FFDHE_2048,
|
|
NamedGroup.FFDHE_3072,
|
|
NamedGroup.FFDHE_4096,
|
|
NamedGroup.FFDHE_6144,
|
|
NamedGroup.FFDHE_8192,
|
|
};
|
|
|
|
groupList = new ArrayList<>(groups.length);
|
|
for (NamedGroup group : groups) {
|
|
if (group.isAvailable) {
|
|
groupList.add(group);
|
|
}
|
|
}
|
|
|
|
if (groupList.isEmpty() &&
|
|
SSLLogger.isOn && SSLLogger.isOn("ssl")) {
|
|
SSLLogger.warning("No default named groups");
|
|
}
|
|
}
|
|
|
|
supportedNamedGroups = new NamedGroup[groupList.size()];
|
|
int i = 0;
|
|
for (NamedGroup namedGroup : groupList) {
|
|
supportedNamedGroups[i++] = namedGroup;
|
|
}
|
|
}
|
|
|
|
// Is there any supported group permitted by the constraints?
|
|
static boolean isActivatable(
|
|
AlgorithmConstraints constraints, NamedGroupSpec type) {
|
|
|
|
boolean hasFFDHEGroups = false;
|
|
for (NamedGroup namedGroup : supportedNamedGroups) {
|
|
if (namedGroup.isAvailable && namedGroup.spec == type) {
|
|
if (namedGroup.isPermitted(constraints)) {
|
|
return true;
|
|
}
|
|
|
|
if (!hasFFDHEGroups &&
|
|
(type == NamedGroupSpec.NAMED_GROUP_FFDHE)) {
|
|
hasFFDHEGroups = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// For compatibility, if no FFDHE groups are defined, the non-FFDHE
|
|
// compatible mode (using DHE cipher suite without FFDHE extension)
|
|
// is allowed.
|
|
//
|
|
// Note that the constraints checking on DHE parameters will be
|
|
// performed during key exchanging in a handshake.
|
|
return !hasFFDHEGroups && type == NamedGroupSpec.NAMED_GROUP_FFDHE;
|
|
}
|
|
|
|
// Is the named group permitted by the constraints?
|
|
static boolean isActivatable(
|
|
AlgorithmConstraints constraints, NamedGroup namedGroup) {
|
|
if (!namedGroup.isAvailable || !isSupported(namedGroup)) {
|
|
return false;
|
|
}
|
|
|
|
return namedGroup.isPermitted(constraints);
|
|
}
|
|
|
|
// Is the named group supported?
|
|
static boolean isSupported(NamedGroup namedGroup) {
|
|
for (NamedGroup group : supportedNamedGroups) {
|
|
if (namedGroup.id == group.id) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static NamedGroup getPreferredGroup(
|
|
ProtocolVersion negotiatedProtocol,
|
|
AlgorithmConstraints constraints, NamedGroupSpec[] types,
|
|
List<NamedGroup> requestedNamedGroups) {
|
|
for (NamedGroup namedGroup : requestedNamedGroups) {
|
|
if ((NamedGroupSpec.arrayContains(types, namedGroup.spec)) &&
|
|
namedGroup.isAvailable(negotiatedProtocol) &&
|
|
isSupported(namedGroup) &&
|
|
namedGroup.isPermitted(constraints)) {
|
|
return namedGroup;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
static NamedGroup getPreferredGroup(
|
|
ProtocolVersion negotiatedProtocol,
|
|
AlgorithmConstraints constraints, NamedGroupSpec[] types) {
|
|
for (NamedGroup namedGroup : supportedNamedGroups) {
|
|
if ((NamedGroupSpec.arrayContains(types, namedGroup.spec)) &&
|
|
namedGroup.isAvailable(negotiatedProtocol) &&
|
|
namedGroup.isPermitted(constraints)) {
|
|
return namedGroup;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Network data producer of a "supported_groups" extension in
|
|
* the ClientHello handshake message.
|
|
*/
|
|
private static final class CHSupportedGroupsProducer
|
|
extends SupportedGroups implements HandshakeProducer {
|
|
// Prevent instantiation of this class.
|
|
private CHSupportedGroupsProducer() {
|
|
// blank
|
|
}
|
|
|
|
@Override
|
|
public byte[] produce(ConnectionContext context,
|
|
HandshakeMessage message) throws IOException {
|
|
// The producing happens in client side only.
|
|
ClientHandshakeContext chc = (ClientHandshakeContext)context;
|
|
|
|
// Is it a supported and enabled extension?
|
|
if (!chc.sslConfig.isAvailable(CH_SUPPORTED_GROUPS)) {
|
|
if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.fine(
|
|
"Ignore unavailable supported_groups extension");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Produce the extension.
|
|
ArrayList<NamedGroup> namedGroups =
|
|
new ArrayList<>(SupportedGroups.supportedNamedGroups.length);
|
|
for (NamedGroup ng : SupportedGroups.supportedNamedGroups) {
|
|
if ((!SupportedGroups.enableFFDHE) &&
|
|
(ng.spec == NamedGroupSpec.NAMED_GROUP_FFDHE)) {
|
|
continue;
|
|
}
|
|
|
|
if (ng.isAvailable(chc.activeProtocols) &&
|
|
ng.isSupported(chc.activeCipherSuites) &&
|
|
ng.isPermitted(chc.algorithmConstraints)) {
|
|
namedGroups.add(ng);
|
|
} else if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.fine(
|
|
"Ignore inactive or disabled named group: " + ng.name);
|
|
}
|
|
}
|
|
|
|
if (namedGroups.isEmpty()) {
|
|
if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.warning("no available named group");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
int vectorLen = namedGroups.size() << 1;
|
|
byte[] extData = new byte[vectorLen + 2];
|
|
ByteBuffer m = ByteBuffer.wrap(extData);
|
|
Record.putInt16(m, vectorLen);
|
|
for (NamedGroup namedGroup : namedGroups) {
|
|
Record.putInt16(m, namedGroup.id);
|
|
}
|
|
|
|
// Update the context.
|
|
chc.clientRequestedNamedGroups =
|
|
Collections.<NamedGroup>unmodifiableList(namedGroups);
|
|
chc.handshakeExtensions.put(CH_SUPPORTED_GROUPS,
|
|
new SupportedGroupsSpec(namedGroups));
|
|
|
|
return extData;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Network data producer of a "supported_groups" extension in
|
|
* the ClientHello handshake message.
|
|
*/
|
|
private static final
|
|
class CHSupportedGroupsConsumer implements ExtensionConsumer {
|
|
// Prevent instantiation of this class.
|
|
private CHSupportedGroupsConsumer() {
|
|
// blank
|
|
}
|
|
|
|
@Override
|
|
public void consume(ConnectionContext context,
|
|
HandshakeMessage message, ByteBuffer buffer) throws IOException {
|
|
// The consuming happens in server side only.
|
|
ServerHandshakeContext shc = (ServerHandshakeContext)context;
|
|
|
|
// Is it a supported and enabled extension?
|
|
if (!shc.sslConfig.isAvailable(CH_SUPPORTED_GROUPS)) {
|
|
if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.fine(
|
|
"Ignore unavailable supported_groups extension");
|
|
}
|
|
return; // ignore the extension
|
|
}
|
|
|
|
// Parse the extension.
|
|
SupportedGroupsSpec spec = new SupportedGroupsSpec(shc, buffer);
|
|
|
|
// Update the context.
|
|
List<NamedGroup> knownNamedGroups = new LinkedList<>();
|
|
for (int id : spec.namedGroupsIds) {
|
|
NamedGroup ng = NamedGroup.valueOf(id);
|
|
if (ng != null) {
|
|
knownNamedGroups.add(ng);
|
|
}
|
|
}
|
|
|
|
shc.clientRequestedNamedGroups = knownNamedGroups;
|
|
shc.handshakeExtensions.put(CH_SUPPORTED_GROUPS, spec);
|
|
|
|
// No impact on session resumption.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The absence processing if the extension is not present in
|
|
* a ClientHello handshake message.
|
|
*/
|
|
private static final class CHSupportedGroupsOnTradeAbsence
|
|
implements HandshakeAbsence {
|
|
@Override
|
|
public void absent(ConnectionContext context,
|
|
HandshakeMessage message) throws IOException {
|
|
// The producing happens in server side only.
|
|
ServerHandshakeContext shc = (ServerHandshakeContext)context;
|
|
|
|
// A client is considered to be attempting to negotiate using this
|
|
// specification if the ClientHello contains a "supported_versions"
|
|
// extension with 0x0304 contained in its body. Such a ClientHello
|
|
// message MUST meet the following requirements:
|
|
// - If containing a "supported_groups" extension, it MUST also
|
|
// contain a "key_share" extension, and vice versa. An empty
|
|
// KeyShare.client_shares vector is permitted.
|
|
if (shc.negotiatedProtocol.useTLS13PlusSpec() &&
|
|
shc.handshakeExtensions.containsKey(
|
|
SSLExtension.CH_KEY_SHARE)) {
|
|
throw shc.conContext.fatal(Alert.MISSING_EXTENSION,
|
|
"No supported_groups extension to work with " +
|
|
"the key_share extension");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Network data producer of a "supported_groups" extension in
|
|
* the EncryptedExtensions handshake message.
|
|
*/
|
|
private static final class EESupportedGroupsProducer
|
|
extends SupportedGroups implements HandshakeProducer {
|
|
|
|
// Prevent instantiation of this class.
|
|
private EESupportedGroupsProducer() {
|
|
// blank
|
|
}
|
|
|
|
@Override
|
|
public byte[] produce(ConnectionContext context,
|
|
HandshakeMessage message) throws IOException {
|
|
// The producing happens in server side only.
|
|
ServerHandshakeContext shc = (ServerHandshakeContext)context;
|
|
|
|
// Is it a supported and enabled extension?
|
|
if (!shc.sslConfig.isAvailable(EE_SUPPORTED_GROUPS)) {
|
|
if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.fine(
|
|
"Ignore unavailable supported_groups extension");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Produce the extension.
|
|
//
|
|
// Contains all groups the server supports, regardless of whether
|
|
// they are currently supported by the client.
|
|
ArrayList<NamedGroup> namedGroups = new ArrayList<>(
|
|
SupportedGroups.supportedNamedGroups.length);
|
|
for (NamedGroup ng : SupportedGroups.supportedNamedGroups) {
|
|
if ((!SupportedGroups.enableFFDHE) &&
|
|
(ng.spec == NamedGroupSpec.NAMED_GROUP_FFDHE)) {
|
|
continue;
|
|
}
|
|
|
|
if (ng.isAvailable(shc.activeProtocols) &&
|
|
ng.isSupported(shc.activeCipherSuites) &&
|
|
ng.isPermitted(shc.algorithmConstraints)) {
|
|
namedGroups.add(ng);
|
|
} else if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.fine(
|
|
"Ignore inactive or disabled named group: " + ng.name);
|
|
}
|
|
}
|
|
|
|
if (namedGroups.isEmpty()) {
|
|
if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.warning("no available named group");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
int vectorLen = namedGroups.size() << 1;
|
|
byte[] extData = new byte[vectorLen + 2];
|
|
ByteBuffer m = ByteBuffer.wrap(extData);
|
|
Record.putInt16(m, vectorLen);
|
|
for (NamedGroup namedGroup : namedGroups) {
|
|
Record.putInt16(m, namedGroup.id);
|
|
}
|
|
|
|
// Update the context.
|
|
shc.conContext.serverRequestedNamedGroups =
|
|
Collections.<NamedGroup>unmodifiableList(namedGroups);
|
|
SupportedGroupsSpec spec = new SupportedGroupsSpec(namedGroups);
|
|
shc.handshakeExtensions.put(EE_SUPPORTED_GROUPS, spec);
|
|
|
|
return extData;
|
|
}
|
|
}
|
|
|
|
private static final
|
|
class EESupportedGroupsConsumer implements ExtensionConsumer {
|
|
// Prevent instantiation of this class.
|
|
private EESupportedGroupsConsumer() {
|
|
// blank
|
|
}
|
|
|
|
@Override
|
|
public void consume(ConnectionContext context,
|
|
HandshakeMessage message, ByteBuffer buffer) throws IOException {
|
|
// The consuming happens in client side only.
|
|
ClientHandshakeContext chc = (ClientHandshakeContext)context;
|
|
|
|
// Is it a supported and enabled extension?
|
|
if (!chc.sslConfig.isAvailable(EE_SUPPORTED_GROUPS)) {
|
|
if (SSLLogger.isOn && SSLLogger.isOn("ssl,handshake")) {
|
|
SSLLogger.fine(
|
|
"Ignore unavailable supported_groups extension");
|
|
}
|
|
return; // ignore the extension
|
|
}
|
|
|
|
// Parse the extension.
|
|
SupportedGroupsSpec spec = new SupportedGroupsSpec(chc, buffer);
|
|
|
|
// Update the context.
|
|
List<NamedGroup> knownNamedGroups =
|
|
new ArrayList<>(spec.namedGroupsIds.length);
|
|
for (int id : spec.namedGroupsIds) {
|
|
NamedGroup ng = NamedGroup.valueOf(id);
|
|
if (ng != null) {
|
|
knownNamedGroups.add(ng);
|
|
}
|
|
}
|
|
|
|
chc.conContext.serverRequestedNamedGroups = knownNamedGroups;
|
|
chc.handshakeExtensions.put(EE_SUPPORTED_GROUPS, spec);
|
|
|
|
// No impact on session resumption.
|
|
}
|
|
}
|
|
}
|