pkcs11gost_link.c revision 12bf5d4796505b4c20680531da96a31e6c2c1144
d6fa26d0adaec6c910115be34fe7a5a5f402c14fMark Andrews/*
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * Copyright (C) 2014 Internet Systems Consortium, Inc. ("ISC")
71cef386fae61275b03e203825680b39fedaa8c6Tinderbox User *
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * Permission to use, copy, modify, and/or distribute this software for any
5347c0fcb04eaea19d9f39795646239f487c6207Tinderbox User * purpose with or without fee is hereby granted, provided that the above
5347c0fcb04eaea19d9f39795646239f487c6207Tinderbox User * copyright notice and this permission notice appear in all copies.
5347c0fcb04eaea19d9f39795646239f487c6207Tinderbox User *
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
d6fa26d0adaec6c910115be34fe7a5a5f402c14fMark Andrews * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
fd2597f75693a2279fdf588bd40dfe2407c42028Tinderbox User * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt * PERFORMANCE OF THIS SOFTWARE.
cd32f419a8a5432fbb139f56ee73cbf68b9350ccTinderbox User */
1e9517ea2156b990be21f44676d3370318eacf17Tinderbox User
14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt/* $Id$ */
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <config.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#if defined(PKCS11CRYPTO) && defined(HAVE_PKCS11_GOST)
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <isc/entropy.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <isc/mem.h>
1e9517ea2156b990be21f44676d3370318eacf17Tinderbox User#include <isc/sha2.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <isc/string.h>
14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt#include <isc/util.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <dns/keyvalues.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <dns/log.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <dst/result.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
fd2597f75693a2279fdf588bd40dfe2407c42028Tinderbox User#include "dst_internal.h"
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include "dst_parse.h"
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#include "dst_pkcs11.h"
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#include "dst_gost.h"
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#include <iscpk11/pk11.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#include <iscpk11/internal.h>
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#define WANT_GOST_PARAMS
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#include <iscpk11/constants.h>
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#include <pkcs11/pkcs11.h>
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User/*
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * RU CryptoPro GOST keys:
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * mechanisms:
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * CKM_GOSTR3411
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * CKM_GOSTR3410_WITH_GOSTR3411
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * CKM_GOSTR3410_KEY_PAIR_GEN
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * domain parameters:
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * CKA_GOSTR3410_PARAMS (fixed BER OID 1.2.643.2.2.35.1)
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * CKA_GOSTR3411_PARAMS (fixed BER OID 1.2.643.2.2.30.1)
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * CKA_GOST28147_PARAMS (optional, don't use)
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * public keys:
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * object class CKO_PUBLIC_KEY
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * key type CKK_GOSTR3410
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * attribute CKA_VALUE (point Q)
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * attribute CKA_GOSTR3410_PARAMS
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * attribute CKA_GOSTR3411_PARAMS
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * attribute CKA_GOST28147_PARAMS
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * private keys:
7e71f05d8643aca84914437c900cb716444507e4Tinderbox User * object class CKO_PRIVATE_KEY
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * key type CKK_GOSTR3410
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * attribute CKA_VALUE (big int d)
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * attribute CKA_GOSTR3410_PARAMS
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * attribute CKA_GOSTR3411_PARAMS
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User * attribute CKA_GOST28147_PARAMS
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User * point format: <x> <y> (little endian)
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User */
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User#define CKA_VALUE2 CKA_PRIVATE_EXPONENT
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#define ISC_GOST_SIGNATURELENGTH 64
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User#define ISC_GOST_PUBKEYLENGTH 64
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User/* HASH methods */
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox Userisc_result_t
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox Userisc_gost_init(isc_gost_t *ctx) {
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User CK_RV rv;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User CK_MECHANISM mech = { CKM_GOSTR3411, NULL, 0 };
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User int ret = ISC_R_SUCCESS;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User ret = pk11_get_session(ctx, OP_GOST, ISC_FALSE, ISC_FALSE, NULL, 0);
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User if (ret != ISC_R_SUCCESS)
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User return (ret);
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User PK11_CALL(pkcs_C_DigestInit, (ctx->session, &mech), ISC_R_FAILURE);
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User return (ret);
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User}
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox Uservoid
7e71f05d8643aca84914437c900cb716444507e4Tinderbox Userisc_gost_invalidate(isc_gost_t *ctx) {
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User CK_BYTE garbage[ISC_GOST_DIGESTLENGTH];
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User CK_ULONG len = ISC_GOST_DIGESTLENGTH;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User if (ctx->handle == NULL)
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User return;
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User (void) pkcs_C_DigestFinal(ctx->session, garbage, &len);
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User memset(garbage, 0, sizeof(garbage));
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User pk11_return_session(ctx);
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User}
7911e6f9de303bca5a3d8b34f4330c8f7cecffaeTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox Userisc_result_t
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox Userisc_gost_update(isc_gost_t *ctx, const unsigned char *buf, unsigned int len) {
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User CK_RV rv;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User CK_BYTE_PTR pPart;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User int ret = ISC_R_SUCCESS;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
1e9517ea2156b990be21f44676d3370318eacf17Tinderbox User DE_CONST(buf, pPart);
cd32f419a8a5432fbb139f56ee73cbf68b9350ccTinderbox User PK11_CALL(pkcs_C_DigestUpdate,
14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt (ctx->session, pPart, (CK_ULONG) len),
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User ISC_R_FAILURE);
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User return (ret);
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User}
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
1e9517ea2156b990be21f44676d3370318eacf17Tinderbox Userisc_result_t
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox Userisc_gost_final(isc_gost_t *ctx, unsigned char *digest) {
14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt CK_RV rv;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User CK_ULONG len = ISC_GOST_DIGESTLENGTH;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User int ret = ISC_R_SUCCESS;
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User PK11_CALL(pkcs_C_DigestFinal,
c313914d0e66b20969215e519bbf2ab4ecf39512Tinderbox User (ctx->session, (CK_BYTE_PTR) digest, &len),
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User ISC_R_FAILURE);
b6b8f8a0362da8c749021c4b6376cfb96047912bTinderbox User pk11_return_session(ctx);
return (ret);
}
/* DST methods */
static CK_BBOOL truevalue = TRUE;
static CK_BBOOL falsevalue = FALSE;
#define DST_RET(a) {ret = a; goto err;}
static isc_result_t pkcs11gost_todns(const dst_key_t *key, isc_buffer_t *data);
static void pkcs11gost_destroy(dst_key_t *key);
static isc_result_t
pkcs11gost_createctx_sign(dst_key_t *key, dst_context_t *dctx) {
CK_RV rv;
CK_MECHANISM mech = { CKM_GOSTR3410_WITH_GOSTR3411, NULL, 0 };
CK_OBJECT_CLASS keyClass = CKO_PRIVATE_KEY;
CK_KEY_TYPE keyType = CKK_GOSTR3410;
CK_ATTRIBUTE keyTemplate[] =
{
{ CKA_CLASS, &keyClass, (CK_ULONG) sizeof(keyClass) },
{ CKA_KEY_TYPE, &keyType, (CK_ULONG) sizeof(keyType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_SENSITIVE, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_SIGN, &truevalue, (CK_ULONG) sizeof(truevalue) },
{ CKA_VALUE, NULL, 0 },
{ CKA_GOSTR3410_PARAMS, pk11_gost_a_paramset,
(CK_ULONG) sizeof(pk11_gost_a_paramset) },
{ CKA_GOSTR3411_PARAMS, pk11_gost_paramset,
(CK_ULONG) sizeof(pk11_gost_paramset) }
};
CK_ATTRIBUTE *attr;
iscpk11_object_t *gost;
iscpk11_context_t *pk11_ctx;
isc_result_t ret;
unsigned int i;
pk11_ctx = (iscpk11_context_t *) isc_mem_get(dctx->mctx,
sizeof(*pk11_ctx));
if (pk11_ctx == NULL)
return (ISC_R_NOMEMORY);
ret = pk11_get_session(pk11_ctx, OP_GOST, ISC_FALSE, ISC_FALSE, NULL,
pk11_get_best_token(OP_GOST));
if (ret != ISC_R_SUCCESS)
goto err;
gost = key->keydata.pkey;
if (gost->ontoken && (gost->object != CK_INVALID_HANDLE)) {
pk11_ctx->ontoken = gost->ontoken;
pk11_ctx->object = gost->object;
goto token_key;
}
for (attr = pk11_attribute_first(gost);
attr != NULL;
attr = pk11_attribute_next(gost, attr))
switch (attr->type) {
case CKA_VALUE2:
INSIST(keyTemplate[6].type == CKA_VALUE);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
if (keyTemplate[6].pValue == NULL)
DST_RET(ISC_R_NOMEMORY);
memcpy(keyTemplate[6].pValue,
attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
break;
}
pk11_ctx->object = CK_INVALID_HANDLE;
pk11_ctx->ontoken = ISC_FALSE;
PK11_RET(pkcs_C_CreateObject,
(pk11_ctx->session,
keyTemplate, (CK_ULONG) 9,
&pk11_ctx->object),
ISC_R_FAILURE);
token_key:
PK11_RET(pkcs_C_SignInit,
(pk11_ctx->session, &mech, pk11_ctx->object),
ISC_R_FAILURE);
dctx->ctxdata.pk11_ctx = pk11_ctx;
for (i = 6; i <= 6; i++)
if (keyTemplate[i].pValue != NULL) {
memset(keyTemplate[i].pValue, 0,
keyTemplate[i].ulValueLen);
isc_mem_put(dctx->mctx,
keyTemplate[i].pValue,
keyTemplate[i].ulValueLen);
}
return (ISC_R_SUCCESS);
err:
if (!pk11_ctx->ontoken && (pk11_ctx->object != CK_INVALID_HANDLE))
(void) pkcs_C_DestroyObject(pk11_ctx->session, pk11_ctx->object);
for (i = 6; i <= 6; i++)
if (keyTemplate[i].pValue != NULL) {
memset(keyTemplate[i].pValue, 0,
keyTemplate[i].ulValueLen);
isc_mem_put(dctx->mctx,
keyTemplate[i].pValue,
keyTemplate[i].ulValueLen);
}
pk11_return_session(pk11_ctx);
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
isc_mem_put(dctx->mctx, pk11_ctx, sizeof(*pk11_ctx));
return (ret);
}
static isc_result_t
pkcs11gost_createctx_verify(dst_key_t *key, dst_context_t *dctx) {
CK_RV rv;
CK_MECHANISM mech = { CKM_GOSTR3410_WITH_GOSTR3411, NULL, 0 };
CK_OBJECT_CLASS keyClass = CKO_PUBLIC_KEY;
CK_KEY_TYPE keyType = CKK_GOSTR3410;
CK_ATTRIBUTE keyTemplate[] =
{
{ CKA_CLASS, &keyClass, (CK_ULONG) sizeof(keyClass) },
{ CKA_KEY_TYPE, &keyType, (CK_ULONG) sizeof(keyType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_VERIFY, &truevalue, (CK_ULONG) sizeof(truevalue) },
{ CKA_VALUE, NULL, 0 },
{ CKA_GOSTR3410_PARAMS, pk11_gost_a_paramset,
(CK_ULONG) sizeof(pk11_gost_a_paramset) },
{ CKA_GOSTR3411_PARAMS, pk11_gost_paramset,
(CK_ULONG) sizeof(pk11_gost_paramset) }
};
CK_ATTRIBUTE *attr;
iscpk11_object_t *gost;
iscpk11_context_t *pk11_ctx;
isc_result_t ret;
unsigned int i;
pk11_ctx = (iscpk11_context_t *) isc_mem_get(dctx->mctx,
sizeof(*pk11_ctx));
if (pk11_ctx == NULL)
return (ISC_R_NOMEMORY);
ret = pk11_get_session(pk11_ctx, OP_GOST, ISC_FALSE, ISC_FALSE, NULL,
pk11_get_best_token(OP_GOST));
if (ret != ISC_R_SUCCESS)
goto err;
gost = key->keydata.pkey;
if (gost->ontoken && (gost->object != CK_INVALID_HANDLE)) {
pk11_ctx->ontoken = gost->ontoken;
pk11_ctx->object = gost->object;
goto token_key;
}
for (attr = pk11_attribute_first(gost);
attr != NULL;
attr = pk11_attribute_next(gost, attr))
switch (attr->type) {
case CKA_VALUE:
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
if (keyTemplate[5].pValue == NULL)
DST_RET(ISC_R_NOMEMORY);
memcpy(keyTemplate[5].pValue,
attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
break;
}
pk11_ctx->object = CK_INVALID_HANDLE;
pk11_ctx->ontoken = ISC_FALSE;
PK11_RET(pkcs_C_CreateObject,
(pk11_ctx->session,
keyTemplate, (CK_ULONG) 8,
&pk11_ctx->object),
ISC_R_FAILURE);
token_key:
PK11_RET(pkcs_C_VerifyInit,
(pk11_ctx->session, &mech, pk11_ctx->object),
ISC_R_FAILURE);
dctx->ctxdata.pk11_ctx = pk11_ctx;
for (i = 5; i <= 5; i++)
if (keyTemplate[i].pValue != NULL) {
memset(keyTemplate[i].pValue, 0,
keyTemplate[i].ulValueLen);
isc_mem_put(dctx->mctx,
keyTemplate[i].pValue,
keyTemplate[i].ulValueLen);
}
return (ISC_R_SUCCESS);
err:
if (!pk11_ctx->ontoken && (pk11_ctx->object != CK_INVALID_HANDLE))
(void) pkcs_C_DestroyObject(pk11_ctx->session, pk11_ctx->object);
for (i = 5; i <= 5; i++)
if (keyTemplate[i].pValue != NULL) {
memset(keyTemplate[i].pValue, 0,
keyTemplate[i].ulValueLen);
isc_mem_put(dctx->mctx,
keyTemplate[i].pValue,
keyTemplate[i].ulValueLen);
}
pk11_return_session(pk11_ctx);
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
isc_mem_put(dctx->mctx, pk11_ctx, sizeof(*pk11_ctx));
return (ret);
}
static isc_result_t
pkcs11gost_createctx(dst_key_t *key, dst_context_t *dctx) {
if (dctx->use == DO_SIGN)
return (pkcs11gost_createctx_sign(key, dctx));
else
return (pkcs11gost_createctx_verify(key, dctx));
}
static void
pkcs11gost_destroyctx(dst_context_t *dctx) {
iscpk11_context_t *pk11_ctx = dctx->ctxdata.pk11_ctx;
if (pk11_ctx != NULL) {
if (!pk11_ctx->ontoken &&
(pk11_ctx->object != CK_INVALID_HANDLE))
(void) pkcs_C_DestroyObject(pk11_ctx->session,
pk11_ctx->object);
pk11_return_session(pk11_ctx);
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
isc_mem_put(dctx->mctx, pk11_ctx, sizeof(*pk11_ctx));
dctx->ctxdata.pk11_ctx = NULL;
}
}
static isc_result_t
pkcs11gost_adddata(dst_context_t *dctx, const isc_region_t *data) {
CK_RV rv;
iscpk11_context_t *pk11_ctx = dctx->ctxdata.pk11_ctx;
isc_result_t ret = ISC_R_SUCCESS;
if (dctx->use == DO_SIGN)
PK11_CALL(pkcs_C_SignUpdate,
(pk11_ctx->session,
(CK_BYTE_PTR) data->base,
(CK_ULONG) data->length),
ISC_R_FAILURE);
else
PK11_CALL(pkcs_C_VerifyUpdate,
(pk11_ctx->session,
(CK_BYTE_PTR) data->base,
(CK_ULONG) data->length),
ISC_R_FAILURE);
return (ret);
}
static isc_result_t
pkcs11gost_sign(dst_context_t *dctx, isc_buffer_t *sig) {
CK_RV rv;
CK_ULONG siglen = ISC_GOST_SIGNATURELENGTH;
isc_region_t r;
iscpk11_context_t *pk11_ctx = dctx->ctxdata.pk11_ctx;
isc_result_t ret = ISC_R_SUCCESS;
isc_buffer_availableregion(sig, &r);
if (r.length < ISC_GOST_SIGNATURELENGTH)
return (ISC_R_NOSPACE);
PK11_RET(pkcs_C_SignFinal,
(pk11_ctx->session, (CK_BYTE_PTR) r.base, &siglen),
DST_R_SIGNFAILURE);
if (siglen != ISC_GOST_SIGNATURELENGTH)
return (DST_R_SIGNFAILURE);
isc_buffer_add(sig, ISC_GOST_SIGNATURELENGTH);
err:
return (ret);
}
static isc_result_t
pkcs11gost_verify(dst_context_t *dctx, const isc_region_t *sig) {
CK_RV rv;
iscpk11_context_t *pk11_ctx = dctx->ctxdata.pk11_ctx;
isc_result_t ret = ISC_R_SUCCESS;
PK11_CALL(pkcs_C_VerifyFinal,
(pk11_ctx->session,
(CK_BYTE_PTR) sig->base,
(CK_ULONG) sig->length),
DST_R_VERIFYFAILURE);
return (ret);
}
static isc_boolean_t
pkcs11gost_compare(const dst_key_t *key1, const dst_key_t *key2) {
iscpk11_object_t *gost1, *gost2;
CK_ATTRIBUTE *attr1, *attr2;
gost1 = key1->keydata.pkey;
gost2 = key2->keydata.pkey;
if ((gost1 == NULL) && (gost2 == NULL))
return (ISC_TRUE);
else if ((gost1 == NULL) || (gost2 == NULL))
return (ISC_FALSE);
attr1 = pk11_attribute_bytype(gost1, CKA_VALUE);
attr2 = pk11_attribute_bytype(gost2, CKA_VALUE);
if ((attr1 == NULL) && (attr2 == NULL))
return (ISC_TRUE);
else if ((attr1 == NULL) || (attr2 == NULL) ||
(attr1->ulValueLen != attr2->ulValueLen) ||
memcmp(attr1->pValue, attr2->pValue, attr1->ulValueLen))
return (ISC_FALSE);
attr1 = pk11_attribute_bytype(gost1, CKA_VALUE2);
attr2 = pk11_attribute_bytype(gost2, CKA_VALUE2);
if (((attr1 != NULL) || (attr2 != NULL)) &&
((attr1 == NULL) || (attr2 == NULL) ||
(attr1->ulValueLen != attr2->ulValueLen) ||
memcmp(attr1->pValue, attr2->pValue, attr1->ulValueLen)))
return (ISC_FALSE);
if (!gost1->ontoken && !gost2->ontoken)
return (ISC_TRUE);
else if (gost1->ontoken || gost2->ontoken ||
(gost1->object != gost2->object))
return (ISC_FALSE);
return (ISC_TRUE);
}
static isc_result_t
pkcs11gost_generate(dst_key_t *key, int unused, void (*callback)(int)) {
CK_RV rv;
CK_MECHANISM mech = { CKM_GOSTR3410_KEY_PAIR_GEN, NULL, 0 };
CK_KEY_TYPE keyType = CKK_GOSTR3410;
CK_OBJECT_HANDLE pub = CK_INVALID_HANDLE;
CK_OBJECT_CLASS pubClass = CKO_PUBLIC_KEY;
CK_ATTRIBUTE pubTemplate[] =
{
{ CKA_CLASS, &pubClass, (CK_ULONG) sizeof(pubClass) },
{ CKA_KEY_TYPE, &keyType, (CK_ULONG) sizeof(keyType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_VERIFY, &truevalue, (CK_ULONG) sizeof(truevalue) },
{ CKA_GOSTR3410_PARAMS, pk11_gost_a_paramset,
(CK_ULONG) sizeof(pk11_gost_a_paramset) },
{ CKA_GOSTR3411_PARAMS, pk11_gost_paramset,
(CK_ULONG) sizeof(pk11_gost_paramset) }
};
CK_OBJECT_HANDLE priv = CK_INVALID_HANDLE;
CK_OBJECT_HANDLE privClass = CKO_PRIVATE_KEY;
CK_ATTRIBUTE privTemplate[] =
{
{ CKA_CLASS, &privClass, (CK_ULONG) sizeof(privClass) },
{ CKA_KEY_TYPE, &keyType, (CK_ULONG) sizeof(keyType) },
{ CKA_TOKEN, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_PRIVATE, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_SENSITIVE, &falsevalue, (CK_ULONG) sizeof(falsevalue) },
{ CKA_EXTRACTABLE, &truevalue, (CK_ULONG) sizeof(truevalue) },
{ CKA_SIGN, &truevalue, (CK_ULONG) sizeof(truevalue) },
};
CK_ATTRIBUTE *attr;
iscpk11_object_t *gost;
iscpk11_context_t *pk11_ctx;
isc_result_t ret;
UNUSED(unused);
UNUSED(callback);
pk11_ctx = (iscpk11_context_t *) isc_mem_get(key->mctx,
sizeof(*pk11_ctx));
if (pk11_ctx == NULL)
return (ISC_R_NOMEMORY);
ret = pk11_get_session(pk11_ctx, OP_GOST, ISC_FALSE, ISC_FALSE, NULL,
pk11_get_best_token(OP_GOST));
if (ret != ISC_R_SUCCESS)
goto err;
PK11_RET(pkcs_C_GenerateKeyPair,
(pk11_ctx->session, &mech,
pubTemplate, (CK_ULONG) 7,
privTemplate, (CK_ULONG) 7,
&pub, &priv),
DST_R_CRYPTOFAILURE);
gost = (iscpk11_object_t *) isc_mem_get(key->mctx, sizeof(*gost));
if (gost == NULL)
DST_RET(ISC_R_NOMEMORY);
memset(gost, 0, sizeof(*gost));
key->keydata.pkey = gost;
gost->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx,
sizeof(*attr) * 2);
if (gost->repr == NULL)
DST_RET(ISC_R_NOMEMORY);
memset(gost->repr, 0, sizeof(*attr) * 2);
gost->attrcnt = 2;
attr = gost->repr;
attr[0].type = CKA_VALUE;
attr[1].type = CKA_VALUE2;
attr = gost->repr;
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, pub, attr, 1),
DST_R_CRYPTOFAILURE);
attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
if (attr->pValue == NULL)
DST_RET(ISC_R_NOMEMORY);
memset(attr->pValue, 0, attr->ulValueLen);
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, pub, attr, 1),
DST_R_CRYPTOFAILURE);
attr++;
attr->type = CKA_VALUE;
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, priv, attr, 1),
DST_R_CRYPTOFAILURE);
attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
if (attr->pValue == NULL)
DST_RET(ISC_R_NOMEMORY);
memset(attr->pValue, 0, attr->ulValueLen);
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, priv, attr, 1),
DST_R_CRYPTOFAILURE);
attr->type = CKA_VALUE2;
(void) pkcs_C_DestroyObject(pk11_ctx->session, priv);
(void) pkcs_C_DestroyObject(pk11_ctx->session, pub);
pk11_return_session(pk11_ctx);
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
return (ISC_R_SUCCESS);
err:
pkcs11gost_destroy(key);
if (priv != CK_INVALID_HANDLE)
(void) pkcs_C_DestroyObject(pk11_ctx->session, priv);
if (pub != CK_INVALID_HANDLE)
(void) pkcs_C_DestroyObject(pk11_ctx->session, pub);
pk11_return_session(pk11_ctx);
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
isc_mem_put(key->mctx, pk11_ctx, sizeof(*pk11_ctx));
return (ret);
}
static isc_boolean_t
pkcs11gost_isprivate(const dst_key_t *key) {
iscpk11_object_t *gost = key->keydata.pkey;
CK_ATTRIBUTE *attr;
if (gost == NULL)
return (ISC_FALSE);
attr = pk11_attribute_bytype(gost, CKA_VALUE2);
return (ISC_TF((attr != NULL) || gost->ontoken));
}
static void
pkcs11gost_destroy(dst_key_t *key) {
iscpk11_object_t *gost = key->keydata.pkey;
CK_ATTRIBUTE *attr;
if (gost == NULL)
return;
INSIST((gost->object == CK_INVALID_HANDLE) || gost->ontoken);
for (attr = pk11_attribute_first(gost);
attr != NULL;
attr = pk11_attribute_next(gost, attr))
switch (attr->type) {
case CKA_VALUE:
case CKA_VALUE2:
if (attr->pValue != NULL) {
memset(attr->pValue, 0, attr->ulValueLen);
isc_mem_put(key->mctx,
attr->pValue,
attr->ulValueLen);
}
break;
}
if (gost->repr != NULL) {
memset(gost->repr, 0, gost->attrcnt * sizeof(*attr));
isc_mem_put(key->mctx,
gost->repr,
gost->attrcnt * sizeof(*attr));
}
memset(gost, 0, sizeof(*gost));
isc_mem_put(key->mctx, gost, sizeof(*gost));
key->keydata.pkey = NULL;
}
static isc_result_t
pkcs11gost_todns(const dst_key_t *key, isc_buffer_t *data) {
iscpk11_object_t *gost;
isc_region_t r;
CK_ATTRIBUTE *attr;
REQUIRE(key->keydata.pkey != NULL);
gost = key->keydata.pkey;
attr = pk11_attribute_bytype(gost, CKA_VALUE);
if ((attr == NULL) || (attr->ulValueLen != ISC_GOST_PUBKEYLENGTH))
return (ISC_R_FAILURE);
isc_buffer_availableregion(data, &r);
if (r.length < ISC_GOST_PUBKEYLENGTH)
return (ISC_R_NOSPACE);
memcpy(r.base, (CK_BYTE_PTR) attr->pValue, ISC_GOST_PUBKEYLENGTH);
isc_buffer_add(data, ISC_GOST_PUBKEYLENGTH);
return (ISC_R_SUCCESS);
}
static isc_result_t
pkcs11gost_fromdns(dst_key_t *key, isc_buffer_t *data) {
iscpk11_object_t *gost;
isc_region_t r;
CK_ATTRIBUTE *attr;
isc_buffer_remainingregion(data, &r);
if (r.length == 0)
return (ISC_R_SUCCESS);
if (r.length != ISC_GOST_PUBKEYLENGTH)
return (DST_R_INVALIDPUBLICKEY);
gost = (iscpk11_object_t *) isc_mem_get(key->mctx, sizeof(*gost));
if (gost == NULL)
return (ISC_R_NOMEMORY);
memset(gost, 0, sizeof(*gost));
gost->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr));
if (gost->repr == NULL)
goto nomemory;
gost->attrcnt = 1;
attr = gost->repr;
attr->type = CKA_VALUE;
attr->pValue = isc_mem_get(key->mctx, ISC_GOST_PUBKEYLENGTH);
if (attr->pValue == NULL)
goto nomemory;
memcpy((CK_BYTE_PTR) attr->pValue, r.base, ISC_GOST_PUBKEYLENGTH);
attr->ulValueLen = ISC_GOST_PUBKEYLENGTH;
isc_buffer_forward(data, ISC_GOST_PUBKEYLENGTH);
key->keydata.pkey = gost;
return (ISC_R_SUCCESS);
nomemory:
for (attr = pk11_attribute_first(gost);
attr != NULL;
attr = pk11_attribute_next(gost, attr))
switch (attr->type) {
case CKA_VALUE:
if (attr->pValue != NULL) {
memset(attr->pValue, 0, attr->ulValueLen);
isc_mem_put(key->mctx,
attr->pValue,
attr->ulValueLen);
}
break;
}
if (gost->repr != NULL) {
memset(gost->repr, 0, gost->attrcnt * sizeof(*attr));
isc_mem_put(key->mctx,
gost->repr,
gost->attrcnt * sizeof(*attr));
}
memset(gost, 0, sizeof(*gost));
isc_mem_put(key->mctx, gost, sizeof(*gost));
return (ISC_R_NOMEMORY);
}
static unsigned char gost_private_der[39] = {
0x30, 0x45, 0x02, 0x01, 0x00, 0x30, 0x1c, 0x06,
0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x13, 0x30,
0x12, 0x06, 0x07, 0x2a, 0x85, 0x03, 0x02, 0x02,
0x23, 0x01, 0x06, 0x07, 0x2a, 0x85, 0x03, 0x02,
0x02, 0x1e, 0x01, 0x04, 0x22, 0x02, 0x20
};
#ifdef PREFER_GOSTASN1
static isc_result_t
pkcs11gost_tofile(const dst_key_t *key, const char *directory) {
isc_result_t ret;
iscpk11_object_t *gost;
dst_private_t priv;
unsigned char *buf = NULL;
unsigned int i = 0;
CK_ATTRIBUTE *attr;
int adj;
if (key->keydata.pkey == NULL)
return (DST_R_NULLKEY);
if (key->external) {
priv.nelements = 0;
return (dst__privstruct_writefile(key, &priv, directory));
}
gost = key->keydata.pkey;
attr = pk11_attribute_bytype(gost, CKA_VALUE2);
if (attr != NULL) {
buf = isc_mem_get(key->mctx, attr->ulValueLen + 39);
if (buf == NULL)
return (ISC_R_NOMEMORY);
priv.elements[i].tag = TAG_GOST_PRIVASN1;
priv.elements[i].length =
(unsigned short) attr->ulValueLen + 39;
memcpy(buf, gost_private_der, 39);
memcpy(buf +39, attr->pValue, attr->ulValueLen);
adj = (int) attr->ulValueLen - 32;
if (adj != 0) {
buf[1] += adj;
buf[36] += adj;
buf[38] += adj;
}
priv.elements[i].data = buf;
i++;
} else
return (DST_R_CRYPTOFAILURE);
priv.nelements = i;
ret = dst__privstruct_writefile(key, &priv, directory);
if (buf != NULL) {
memset(buf, 0, attr->ulValueLen);
isc_mem_put(key->mctx, buf, attr->ulValueLen);
}
return (ret);
}
#else
static isc_result_t
pkcs11gost_tofile(const dst_key_t *key, const char *directory) {
isc_result_t ret;
iscpk11_object_t *gost;
dst_private_t priv;
unsigned char *buf = NULL;
unsigned int i = 0;
CK_ATTRIBUTE *attr;
if (key->keydata.pkey == NULL)
return (DST_R_NULLKEY);
if (key->external) {
priv.nelements = 0;
return (dst__privstruct_writefile(key, &priv, directory));
}
gost = key->keydata.pkey;
attr = pk11_attribute_bytype(gost, CKA_VALUE2);
if (attr != NULL) {
buf = isc_mem_get(key->mctx, attr->ulValueLen);
if (buf == NULL)
return (ISC_R_NOMEMORY);
priv.elements[i].tag = TAG_GOST_PRIVRAW;
priv.elements[i].length = (unsigned short) attr->ulValueLen;
memcpy(buf, attr->pValue, attr->ulValueLen);
priv.elements[i].data = buf;
i++;
} else
return (DST_R_CRYPTOFAILURE);
priv.nelements = i;
ret = dst__privstruct_writefile(key, &priv, directory);
if (buf != NULL) {
memset(buf, 0, attr->ulValueLen);
isc_mem_put(key->mctx, buf, attr->ulValueLen);
}
return (ret);
}
#endif
static isc_result_t
pkcs11gost_parse(dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) {
dst_private_t priv;
isc_result_t ret;
iscpk11_object_t *gost = NULL;
CK_ATTRIBUTE *attr, *pattr;
isc_mem_t *mctx = key->mctx;
REQUIRE((pub != NULL) && (pub->keydata.pkey != NULL));
/* read private key file */
ret = dst__privstruct_parse(key, DST_ALG_ECDSA256, lexer, mctx, &priv);
if (ret != ISC_R_SUCCESS)
return (ret);
if (key->external && priv.nelements != 0)
DST_RET(DST_R_INVALIDPRIVATEKEY);
if (priv.elements[0].tag == TAG_GOST_PRIVASN1) {
int adj = (int) priv.elements[0].length - (39 + 32);
unsigned char buf[39];
if ((adj > 0) || (adj < -31))
DST_RET(DST_R_INVALIDPRIVATEKEY);
memcpy(buf, gost_private_der, 39);
if (adj != 0) {
buf[1] += adj;
buf[36] += adj;
buf[38] += adj;
}
if (memcmp(priv.elements[0].data, buf, 39) != 0)
DST_RET(DST_R_INVALIDPRIVATEKEY);
priv.elements[0].tag = TAG_GOST_PRIVRAW;
priv.elements[0].length -= 39;
memmove(priv.elements[0].data,
priv.elements[0].data + 39,
32 + adj);
}
gost = (iscpk11_object_t *) isc_mem_get(key->mctx, sizeof(*gost));
if (gost == NULL)
DST_RET(ISC_R_NOMEMORY);
memset(gost, 0, sizeof(*gost));
key->keydata.pkey = gost;
gost->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx,
sizeof(*attr) * 2);
if (gost->repr == NULL)
DST_RET(ISC_R_NOMEMORY);
memset(gost->repr, 0, sizeof(*attr) * 2);
gost->attrcnt = 2;
attr = gost->repr;
attr->type = CKA_VALUE;
pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_VALUE);
INSIST(pattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
if (attr->pValue == NULL)
DST_RET(ISC_R_NOMEMORY);
memcpy(attr->pValue, pattr->pValue, pattr->ulValueLen);
attr->ulValueLen = pattr->ulValueLen;
attr++;
attr->type = CKA_VALUE2;
attr->pValue = isc_mem_get(key->mctx, priv.elements[0].length);
if (attr->pValue == NULL)
DST_RET(ISC_R_NOMEMORY);
memcpy(attr->pValue, priv.elements[0].data, priv.elements[0].length);
attr->ulValueLen = priv.elements[0].length;
dst__privstruct_free(&priv, mctx);
memset(&priv, 0, sizeof(priv));
return (ISC_R_SUCCESS);
err:
pkcs11gost_destroy(key);
dst__privstruct_free(&priv, mctx);
memset(&priv, 0, sizeof(priv));
return (ret);
}
static dst_func_t pkcs11gost_functions = {
pkcs11gost_createctx,
NULL, /*%< createctx2 */
pkcs11gost_destroyctx,
pkcs11gost_adddata,
pkcs11gost_sign,
pkcs11gost_verify,
NULL, /*%< verify2 */
NULL, /*%< computesecret */
pkcs11gost_compare,
NULL, /*%< paramcompare */
pkcs11gost_generate,
pkcs11gost_isprivate,
pkcs11gost_destroy,
pkcs11gost_todns,
pkcs11gost_fromdns,
pkcs11gost_tofile,
pkcs11gost_parse,
NULL, /*%< cleanup */
NULL, /*%< fromlabel */
NULL, /*%< dump */
NULL, /*%< restore */
};
isc_result_t
dst__pkcs11gost_init(dst_func_t **funcp) {
REQUIRE(funcp != NULL);
if (*funcp == NULL)
*funcp = &pkcs11gost_functions;
return (ISC_R_SUCCESS);
}
#else /* PKCS11CRYPTO && HAVE_PKCS11_GOST */
#include <isc/util.h>
EMPTY_TRANSLATION_UNIT
#endif /* PKCS11CRYPTO && HAVE_PKCS11_GOST */
/*! \file */