/*
* Copyright (C) 2016 - 2018 ARPA2 project
*
* Author: Tom Vrancken (dev@tomvrancken.nl)
*
* This file is part of GnuTLS.
*
* The GnuTLS is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>
*
* This file is part of the server_certificate_type extension as
* defined in RFC7250 (https://tools.ietf.org/html/rfc7250).
*
* The server_certificate_type extension in the client hello indicates
* the types of certificates the client is able to process when provided
* by the server in a subsequent certificate payload.
*/
#include <gnutls_int.h>
#include <gnutls/gnutls.h>
#include "ext/cert_types.h"
#include "ext/server_cert_type.h"
#include "hello_ext.h"
#include "hello_ext_lib.h"
#include "errors.h"
#include "state.h"
#include "datum.h"
static int _gnutls_server_cert_type_recv_params(gnutls_session_t session,
const uint8_t* data,
size_t data_size);
static int _gnutls_server_cert_type_send_params(gnutls_session_t session,
gnutls_buffer_st* data);
const hello_ext_entry_st ext_mod_server_cert_type = {
.name = "Server Certificate Type",
.tls_id = 20,
.gid = GNUTLS_EXTENSION_SERVER_CERT_TYPE,
.client_parse_point = GNUTLS_EXT_TLS,
.server_parse_point = GNUTLS_EXT_TLS,
.validity = GNUTLS_EXT_FLAG_TLS |
GNUTLS_EXT_FLAG_DTLS |
GNUTLS_EXT_FLAG_CLIENT_HELLO |
GNUTLS_EXT_FLAG_TLS12_SERVER_HELLO |
GNUTLS_EXT_FLAG_EE,
.recv_func = _gnutls_server_cert_type_recv_params,
.send_func = _gnutls_server_cert_type_send_params,
.pack_func = _gnutls_hello_ext_default_pack,
.unpack_func = _gnutls_hello_ext_default_unpack,
.deinit_func = _gnutls_hello_ext_default_deinit,
.cannot_be_overriden = 1
};
static int _gnutls_server_cert_type_recv_params(gnutls_session_t session,
const uint8_t* data,
size_t data_size)
{
int ret;
gnutls_datum_t cert_types; // Holds the received cert types
gnutls_datum_t sent_cert_types; // Holds the previously sent cert types
gnutls_certificate_type_t cert_type;
uint8_t i, found = 0;
const uint8_t* pdata = data;
/* Only activate this extension if we have cert credentials set
* and alternative cert types are allowed */
if (!are_alternative_cert_types_allowed(session) ||
(_gnutls_get_cred(session, GNUTLS_CRD_CERTIFICATE) == NULL))
return 0;
if (!IS_SERVER(session)) { // client mode
/* Compare packet length with expected packet length. For the
* client this is a single byte. */
if (data_size != 1) {
return
gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
}
/* The server picked one of the offered cert types if he supports
* at least one of them. If both parties play by the rules then we
* may only receive a cert type that we offered, i.e. one that we
* support. Because the world isn't as beautiful as it may seem,
* we're going to check it nevertheless. */
cert_type = IANA2cert_type(pdata[0]);
// Check validity of cert type
if (cert_type == GNUTLS_CRT_UNKNOWN) {
return gnutls_assert_val(GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE);
}
/* Get the cert types that we sent to the server (they were stored
* in IANA representation.
*/
ret = _gnutls_hello_ext_get_datum(session,
GNUTLS_EXTENSION_SERVER_CERT_TYPE,
&sent_cert_types);
if (ret < 0) {
/* This should not happen and indicate a memory corruption!
* Assertion are always on in production code so execution
* will halt here. */
assert(false);
}
// Check whether what we got back is actually offered by us
for (i = 0; i < sent_cert_types.size; i++) {
if (IANA2cert_type(sent_cert_types.data[i]) == cert_type)
found = 1;
}
if (found) {
// Everything OK, now set the server certificate type
_gnutls_session_server_cert_type_set(session, cert_type);
ret = GNUTLS_E_SUCCESS;
} else {
// No valid cert type found
ret = GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE;
}
return ret;
} else { // server mode
// Compare packet length with expected packet length.
DECR_LEN(data_size, 1);
if (data[0] != data_size) {
return
gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
}
pdata += 1;
// Assign the contents of our data buffer to a gnutls_datum_t
cert_types.data = (uint8_t*)pdata; // Need casting to get rid of 'discards const qualifier' warning
cert_types.size = data_size;
// Store the server certificate types in our session
_gnutls_hello_ext_set_datum(session,
GNUTLS_EXTENSION_SERVER_CERT_TYPE,
&cert_types);
/* We receive a list of supported certificate types that the client
* is able to process when offered by the server via a subsequent
* Certificate message. This list is sorted by order of preference.
* We now check in this order of preference whether we support any
* of these certificate types.
*/
for (i = 0; i < cert_types.size; i++) {
// Convert to internal representation
cert_type = IANA2cert_type(cert_types.data[i]);
// If we have an invalid cert id then continue to the next
if (cert_type == GNUTLS_CRT_UNKNOWN)
continue;
// Check for support of this cert type
if (_gnutls_session_cert_type_supported
(session, cert_type, true, GNUTLS_CTYPE_SERVER) == 0) {
found = 1;
break;
}
}
// We found a matching ctype, we pick this one
if (found) {
_gnutls_session_server_cert_type_set(session, cert_type);
ret = GNUTLS_E_SUCCESS;
} else {
/* If no supported certificate type can be found we terminate
* with a fatal alert of type "unsupported_certificate"
* (according to specification rfc7250).
*/
ret = GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE;
}
return ret;
}
}
static int _gnutls_server_cert_type_send_params(gnutls_session_t session,
gnutls_buffer_st* data)
{
int ret;
uint8_t cert_type; // Holds an IANA cert type ID
uint8_t i = 0, num_cert_types = 0;
priority_st* cert_priorities;
gnutls_datum_t tmp_cert_types; // For type conversion
uint8_t cert_types[GNUTLS_CRT_MAX]; // The list with supported cert types. Inv: 0 <= cert type Id < 256
/* Only activate this extension if we have cert credentials set
* and alternative cert types are allowed */
if (!are_alternative_cert_types_allowed(session) ||
(_gnutls_get_cred(session, GNUTLS_CRD_CERTIFICATE) == NULL))
return 0;
if (!IS_SERVER(session)) { // Client mode
// For brevity
cert_priorities =
&session->internals.priorities->server_ctype;
/* Retrieve server certificate type priorities if any. If no
* priorities are set then the default server certificate type
* initialization values apply. This default is currently set to
* X.509 in which case we don't enable this extension.
*/
if (cert_priorities->num_priorities > 0) { // Priorities are explicitly set
/* If the certificate priority is explicitly set to only
* X.509 (default) then, according to spec we don't send
* this extension. We check this here to avoid further work in
* this routine. We also check it below after pruning supported
* types.
*/
if (cert_priorities->num_priorities == 1 &&
cert_priorities->priorities[0] == DEFAULT_CERT_TYPE) {
_gnutls_handshake_log
("EXT[%p]: Server certificate type was set to default cert type (%s). "
"We therefore do not send this extension.\n",
session,
gnutls_certificate_type_get_name(DEFAULT_CERT_TYPE));
// Explicitly set but default ctype, so don't send anything
return 0;
}
/* We are only allowed to send certificate types that we support.
* Therefore we check this here and prune our original list.
* This check might seem redundant now because we don't check for
* credentials (they are not needed for a client) and only check the
* priorities over which we already iterate. In the future,
* additional checks might be necessary and they can be easily
* added in the ..type_supported() routine without modifying the
* structure of the code here.
*/
for (i = 0; i < cert_priorities->num_priorities; i++) {
if (_gnutls_session_cert_type_supported
(session, cert_priorities->priorities[i],
false, GNUTLS_CTYPE_SERVER) == 0) {
/* Check whether we are allowed to store another cert type
* in our buffer. In other words, prevent a possible buffer
* overflow. This situation can occur when a user sets
* duplicate cert types in the priority strings. */
if (num_cert_types >= GNUTLS_CRT_MAX)
return gnutls_assert_val(GNUTLS_E_SHORT_MEMORY_BUFFER);
// Convert to IANA representation
ret = cert_type2IANA(cert_priorities->priorities[i]);
if (ret < 0)
return gnutls_assert_val(ret);
cert_type = ret; // For readability
// Add this cert type to our list with supported types
cert_types[num_cert_types] = cert_type;
num_cert_types++;
_gnutls_handshake_log
("EXT[%p]: Server certificate type %s (%d) was queued.\n",
session,
gnutls_certificate_type_get_name(cert_priorities->priorities[i]),
cert_type);
}
}
/* Check whether there are any supported certificate types left
* after the previous pruning step. If not, we do not send this
* extension. Also, if the only supported type is the default type
* we do not send this extension (according to RFC7250).
*/
if (num_cert_types == 0) { // For now, this should not occur since we only check priorities while pruning.
_gnutls_handshake_log
("EXT[%p]: Server certificate types were set but none of them is supported. "
"We do not send this extension.\n",
session);
return 0;
} else if (num_cert_types == 1 &&
IANA2cert_type(cert_types[0]) == DEFAULT_CERT_TYPE) {
_gnutls_handshake_log
("EXT[%p]: The only supported server certificate type is (%s) which is the default. "
"We therefore do not send this extension.\n",
session,
gnutls_certificate_type_get_name(DEFAULT_CERT_TYPE));
return 0;
}
/* We have data to send and store a copy internally. We convert
* our list with supported cert types to a datum_t in order to
* be able to make the ..._set_datum call.
*/
tmp_cert_types.data = cert_types;
tmp_cert_types.size = num_cert_types;
_gnutls_hello_ext_set_datum(session,
GNUTLS_EXTENSION_SERVER_CERT_TYPE,
&tmp_cert_types);
/* Serialize the certificate types into a sequence of octets
* uint8: length of sequence of cert types (1 octet)
* uint8: cert types (0 <= #octets <= 255)
*/
ret = _gnutls_buffer_append_data_prefix(data, 8,
cert_types,
num_cert_types);
// Check for errors and cleanup in case of error
if (ret < 0) {
return gnutls_assert_val(ret);
} else {
// Number of bytes we are sending
return num_cert_types + 1;
}
}
} else { // Server mode
// Retrieve negotiated server certificate type and send it
ret = cert_type2IANA(get_certificate_type(
session, GNUTLS_CTYPE_SERVER));
if (ret < 0)
return gnutls_assert_val(ret);
cert_type = ret; // For readability
ret = gnutls_buffer_append_data(data, &cert_type, 1);
if (ret < 0)
return gnutls_assert_val(ret);
return 1; // sent one byte
}
// In all other cases don't enable this extension
return 0;
}
/** Extension interface **/
/* The interface is defined in state.c:
* Public:
* - gnutls_certificate_type_get2
*
* Private:
* - _gnutls_session_server_cert_type_set
*/