Source code

Revision control

Other Tools

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nss.h"
#include "pk11func.h"
#include "ssl.h"
#include "sslproto.h"
#include "sslimpl.h"
#include "ssl3exthandle.h"
#include "tls13exthandle.h"
#include "tls13hkdf.h"
#include "tls13psk.h"
SECStatus
SSLExp_AddExternalPsk0Rtt(PRFileDesc *fd, PK11SymKey *key, const PRUint8 *identity,
unsigned int identityLen, SSLHashType hash,
PRUint16 zeroRttSuite, PRUint32 maxEarlyData)
{
sslSocket *ss = ssl_FindSocket(fd);
if (!ss) {
SSL_DBG(("%d: SSL[%d]: bad socket in SSLExp_SetExternalPsk",
SSL_GETPID(), fd));
return SECFailure;
}
if (!key || !identity || !identityLen || identityLen > 0xFFFF ||
(hash != ssl_hash_sha256 && hash != ssl_hash_sha384)) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
return SECFailure;
}
SECItem label = { siBuffer, CONST_CAST(unsigned char, identity), identityLen };
sslPsk *psk = tls13_MakePsk(PK11_ReferenceSymKey(key), ssl_psk_external,
hash, &label);
if (!psk) {
PORT_SetError(SEC_ERROR_NO_MEMORY);
return SECFailure;
}
psk->zeroRttSuite = zeroRttSuite;
psk->maxEarlyData = maxEarlyData;
SECStatus rv = SECFailure;
ssl_Get1stHandshakeLock(ss);
ssl_GetSSL3HandshakeLock(ss);
if (ss->psk) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
tls13_DestroyPsk(psk);
} else {
ss->psk = psk;
rv = SECSuccess;
tls13_ResetHandshakePsks(ss, &ss->ssl3.hs.psks);
}
ssl_ReleaseSSL3HandshakeLock(ss);
ssl_Release1stHandshakeLock(ss);
return rv;
}
SECStatus
SSLExp_AddExternalPsk(PRFileDesc *fd, PK11SymKey *key, const PRUint8 *identity,
unsigned int identityLen, SSLHashType hash)
{
return SSLExp_AddExternalPsk0Rtt(fd, key, identity, identityLen,
hash, TLS_NULL_WITH_NULL_NULL, 0);
}
SECStatus
SSLExp_RemoveExternalPsk(PRFileDesc *fd, const PRUint8 *identity, unsigned int identityLen)
{
if (!identity || !identityLen) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
return SECFailure;
}
sslSocket *ss = ssl_FindSocket(fd);
if (!ss) {
SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetPSK",
SSL_GETPID(), fd));
return SECFailure;
}
SECItem removeIdentity = { siBuffer,
(unsigned char *)identity,
identityLen };
SECStatus rv;
ssl_Get1stHandshakeLock(ss);
ssl_GetSSL3HandshakeLock(ss);
if (!ss->psk || SECITEM_CompareItem(&ss->psk->label, &removeIdentity) != SECEqual) {
PORT_SetError(SEC_ERROR_NO_KEY);
rv = SECFailure;
} else {
tls13_DestroyPsk(ss->psk);
ss->psk = NULL;
tls13_ResetHandshakePsks(ss, &ss->ssl3.hs.psks);
rv = SECSuccess;
}
ssl_ReleaseSSL3HandshakeLock(ss);
ssl_Release1stHandshakeLock(ss);
return rv;
}
sslPsk *
tls13_CopyPsk(sslPsk *opsk)
{
if (!opsk || !opsk->key) {
return NULL;
}
sslPsk *psk = PORT_ZNew(sslPsk);
if (!psk) {
return NULL;
}
SECStatus rv = SECITEM_CopyItem(NULL, &psk->label, &opsk->label);
if (rv != SECSuccess) {
PORT_Free(psk);
return NULL;
}
/* We should only have the initial key. Binder keys
* are derived during the handshake. */
PORT_Assert(opsk->type == ssl_psk_external);
PORT_Assert(opsk->key);
PORT_Assert(!opsk->binderKey);
psk->hash = opsk->hash;
psk->type = opsk->type;
psk->key = opsk->key ? PK11_ReferenceSymKey(opsk->key) : NULL;
psk->binderKey = opsk->binderKey ? PK11_ReferenceSymKey(opsk->binderKey) : NULL;
return psk;
}
void
tls13_DestroyPsk(sslPsk *psk)
{
if (!psk) {
return;
}
if (psk->key) {
PK11_FreeSymKey(psk->key);
psk->key = NULL;
}
if (psk->binderKey) {
PK11_FreeSymKey(psk->binderKey);
psk->binderKey = NULL;
}
SECITEM_ZfreeItem(&psk->label, PR_FALSE);
PORT_ZFree(psk, sizeof(*psk));
}
void
tls13_DestroyPskList(PRCList *list)
{
PRCList *cur_p;
while (!PR_CLIST_IS_EMPTY(list)) {
cur_p = PR_LIST_TAIL(list);
PR_REMOVE_LINK(cur_p);
tls13_DestroyPsk((sslPsk *)cur_p);
}
}
sslPsk *
tls13_MakePsk(PK11SymKey *key, SSLPskType pskType, SSLHashType hashType, const SECItem *label)
{
sslPsk *psk = PORT_ZNew(sslPsk);
if (!psk) {
PORT_SetError(SEC_ERROR_NO_MEMORY);
return NULL;
}
psk->type = pskType;
psk->hash = hashType;
psk->key = key;
/* Label is NULL in the resumption case. */
if (label) {
PORT_Assert(psk->type != ssl_psk_resume);
SECStatus rv = SECITEM_CopyItem(NULL, &psk->label, label);
if (rv != SECSuccess) {
PORT_SetError(SEC_ERROR_NO_MEMORY);
tls13_DestroyPsk(psk);
return NULL;
}
}
return psk;
}
/* Destroy any existing PSKs in |list| then copy
* in the configured |ss->psk|, if any.*/
SECStatus
tls13_ResetHandshakePsks(sslSocket *ss, PRCList *list)
{
tls13_DestroyPskList(list);
PORT_Assert(!ss->xtnData.selectedPsk);
ss->xtnData.selectedPsk = NULL;
if (ss->psk) {
PORT_Assert(ss->psk->type == ssl_psk_external);
PORT_Assert(ss->psk->key);
PORT_Assert(!ss->psk->binderKey);
sslPsk *epsk = tls13_MakePsk(PK11_ReferenceSymKey(ss->psk->key),
ss->psk->type, ss->psk->hash, &ss->psk->label);
if (!epsk) {
return SECFailure;
}
epsk->zeroRttSuite = ss->psk->zeroRttSuite;
epsk->maxEarlyData = ss->psk->maxEarlyData;
PR_APPEND_LINK(&epsk->link, list);
}
return SECSuccess;
}