ComputerSurge/bind9
3
0
Fork 0
Code Pull Requests 1 Activity
Files
a8bc003d1b6ab0fe2ff2d693cbe2fa637d1df149
bind9/lib/dns/hmac_link.c
Ondřej Surý 4e114f8ed6 Stop leaking OpenSSL types and defines in the isc/md.h 
The <isc/md.h> header directly included <openssl/evp.h> header which
enforced all users of the libisc library to explicitly list the include
path to OpenSSL and link with -lcrypto.  By hiding the specific
implementation into the private namespace, we no longer enforce this.
In the long run, this might also allow us to switch cryptographic
library implementation without affecting the downstream users.

While making the isc_md_type_t type opaque, the API using the data type
was changed to use the pointer to isc_md_type_t instead of using the
type directly.
2020-03-17 09:11:13 +01:00

519 lines
16 KiB
C
Raw Blame History

/*
* Portions Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* 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/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*
* Portions Copyright (C) Network Associates, Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC AND NETWORK ASSOCIATES DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE
* FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <stdbool.h>
#ifndef WIN32
#include <arpa/inet.h>
#endif /* WIN32 */
#include <isc/buffer.h>
#include <isc/hmac.h>
#include <isc/md.h>
#include <isc/mem.h>
#include <isc/nonce.h>
#include <isc/random.h>
#include <isc/safe.h>
#include <isc/string.h>
#include <isc/util.h>
#include <pk11/site.h>
#include <dst/result.h>
#include "dst_internal.h"
#ifdef HAVE_FIPS_MODE
#include "dst_openssl.h" /* FIPS_mode() prototype */
#endif /* ifdef HAVE_FIPS_MODE */
#include "dst_parse.h"
#define ISC_MD_md5 ISC_MD_MD5
#define ISC_MD_sha1 ISC_MD_SHA1
#define ISC_MD_sha224 ISC_MD_SHA224
#define ISC_MD_sha256 ISC_MD_SHA256
#define ISC_MD_sha384 ISC_MD_SHA384
#define ISC_MD_sha512 ISC_MD_SHA512
#define hmac_register_algorithm(alg) \
static isc_result_t hmac##alg##_createctx(dst_key_t *key, \
dst_context_t *dctx) { \
return (hmac_createctx(ISC_MD_##alg, key, dctx)); \
} \
static void hmac##alg##_destroyctx(dst_context_t *dctx) { \
hmac_destroyctx(dctx); \
} \
static isc_result_t hmac##alg##_adddata(dst_context_t *dctx, \
const isc_region_t *data) { \
return (hmac_adddata(dctx, data)); \
} \
static isc_result_t hmac##alg##_sign(dst_context_t *dctx, \
isc_buffer_t *sig) { \
return (hmac_sign(dctx, sig)); \
} \
static isc_result_t hmac##alg##_verify(dst_context_t *dctx, \
const isc_region_t *sig) { \
return (hmac_verify(dctx, sig)); \
} \
static bool hmac##alg##_compare(const dst_key_t *key1, \
const dst_key_t *key2) { \
return (hmac_compare(ISC_MD_##alg, key1, key2)); \
} \
static isc_result_t hmac##alg##_generate( \
dst_key_t *key, int pseudorandom_ok, void (*callback)(int)) { \
UNUSED(pseudorandom_ok); \
UNUSED(callback); \
return (hmac_generate(ISC_MD_##alg, key)); \
} \
static bool hmac##alg##_isprivate(const dst_key_t *key) { \
return (hmac_isprivate(key)); \
} \
static void hmac##alg##_destroy(dst_key_t *key) { hmac_destroy(key); } \
static isc_result_t hmac##alg##_todns(const dst_key_t *key, \
isc_buffer_t *data) { \
return (hmac_todns(key, data)); \
} \
static isc_result_t hmac##alg##_fromdns(dst_key_t *key, \
isc_buffer_t *data) { \
return (hmac_fromdns(ISC_MD_##alg, key, data)); \
} \
static isc_result_t hmac##alg##_tofile(const dst_key_t *key, \
const char *directory) { \
return (hmac_tofile(ISC_MD_##alg, key, directory)); \
} \
static isc_result_t hmac##alg##_parse( \
dst_key_t *key, isc_lex_t *lexer, dst_key_t *pub) { \
return (hmac_parse(ISC_MD_##alg, key, lexer, pub)); \
} \
static dst_func_t hmac##alg##_functions = { \
hmac##alg##_createctx, \
NULL, /*%< createctx2 */ \
hmac##alg##_destroyctx, \
hmac##alg##_adddata, \
hmac##alg##_sign, \
hmac##alg##_verify, \
NULL, /*%< verify2 */ \
NULL, /*%< computesecret */ \
hmac##alg##_compare, \
NULL, /*%< paramcompare */ \
hmac##alg##_generate, \
hmac##alg##_isprivate, \
hmac##alg##_destroy, \
hmac##alg##_todns, \
hmac##alg##_fromdns, \
hmac##alg##_tofile, \
hmac##alg##_parse, \
NULL, /*%< cleanup */ \
NULL, /*%< fromlabel */ \
NULL, /*%< dump */ \
NULL, /*%< restore */ \
}; \
isc_result_t dst__hmac##alg##_init(dst_func_t **funcp) { \
REQUIRE(funcp != NULL); \
if (*funcp == NULL) { \
*funcp = &hmac##alg##_functions; \
} \
return (ISC_R_SUCCESS); \
}
static isc_result_t
hmac_fromdns(const isc_md_type_t *type, dst_key_t *key, isc_buffer_t *data);
struct dst_hmac_key {
uint8_t key[ISC_MAX_BLOCK_SIZE];
};
static inline isc_result_t
getkeybits(dst_key_t *key, struct dst_private_element *element) {
uint16_t *bits = (uint16_t *)element->data;
if (element->length != 2) {
return (DST_R_INVALIDPRIVATEKEY);
}
key->key_bits = ntohs(*bits);
return (ISC_R_SUCCESS);
}
static inline isc_result_t
hmac_createctx(const isc_md_type_t *type, const dst_key_t *key,
dst_context_t *dctx) {
isc_result_t result;
const dst_hmac_key_t *hkey = key->keydata.hmac_key;
isc_hmac_t *ctx = isc_hmac_new(); /* Either returns or abort()s */
result = isc_hmac_init(ctx, hkey->key, isc_md_type_get_block_size(type),
type);
if (result != ISC_R_SUCCESS) {
return (DST_R_UNSUPPORTEDALG);
}
dctx->ctxdata.hmac_ctx = ctx;
return (ISC_R_SUCCESS);
}
static inline void
hmac_destroyctx(dst_context_t *dctx) {
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
REQUIRE(ctx != NULL);
isc_hmac_free(ctx);
dctx->ctxdata.hmac_ctx = NULL;
}
static inline isc_result_t
hmac_adddata(const dst_context_t *dctx, const isc_region_t *data) {
isc_result_t result;
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
REQUIRE(ctx != NULL);
result = isc_hmac_update(ctx, data->base, data->length);
if (result != ISC_R_SUCCESS) {
return (DST_R_OPENSSLFAILURE);
}
return (ISC_R_SUCCESS);
}
static inline isc_result_t
hmac_sign(const dst_context_t *dctx, isc_buffer_t *sig) {
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
REQUIRE(ctx != NULL);
unsigned int digestlen;
unsigned char digest[ISC_MAX_MD_SIZE];
if (isc_hmac_final(ctx, digest, &digestlen) != ISC_R_SUCCESS) {
return (DST_R_OPENSSLFAILURE);
}
if (isc_hmac_reset(ctx) != ISC_R_SUCCESS) {
return (DST_R_OPENSSLFAILURE);
}
if (isc_buffer_availablelength(sig) < digestlen) {
return (ISC_R_NOSPACE);
}
isc_buffer_putmem(sig, digest, digestlen);
return (ISC_R_SUCCESS);
}
static inline isc_result_t
hmac_verify(const dst_context_t *dctx, const isc_region_t *sig) {
isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx;
unsigned int digestlen;
unsigned char digest[ISC_MAX_MD_SIZE];
REQUIRE(ctx != NULL);
if (isc_hmac_final(ctx, digest, &digestlen) != ISC_R_SUCCESS) {
return (DST_R_OPENSSLFAILURE);
}
if (isc_hmac_reset(ctx) != ISC_R_SUCCESS) {
return (DST_R_OPENSSLFAILURE);
}
if (sig->length > digestlen) {
return (DST_R_VERIFYFAILURE);
}
return (isc_safe_memequal(digest, sig->base, sig->length)
? ISC_R_SUCCESS
: DST_R_VERIFYFAILURE);
}
static inline bool
hmac_compare(const isc_md_type_t *type, const dst_key_t *key1,
const dst_key_t *key2) {
dst_hmac_key_t *hkey1, *hkey2;
hkey1 = key1->keydata.hmac_key;
hkey2 = key2->keydata.hmac_key;
if (hkey1 == NULL && hkey2 == NULL) {
return (true);
} else if (hkey1 == NULL || hkey2 == NULL) {
return (false);
}
return (isc_safe_memequal(hkey1->key, hkey2->key,
isc_md_type_get_block_size(type)));
}
static inline isc_result_t
hmac_generate(const isc_md_type_t *type, dst_key_t *key) {
isc_buffer_t b;
isc_result_t ret;
unsigned int bytes, len;
unsigned char data[ISC_MAX_MD_SIZE] = { 0 };
len = isc_md_type_get_block_size(type);
bytes = (key->key_size + 7) / 8;
if (bytes > len) {
bytes = len;
key->key_size = len * 8;
}
isc_nonce_buf(data, bytes);
isc_buffer_init(&b, data, bytes);
isc_buffer_add(&b, bytes);
ret = hmac_fromdns(type, key, &b);
isc_safe_memwipe(data, sizeof(data));
return (ret);
}
static inline bool
hmac_isprivate(const dst_key_t *key) {
UNUSED(key);
return (true);
}
static inline void
hmac_destroy(dst_key_t *key) {
dst_hmac_key_t *hkey = key->keydata.hmac_key;
isc_safe_memwipe(hkey, sizeof(*hkey));
isc_mem_put(key->mctx, hkey, sizeof(*hkey));
key->keydata.hmac_key = NULL;
}
static inline isc_result_t
hmac_todns(const dst_key_t *key, isc_buffer_t *data) {
REQUIRE(key != NULL && key->keydata.hmac_key != NULL);
dst_hmac_key_t *hkey = key->keydata.hmac_key;
unsigned int bytes;
bytes = (key->key_size + 7) / 8;
if (isc_buffer_availablelength(data) < bytes) {
return (ISC_R_NOSPACE);
}
isc_buffer_putmem(data, hkey->key, bytes);
return (ISC_R_SUCCESS);
}
static inline isc_result_t
hmac_fromdns(const isc_md_type_t *type, dst_key_t *key, isc_buffer_t *data) {
dst_hmac_key_t *hkey;
unsigned int keylen;
isc_region_t r;
isc_buffer_remainingregion(data, &r);
if (r.length == 0) {
return (ISC_R_SUCCESS);
}
hkey = isc_mem_get(key->mctx, sizeof(dst_hmac_key_t));
memset(hkey->key, 0, sizeof(hkey->key));
/* Hash the key if the key is longer then chosen MD block size */
if (r.length > (unsigned int)isc_md_type_get_block_size(type)) {
if (isc_md(type, r.base, r.length, hkey->key, &keylen) !=
ISC_R_SUCCESS) {
isc_mem_put(key->mctx, hkey, sizeof(dst_hmac_key_t));
return (DST_R_OPENSSLFAILURE);
}
} else {
memmove(hkey->key, r.base, r.length);
keylen = r.length;
}
key->key_size = keylen * 8;
key->keydata.hmac_key = hkey;
isc_buffer_forward(data, r.length);
return (ISC_R_SUCCESS);
}
static inline int
hmac__get_tag_key(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (TAG_HMACMD5_KEY);
} else if (type == ISC_MD_SHA1) {
return (TAG_HMACSHA1_KEY);
} else if (type == ISC_MD_SHA224) {
return (TAG_HMACSHA224_KEY);
} else if (type == ISC_MD_SHA256) {
return (TAG_HMACSHA256_KEY);
} else if (type == ISC_MD_SHA384) {
return (TAG_HMACSHA384_KEY);
} else if (type == ISC_MD_SHA512) {
return (TAG_HMACSHA512_KEY);
} else {
INSIST(0);
ISC_UNREACHABLE();
}
}
static inline int
hmac__get_tag_bits(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (TAG_HMACMD5_BITS);
} else if (type == ISC_MD_SHA1) {
return (TAG_HMACSHA1_BITS);
} else if (type == ISC_MD_SHA224) {
return (TAG_HMACSHA224_BITS);
} else if (type == ISC_MD_SHA256) {
return (TAG_HMACSHA256_BITS);
} else if (type == ISC_MD_SHA384) {
return (TAG_HMACSHA384_BITS);
} else if (type == ISC_MD_SHA512) {
return (TAG_HMACSHA512_BITS);
} else {
INSIST(0);
ISC_UNREACHABLE();
}
}
static inline isc_result_t
hmac_tofile(const isc_md_type_t *type, const dst_key_t *key,
const char *directory) {
dst_hmac_key_t *hkey;
dst_private_t priv;
int bytes = (key->key_size + 7) / 8;
uint16_t bits;
if (key->keydata.hmac_key == NULL) {
return (DST_R_NULLKEY);
}
if (key->external) {
return (DST_R_EXTERNALKEY);
}
hkey = key->keydata.hmac_key;
priv.elements[0].tag = hmac__get_tag_key(type);
priv.elements[0].length = bytes;
priv.elements[0].data = hkey->key;
bits = htons(key->key_bits);
priv.elements[1].tag = hmac__get_tag_bits(type);
priv.elements[1].length = sizeof(bits);
priv.elements[1].data = (uint8_t *)&bits;
priv.nelements = 2;
return (dst__privstruct_writefile(key, &priv, directory));
}
static inline int
hmac__to_dst_alg(const isc_md_type_t *type) {
if (type == ISC_MD_MD5) {
return (DST_ALG_HMACMD5);
} else if (type == ISC_MD_SHA1) {
return (DST_ALG_HMACSHA1);
} else if (type == ISC_MD_SHA224) {
return (DST_ALG_HMACSHA224);
} else if (type == ISC_MD_SHA256) {
return (DST_ALG_HMACSHA256);
} else if (type == ISC_MD_SHA384) {
return (DST_ALG_HMACSHA384);
} else if (type == ISC_MD_SHA512) {
return (DST_ALG_HMACSHA512);
} else {
INSIST(0);
ISC_UNREACHABLE();
}
}
static inline isc_result_t
hmac_parse(const isc_md_type_t *type, dst_key_t *key, isc_lex_t *lexer,
dst_key_t *pub) {
dst_private_t priv;
isc_result_t result, tresult;
isc_buffer_t b;
isc_mem_t *mctx = key->mctx;
unsigned int i;
UNUSED(pub);
/* read private key file */
result = dst__privstruct_parse(key, hmac__to_dst_alg(type), lexer, mctx,
&priv);
if (result != ISC_R_SUCCESS) {
return (result);
}
if (key->external) {
result = DST_R_EXTERNALKEY;
}
key->key_bits = 0;
for (i = 0; i < priv.nelements && result == ISC_R_SUCCESS; i++) {
switch (priv.elements[i].tag) {
case TAG_HMACMD5_KEY:
case TAG_HMACSHA1_KEY:
case TAG_HMACSHA224_KEY:
case TAG_HMACSHA256_KEY:
case TAG_HMACSHA384_KEY:
case TAG_HMACSHA512_KEY:
isc_buffer_init(&b, priv.elements[i].data,
priv.elements[i].length);
isc_buffer_add(&b, priv.elements[i].length);
tresult = hmac_fromdns(type, key, &b);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
break;
case TAG_HMACMD5_BITS:
case TAG_HMACSHA1_BITS:
case TAG_HMACSHA224_BITS:
case TAG_HMACSHA256_BITS:
case TAG_HMACSHA384_BITS:
case TAG_HMACSHA512_BITS:
tresult = getkeybits(key, &priv.elements[i]);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
break;
default:
result = DST_R_INVALIDPRIVATEKEY;
break;
}
}
dst__privstruct_free(&priv, mctx);
isc_safe_memwipe(&priv, sizeof(priv));
return (result);
}
hmac_register_algorithm(md5);
hmac_register_algorithm(sha1);
hmac_register_algorithm(sha224);
hmac_register_algorithm(sha256);
hmac_register_algorithm(sha384);
hmac_register_algorithm(sha512);
/*! \file */
View Git Blame Copy Permalink