Skip to content

Support in SSL for setting a private key id #2078

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
toddouska merged 3 commits into from
Feb 12, 2019
Merged

Support in SSL for setting a private key id #2078

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
47922a4
Support in SSL for setting a private key id
SparkiDev Feb 8, 2019
e86aae0
Change to allow setting of devId for private key
SparkiDev Feb 11, 2019
66ab6d8
Check FindObjectFinal call for error
SparkiDev Feb 11, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
188 changes: 69 additions & 119 deletions src/internal.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4413,9 +4413,11 @@ int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
#ifdef WOLFSSL_TLS13
ssl->buffers.certChainCnt = ctx->certChainCnt;
#endif
ssl->buffers.key = ctx->privateKey;
ssl->buffers.keyType = ctx->privateKeyType;
ssl->buffers.keySz = ctx->privateKeySz;
ssl->buffers.key = ctx->privateKey;
ssl->buffers.keyType = ctx->privateKeyType;
ssl->buffers.keyId = ctx->privateKeyId;
ssl->buffers.keySz = ctx->privateKeySz;
ssl->buffers.keyDevId = ctx->privateKeyDevId;
#endif
#if !defined(WOLFSSL_NO_CLIENT_AUTH) && defined(HAVE_ED25519) && \
!defined(NO_ED25519_CLIENT_AUTH)
Expand Down Expand Up @@ -16927,6 +16929,49 @@ int DecodePrivateKey(WOLFSSL *ssl, word16* length)
ERROR_OUT(NO_PRIVATE_KEY, exit_dpk);
}

#ifdef HAVE_PKCS11
if (ssl->buffers.keyDevId != INVALID_DEVID && ssl->buffers.keyId) {
if (ssl->buffers.keyType == rsa_sa_algo)
ssl->hsType = DYNAMIC_TYPE_RSA;
else if (ssl->buffers.keyType == ecc_dsa_sa_algo)
ssl->hsType = DYNAMIC_TYPE_ECC;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
if (ret != 0) {
goto exit_dpk;
}

if (ssl->buffers.keyType == rsa_sa_algo) {
ret = wc_InitRsaKey_Id((RsaKey*)ssl->hsKey,
ssl->buffers.key->buffer, ssl->buffers.key->length,
ssl->heap, ssl->buffers.keyDevId);
if (ret == 0) {
if (ssl->buffers.keySz < ssl->options.minRsaKeySz) {
WOLFSSL_MSG("RSA key size too small");
ERROR_OUT(RSA_KEY_SIZE_E, exit_dpk);
}

/* Return the maximum signature length. */
*length = (word16)ssl->buffers.keySz;
}
}
else if (ssl->buffers.keyType == ecc_dsa_sa_algo) {
ret = wc_ecc_init_id((ecc_key*)ssl->hsKey, ssl->buffers.key->buffer,
ssl->buffers.key->length, ssl->heap,
ssl->buffers.keyDevId);
if (ret == 0) {
if (ssl->buffers.keySz < ssl->options.minEccKeySz) {
WOLFSSL_MSG("ECC key size too small");
ERROR_OUT(ECC_KEY_SIZE_E, exit_dpk);
}

/* Return the maximum signature length. */
*length = (word16)ssl->buffers.keySz;
}
}
goto exit_dpk;
}
#endif

#ifndef NO_RSA
if (ssl->buffers.keyType == rsa_sa_algo || ssl->buffers.keyType == 0) {
ssl->hsType = DYNAMIC_TYPE_RSA;
Expand Down Expand Up @@ -22012,97 +22057,46 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
#endif
case rsa_sa_algo:
{
word32 i = 0;
int keySz;
word16 keySz;

ssl->hsType = DYNAMIC_TYPE_RSA;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
ssl->buffers.keyType = rsa_sa_algo;
ret = DecodePrivateKey(ssl, &keySz);
if (ret != 0) {
goto exit_sske;
}

ret = wc_RsaPrivateKeyDecode(
ssl->buffers.key->buffer,
&i,
(RsaKey*)ssl->hsKey,
ssl->buffers.key->length);
if (ret != 0) {
goto exit_sske;
}
keySz = wc_RsaEncryptSize((RsaKey*)ssl->hsKey);
if (keySz < 0) { /* test if keySz has error */
ERROR_OUT(keySz, exit_sske);
}

args->tmpSigSz = (word32)keySz;
if (keySz < ssl->options.minRsaKeySz) {
WOLFSSL_MSG("RSA signature key size too small");
ERROR_OUT(RSA_KEY_SIZE_E, exit_sske);
}
break;
}
#endif /* !NO_RSA */
#ifdef HAVE_ECC
case ecc_dsa_sa_algo:
{
word32 i = 0;

ssl->hsType = DYNAMIC_TYPE_ECC;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
if (ret != 0) {
goto exit_sske;
}
word16 keySz;

ret = wc_EccPrivateKeyDecode(
ssl->buffers.key->buffer,
&i,
(ecc_key*)ssl->hsKey,
ssl->buffers.key->length);
ssl->buffers.keyType = ecc_dsa_sa_algo;
ret = DecodePrivateKey(ssl, &keySz);
if (ret != 0) {
goto exit_sske;
}
/* worst case estimate */
args->tmpSigSz = wc_ecc_sig_size(
(ecc_key*)ssl->hsKey);

/* check the minimum ECC key size */
if (wc_ecc_size((ecc_key*)ssl->hsKey) <
ssl->options.minEccKeySz) {
WOLFSSL_MSG("ECC key size too small");
ERROR_OUT(ECC_KEY_SIZE_E, exit_sske);
}
args->tmpSigSz = keySz;
break;
}
#endif
#ifdef HAVE_ED25519
case ed25519_sa_algo:
{
word32 i = 0;
word16 keySz;

ssl->hsType = DYNAMIC_TYPE_ED25519;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
if (ret != 0) {
goto exit_sske;
}

ret = wc_Ed25519PrivateKeyDecode(
ssl->buffers.key->buffer,
&i,
(ed25519_key*)ssl->hsKey,
ssl->buffers.key->length);
ssl->buffers.keyType = ed25519_sa_algo;
ret = DecodePrivateKey(ssl, &keySz);
if (ret != 0) {
goto exit_sske;
}

/* worst case estimate */
args->tmpSigSz = ED25519_SIG_SIZE;

/* check the minimum ECC key size */
if (ED25519_KEY_SIZE <
ssl->options.minEccKeySz) {
WOLFSSL_MSG("Ed25519 key size too small");
ERROR_OUT(ECC_KEY_SIZE_E, exit_sske);
}
break;
}
#endif /* HAVE_ED25519 */
Expand Down Expand Up @@ -22307,7 +22301,7 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
preSigSz = args->length;

if (!ssl->options.usingAnon_cipher) {
int keySz;
word16 keySz;

/* sig length */
args->length += LENGTH_SZ;
Expand All @@ -22322,22 +22316,12 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
}
else
{
word32 i = 0;

ssl->hsType = DYNAMIC_TYPE_RSA;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
if (ssl->buffers.keyType == 0)
ssl->buffers.keyType = rsa_sa_algo;
ret = DecodePrivateKey(ssl, &keySz);
if (ret != 0) {
goto exit_sske;
}

ret = wc_RsaPrivateKeyDecode(
ssl->buffers.key->buffer, &i,
(RsaKey*)ssl->hsKey,
ssl->buffers.key->length);
if (ret != 0) {
goto exit_sske;
}
keySz = wc_RsaEncryptSize((RsaKey*)ssl->hsKey);
}

if (keySz <= 0) { /* test if keySz has error */
Expand All @@ -22347,11 +22331,6 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
args->tmpSigSz = (word32)keySz;
args->length += args->tmpSigSz;

if (keySz < ssl->options.minRsaKeySz) {
WOLFSSL_MSG("RSA key size too small");
ERROR_OUT(RSA_KEY_SIZE_E, exit_sske);
}

if (IsAtLeastTLSv1_2(ssl)) {
args->length += HASH_SIG_SIZE;
}
Expand Down Expand Up @@ -25014,30 +24993,14 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
#ifndef NO_RSA
case rsa_kea:
{
word32 i = 0;
int keySz;
word16 keySz;

ssl->hsType = DYNAMIC_TYPE_RSA;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
ssl->buffers.keyType = rsa_sa_algo;
ret = DecodePrivateKey(ssl, &keySz);
if (ret != 0) {
goto exit_dcke;
}

ret = wc_RsaPrivateKeyDecode(ssl->buffers.key->buffer,
&i, (RsaKey*)ssl->hsKey, ssl->buffers.key->length);
if (ret != 0) {
goto exit_dcke;
}
keySz = wc_RsaEncryptSize((RsaKey*)ssl->hsKey);
if (keySz < 0) { /* test if keySz has error */
ERROR_OUT(keySz, exit_dcke);
}
args->length = (word32)keySz;

if (keySz < ssl->options.minRsaKeySz) {
WOLFSSL_MSG("Peer RSA key is too small");
ERROR_OUT(RSA_KEY_SIZE_E, exit_dcke);
}
ssl->arrays->preMasterSz = SECRET_LEN;

if (ssl->options.tls) {
Expand Down Expand Up @@ -25172,27 +25135,14 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
/* handle static private key */
if (ssl->specs.static_ecdh &&
ssl->ecdhCurveOID != ECC_X25519_OID) {
word32 i = 0;
word16 keySz;

ssl->hsType = DYNAMIC_TYPE_ECC;
ret = AllocKey(ssl, ssl->hsType, &ssl->hsKey);
ssl->buffers.keyType = ecc_dsa_sa_algo;
ret = DecodePrivateKey(ssl, &keySz);
if (ret != 0) {
goto exit_dcke;
}

ret = wc_EccPrivateKeyDecode(
ssl->buffers.key->buffer,
&i,
(ecc_key*)ssl->hsKey,
ssl->buffers.key->length);
if (ret == 0) {
private_key = (ecc_key*)ssl->hsKey;
if (wc_ecc_size(private_key) <
ssl->options.minEccKeySz) {
WOLFSSL_MSG("ECC key too small");
ERROR_OUT(ECC_KEY_SIZE_E, exit_dcke);
}
}
private_key = (ecc_key*)ssl->hsKey;
}
#endif

Expand Down
52 changes: 49 additions & 3 deletions src/ssl.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11156,6 +11156,28 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
return ProcessBuffer(ctx, in, sz, format, PRIVATEKEY_TYPE, NULL,NULL,0);
}

#ifdef HAVE_PKCS11
int wolfSSL_CTX_use_PrivateKey_id(WOLFSSL_CTX* ctx, const unsigned char* id,
long sz, int devId, long keySz)
{
int ret = WOLFSSL_FAILURE;

FreeDer(&ctx->privateKey);
if (AllocDer(&ctx->privateKey, sz, PRIVATEKEY_TYPE, ctx->heap) == 0) {
XMEMCPY(ctx->privateKey->buffer, id, sz);
ctx->privateKeyId = 1;
ctx->privateKeySz = keySz;
if (devId != INVALID_DEVID)
ctx->privateKeyDevId = devId;
else
ctx->privateKeyDevId = ctx->devId;

ret = WOLFSSL_SUCCESS;
}

return ret;
}
#endif

int wolfSSL_CTX_use_certificate_chain_buffer_format(WOLFSSL_CTX* ctx,
const unsigned char* in, long sz, int format)
Expand Down Expand Up @@ -11291,6 +11313,30 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
ssl, NULL, 0);
}

#ifdef HAVE_PKCS11
int wolfSSL_use_PrivateKey_id(WOLFSSL* ssl, const unsigned char* id,
long sz, int devId, long keySz)
{
int ret = WOLFSSL_FAILURE;

FreeDer(&ssl->buffers.key);
if (AllocDer(&ssl->buffers.key, sz, PRIVATEKEY_TYPE, ssl->heap) == 0) {
XMEMCPY(ssl->buffers.key->buffer, id, sz);
ssl->buffers.weOwnKey = 1;
ssl->buffers.keyId = 1;
ssl->buffers.keySz = keySz;
if (devId != INVALID_DEVID)
ssl->buffers.keyId = devId;
else
ssl->buffers.keyId = ssl->devId;

ret = WOLFSSL_SUCCESS;
}

return ret;
}
#endif

int wolfSSL_use_certificate_chain_buffer_format(WOLFSSL* ssl,
const unsigned char* in, long sz, int format)
{
Expand Down Expand Up @@ -12348,7 +12394,7 @@ int wolfSSL_set_compression(WOLFSSL* ssl)
ret = wolfSSL_EVP_get_hashinfo(md, &hashType, NULL);
if (ret == WOLFSSL_FAILURE)
goto end;

ret = wc_PBKDF1_ex(key, info->keySz, iv, info->ivSz, data, sz, salt,
EVP_SALT_SIZE, count, hashType, NULL);
if (ret == 0)
Expand Down Expand Up @@ -13055,7 +13101,7 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD *md)
int wolfSSL_EVP_MD_CTX_block_size(const WOLFSSL_EVP_MD_CTX *ctx) {
return(wolfSSL_EVP_MD_block_size(wolfSSL_EVP_MD_CTX_md(ctx)));
}

/* Deep copy of EVP_MD hasher
* return WOLFSSL_SUCCESS on success */
static int wolfSSL_EVP_MD_Copy_Hasher(WOLFSSL_EVP_MD_CTX* des,
Expand Down Expand Up @@ -13447,7 +13493,7 @@ int wolfSSL_EVP_MD_type(const WOLFSSL_EVP_MD *md)
ctx->enc = enc ? 1 : 0;
if (key) {
ret = AesSetKey_ex(&ctx->cipher.aes, key, ctx->keyLen, iv,
ctx->enc ? AES_ENCRYPTION : AES_DECRYPTION);
ctx->enc ? AES_ENCRYPTION : AES_DECRYPTION);
if (ret != 0)
return ret;
}
Expand Down
8 changes: 8 additions & 0 deletions wolfcrypt/src/ecc.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4351,6 +4351,10 @@ int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
key->state = ECC_STATE_SIGN_DO;

if ((err = mp_init_multi(r, s, NULL, NULL, NULL, NULL)) != MP_OKAY){
#if !defined(WOLFSSL_ASYNC_CRYPT) && defined(WOLFSSL_SMALL_STACK)
XFREE(s, key->heap, DYNAMIC_TYPE_ECC);
XFREE(r, key->heap, DYNAMIC_TYPE_ECC);
#endif
break;
}

Expand All @@ -4361,6 +4365,10 @@ int wc_ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
err = wc_ecc_sign_hash_ex(in, inlen, rng, key, r, s);
#endif
if (err < 0) {
#if !defined(WOLFSSL_ASYNC_CRYPT) && defined(WOLFSSL_SMALL_STACK)
XFREE(s, key->heap, DYNAMIC_TYPE_ECC);
XFREE(r, key->heap, DYNAMIC_TYPE_ECC);
#endif
break;
}

Expand Down
Loading