static int ssl_set_cert(CERT *c, X509 *x509);
static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey);
+
+#define SYNTHV1CONTEXT (SSL_EXT_TLS1_2_AND_BELOW_ONLY \
+ | SSL_EXT_CLIENT_HELLO \
+ | SSL_EXT_TLS1_2_SERVER_HELLO \
+ | SSL_EXT_IGNORE_ON_RESUMPTION)
+
int SSL_use_certificate(SSL *ssl, X509 *x)
{
int rv;
if (x == NULL) {
SSLerr(SSL_F_SSL_USE_CERTIFICATE, ERR_R_PASSED_NULL_PARAMETER);
- return (0);
+ return 0;
}
rv = ssl_security_cert(ssl, NULL, x, 0, 1);
if (rv != 1) {
return 0;
}
- return (ssl_set_cert(ssl->cert, x));
+ return ssl_set_cert(ssl->cert, x);
}
int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
end:
X509_free(x);
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len)
x = d2i_X509(NULL, &d, (long)len);
if (x == NULL) {
SSLerr(SSL_F_SSL_USE_CERTIFICATE_ASN1, ERR_R_ASN1_LIB);
- return (0);
+ return 0;
}
ret = SSL_use_certificate(ssl, x);
X509_free(x);
- return (ret);
+ return ret;
}
#ifndef OPENSSL_NO_RSA
if (rsa == NULL) {
SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
- return (0);
+ return 0;
}
if ((pkey = EVP_PKEY_new()) == NULL) {
SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY, ERR_R_EVP_LIB);
- return (0);
+ return 0;
}
RSA_up_ref(rsa);
ret = ssl_set_pkey(ssl->cert, pkey);
EVP_PKEY_free(pkey);
- return (ret);
+ return ret;
}
#endif
static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey)
{
- int i;
- i = ssl_cert_type(NULL, pkey);
- if (i < 0) {
+ size_t i;
+
+ if (ssl_cert_lookup_by_pkey(pkey, &i) == NULL) {
SSLerr(SSL_F_SSL_SET_PKEY, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
- return (0);
+ return 0;
}
if (c->pkeys[i].x509 != NULL) {
EVP_PKEY_free(c->pkeys[i].privatekey);
EVP_PKEY_up_ref(pkey);
c->pkeys[i].privatekey = pkey;
- c->key = &(c->pkeys[i]);
- return (1);
+ c->key = &c->pkeys[i];
+ return 1;
}
#ifndef OPENSSL_NO_RSA
RSA_free(rsa);
end:
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, const unsigned char *d, long len)
p = d;
if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) {
SSLerr(SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
- return (0);
+ return 0;
}
ret = SSL_use_RSAPrivateKey(ssl, rsa);
RSA_free(rsa);
- return (ret);
+ return ret;
}
#endif /* !OPENSSL_NO_RSA */
if (pkey == NULL) {
SSLerr(SSL_F_SSL_USE_PRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
- return (0);
+ return 0;
}
ret = ssl_set_pkey(ssl->cert, pkey);
- return (ret);
+ return ret;
}
int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
EVP_PKEY_free(pkey);
end:
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d,
p = d;
if ((pkey = d2i_PrivateKey(type, NULL, &p, (long)len)) == NULL) {
SSLerr(SSL_F_SSL_USE_PRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
- return (0);
+ return 0;
}
ret = SSL_use_PrivateKey(ssl, pkey);
EVP_PKEY_free(pkey);
- return (ret);
+ return ret;
}
int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x)
int rv;
if (x == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE, ERR_R_PASSED_NULL_PARAMETER);
- return (0);
+ return 0;
}
rv = ssl_security_cert(NULL, ctx, x, 0, 1);
if (rv != 1) {
SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE, rv);
return 0;
}
- return (ssl_set_cert(ctx->cert, x));
+ return ssl_set_cert(ctx->cert, x);
}
static int ssl_set_cert(CERT *c, X509 *x)
{
EVP_PKEY *pkey;
- int i;
+ size_t i;
pkey = X509_get0_pubkey(x);
if (pkey == NULL) {
SSLerr(SSL_F_SSL_SET_CERT, SSL_R_X509_LIB);
- return (0);
+ return 0;
}
- i = ssl_cert_type(x, pkey);
- if (i < 0) {
+ if (ssl_cert_lookup_by_pkey(pkey, &i) == NULL) {
SSLerr(SSL_F_SSL_SET_CERT, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
return 0;
}
end:
X509_free(x);
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, const unsigned char *d)
x = d2i_X509(NULL, &d, (long)len);
if (x == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_CERTIFICATE_ASN1, ERR_R_ASN1_LIB);
- return (0);
+ return 0;
}
ret = SSL_CTX_use_certificate(ctx, x);
X509_free(x);
- return (ret);
+ return ret;
}
#ifndef OPENSSL_NO_RSA
if (rsa == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
- return (0);
+ return 0;
}
if ((pkey = EVP_PKEY_new()) == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY, ERR_R_EVP_LIB);
- return (0);
+ return 0;
}
RSA_up_ref(rsa);
ret = ssl_set_pkey(ctx->cert, pkey);
EVP_PKEY_free(pkey);
- return (ret);
+ return ret;
}
int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type)
RSA_free(rsa);
end:
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
p = d;
if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
- return (0);
+ return 0;
}
ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa);
RSA_free(rsa);
- return (ret);
+ return ret;
}
#endif /* !OPENSSL_NO_RSA */
{
if (pkey == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
- return (0);
+ return 0;
}
- return (ssl_set_pkey(ctx->cert, pkey));
+ return ssl_set_pkey(ctx->cert, pkey);
}
int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
EVP_PKEY_free(pkey);
end:
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx,
p = d;
if ((pkey = d2i_PrivateKey(type, NULL, &p, (long)len)) == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1, ERR_R_ASN1_LIB);
- return (0);
+ return 0;
}
ret = SSL_CTX_use_PrivateKey(ctx, pkey);
EVP_PKEY_free(pkey);
- return (ret);
+ return ret;
}
/*
end:
X509_free(x);
BIO_free(in);
- return (ret);
+ return ret;
}
int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file)
const unsigned char *serverinfo = NULL;
size_t serverinfo_length = 0;
+ /* We only support extensions for the first Certificate */
+ if ((context & SSL_EXT_TLS1_3_CERTIFICATE) != 0 && chainidx > 0)
+ return 0;
+
/* Is there serverinfo data for the chosen server cert? */
if ((ssl_get_server_cert_serverinfo(s, &serverinfo,
&serverinfo_length)) != 0) {
int retval = serverinfo_find_extension(serverinfo, serverinfo_length,
ext_type, out, outlen);
if (retval == -1) {
- *al = SSL_AD_DECODE_ERROR;
+ *al = SSL_AD_INTERNAL_ERROR;
return -1; /* Error */
}
if (retval == 0)
if (serverinfo == NULL || serverinfo_length == 0)
return 0;
- if (version != SERVERINFOV1 && version != SERVERINFOV2)
+ if (version != SSL_SERVERINFOV1 && version != SSL_SERVERINFOV2)
return 0;
if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length))
unsigned int ext_type = 0;
PACKET data;
- if (!PACKET_get_net_4(&pkt, &context)
+ if ((version == SSL_SERVERINFOV2 && !PACKET_get_net_4(&pkt, &context))
|| !PACKET_get_net_2(&pkt, &ext_type)
|| !PACKET_get_length_prefixed_2(&pkt, &data))
return 0;
if (ctx == NULL)
continue;
- if (version == SERVERINFOV1) {
+ /*
+ * The old style custom extensions API could be set separately for
+ * server/client, i.e. you could set one custom extension for a client,
+ * and *for the same extension in the same SSL_CTX* you could set a
+ * custom extension for the server as well. It seems quite weird to be
+ * setting a custom extension for both client and server in a single
+ * SSL_CTX - but theoretically possible. This isn't possible in the
+ * new API. Therefore, if we have V1 serverinfo we use the old API. We
+ * also use the old API even if we have V2 serverinfo but the context
+ * looks like an old style <= TLSv1.2 extension.
+ */
+ if (version == SSL_SERVERINFOV1 || context == SYNTHV1CONTEXT) {
if (!SSL_CTX_add_server_custom_ext(ctx, ext_type,
serverinfo_srv_add_cb,
NULL, NULL,
int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
size_t serverinfo_length)
{
- return SSL_CTX_use_serverinfo_ex(ctx, SERVERINFOV1, serverinfo,
+ return SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV1, serverinfo,
serverinfo_length);
}
int ret = 0;
BIO *bin = NULL;
size_t num_extensions = 0, contextoff = 0;
- unsigned int version;
if (ctx == NULL || file == NULL) {
SSLerr(SSL_F_SSL_CTX_USE_SERVERINFO_FILE, ERR_R_PASSED_NULL_PARAMETER);
}
for (num_extensions = 0;; num_extensions++) {
+ unsigned int version;
+
if (PEM_read_bio(bin, &name, &header, &extension, &extension_length)
== 0) {
/*
goto end;
}
if (strncmp(name, namePrefix1, strlen(namePrefix1)) == 0) {
- version = SERVERINFOV1;
+ version = SSL_SERVERINFOV1;
} else {
if (strlen(name) < strlen(namePrefix2)) {
SSLerr(SSL_F_SSL_CTX_USE_SERVERINFO_FILE,
SSL_R_PEM_NAME_BAD_PREFIX);
goto end;
}
- version = SERVERINFOV2;
+ version = SSL_SERVERINFOV2;
}
/*
* Check that the decoded PEM data is plausible (valid length field)
*/
- if (version == SERVERINFOV1) {
+ if (version == SSL_SERVERINFOV1) {
/* 4 byte header: 2 bytes type, 2 bytes len */
if (extension_length < 4
|| (extension[2] << 8) + extension[3]
}
serverinfo = tmp;
if (contextoff > 0) {
- unsigned int synthcontext = SSL_EXT_CLIENT_HELLO
- | SSL_EXT_TLS1_2_SERVER_HELLO;
unsigned char *sinfo = serverinfo + serverinfo_length;
/* We know this only uses the last 2 bytes */
sinfo[0] = 0;
sinfo[1] = 0;
- sinfo[2] = (synthcontext >> 8) & 0xff;
- sinfo[3] = synthcontext & 0xff;
+ sinfo[2] = (SYNTHV1CONTEXT >> 8) & 0xff;
+ sinfo[3] = SYNTHV1CONTEXT & 0xff;
}
memcpy(serverinfo + serverinfo_length + contextoff,
extension, extension_length);
extension = NULL;
}
- ret = SSL_CTX_use_serverinfo_ex(ctx, version, serverinfo,
+ ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, serverinfo,
serverinfo_length);
end:
/* SSL_CTX_use_serverinfo makes a local copy of the serverinfo. */