/*
* tsig.c -- TSIG implementation (RFC 2845).
*
* Copyright (c) 2001-2006, NLnet Labs. All rights reserved.
*
* See LICENSE for the license.
*
*/
#include "config.h"
#include <stdlib.h>
#include <ctype.h>
#include "tsig.h"
#include "tsig-openssl.h"
#include "dns.h"
#include "packet.h"
#include "query.h"
#include "rbtree.h"
#if !defined(HAVE_SSL) || !defined(HAVE_CRYPTO_MEMCMP)
/* we need fixed time compare */
#define CRYPTO_memcmp memcmp_fixedtime
int memcmp_fixedtime(const void *s1, const void *s2, size_t n)
{
size_t i;
const uint8_t* u1 = (const uint8_t*)s1;
const uint8_t* u2 = (const uint8_t*)s2;
int ret = 0, haveit = 0, bret = 0, bhaveit = 0;
/* this routine loops for every byte in the strings.
* every loop, it tests ==, < and >. All three. One succeeds,
* as every time it must be equal, smaller or larger. The one
* that succeeds has one if-comparison and two assignments. */
for(i=0; i<n; i++) {
if(u1[i] == u2[i]) {
/* waste time equal to < and > statements */
if(haveit) {
bret = -1; /* waste time */
bhaveit = 1;
} else {
bret = 1; /* waste time */
bhaveit = 1;
}
}
if(u1[i] < u2[i]) {
if(haveit) {
bret = -1; /* waste time equal to the else */
bhaveit = 1;
} else {
ret = -1;
haveit = 1;
}
}
if(u1[i] > u2[i]) {
if(haveit) {
bret = 1; /* waste time equal to the else */
bhaveit = 1;
} else {
ret = 1;
haveit = 1;
}
}
}
/* use the variables to stop the compiler from excluding them */
if(bhaveit) {
if(bret == -2)
ret = 0; /* never happens */
} else {
if(bret == -2)
ret = 0; /* never happens */
}
return ret;
}
#endif
static region_type *tsig_region;
struct tsig_key_table
{
rbnode_type node; /* by dname */
tsig_key_type *key;
};
typedef struct tsig_key_table tsig_key_table_type;
static rbtree_type *tsig_key_table;
struct tsig_algorithm_table
{
struct tsig_algorithm_table *next;
tsig_algorithm_type *algorithm;
};
typedef struct tsig_algorithm_table tsig_algorithm_table_type;
static tsig_algorithm_table_type *tsig_algorithm_table;
static size_t max_algo_digest_size = 0;
static void
tsig_digest_variables(tsig_record_type *tsig, int tsig_timers_only)
{
uint16_t klass = htons(CLASS_ANY);
uint32_t ttl = htonl(0);
uint16_t signed_time_high = htons(tsig->signed_time_high);
uint32_t signed_time_low = htonl(tsig->signed_time_low);
uint16_t signed_time_fudge = htons(tsig->signed_time_fudge);
uint16_t error_code = htons(tsig->error_code);
uint16_t other_size = htons(tsig->other_size);
if (!tsig_timers_only) {
tsig->algorithm->hmac_update(tsig->context,
dname_name(tsig->key_name),
tsig->key_name->name_size);
tsig->algorithm->hmac_update(tsig->context,
&klass,
sizeof(klass));
tsig->algorithm->hmac_update(tsig->context,
&ttl,
sizeof(ttl));
tsig->algorithm->hmac_update(tsig->context,
dname_name(tsig->algorithm_name),
tsig->algorithm_name->name_size);
}
tsig->algorithm->hmac_update(tsig->context,
&signed_time_high,
sizeof(signed_time_high));
tsig->algorithm->hmac_update(tsig->context,
&signed_time_low,
sizeof(signed_time_low));
tsig->algorithm->hmac_update(tsig->context,
&signed_time_fudge,
sizeof(signed_time_fudge));
if (!tsig_timers_only) {
tsig->algorithm->hmac_update(tsig->context,
&error_code,
sizeof(error_code));
tsig->algorithm->hmac_update(tsig->context,
&other_size,
sizeof(other_size));
tsig->algorithm->hmac_update(tsig->context,
tsig->other_data,
tsig->other_size);
}
}
static int
tree_dname_compare(const void* a, const void* b)
{
return dname_compare((const dname_type*)a, (const dname_type*)b);
}
int
tsig_init(region_type *region)
{
tsig_region = region;
tsig_key_table = rbtree_create(region, &tree_dname_compare);
tsig_algorithm_table = NULL;
#if defined(HAVE_SSL)
return tsig_openssl_init(region);
#endif /* defined(HAVE_SSL) */
return 1;
}
void
tsig_add_key(tsig_key_type *key)
{
tsig_key_table_type *entry = (tsig_key_table_type *) region_alloc_zero(
tsig_region, sizeof(tsig_key_table_type));
entry->key = key;
entry->node.key = entry->key->name;
(void)rbtree_insert(tsig_key_table, &entry->node);
}
void
tsig_del_key(tsig_key_type *key)
{
tsig_key_table_type *entry;
if(!key) return;
entry = (tsig_key_table_type*)rbtree_delete(tsig_key_table, key->name);
if(!entry) return;
region_recycle(tsig_region, entry, sizeof(tsig_key_table_type));
}
tsig_key_type*
tsig_find_key(const dname_type* name)
{
tsig_key_table_type* entry;
entry = (tsig_key_table_type*)rbtree_search(tsig_key_table, name);
if(entry)
return entry->key;
return NULL;
}
void
tsig_add_algorithm(tsig_algorithm_type *algorithm)
{
tsig_algorithm_table_type *entry
= (tsig_algorithm_table_type *) region_alloc(
tsig_region, sizeof(tsig_algorithm_table_type));
entry->algorithm = algorithm;
entry->next = tsig_algorithm_table;
tsig_algorithm_table = entry;
if(algorithm->maximum_digest_size > max_algo_digest_size)
max_algo_digest_size = algorithm->maximum_digest_size;
}
/**
* compare a tsig algorithm string lowercased
*/
int
tsig_strlowercmp(const char* str1, const char* str2)
{
while (str1 && str2 && *str1 != '\0' && *str2 != '\0') {
if(tolower((unsigned char)*str1) != tolower((unsigned char)*str2)) {
if(tolower((unsigned char)*str1) < tolower((unsigned char)*str2))
return -1;
return 1;
}
str1++;
str2++;
}
if (str1 && str2) {
if (*str1 == *str2)
return 0;
else if (*str1 == '\0')
return -1;
}
else if (!str1 && !str2)
return 0;
else if (!str1 && str2)
return -1;
return 1;
}
/*
* Find an HMAC algorithm based on its short name.
*/
tsig_algorithm_type *
tsig_get_algorithm_by_name(const char *name)
{
tsig_algorithm_table_type *algorithm_entry;
for (algorithm_entry = tsig_algorithm_table;
algorithm_entry;
algorithm_entry = algorithm_entry->next)
{
if (tsig_strlowercmp(name, algorithm_entry->algorithm->short_name) == 0)
{
return algorithm_entry->algorithm;
}
if(strncmp("hmac-", algorithm_entry->algorithm->short_name, 5) == 0 && tsig_strlowercmp(name, algorithm_entry->algorithm->short_name+5) == 0) {
return algorithm_entry->algorithm;
}
}
return NULL;
}
const char *
tsig_error(int error_code)
{
static char message[1000];
switch (error_code) {
case TSIG_ERROR_NOERROR:
return "No Error";
break;
case TSIG_ERROR_BADSIG:
return "Bad Signature";
break;
case TSIG_ERROR_BADKEY:
return "Bad Key";
break;
case TSIG_ERROR_BADTIME:
return "Bad Time";
break;
default:
if(error_code < 16) /* DNS rcodes */
return rcode2str(error_code);
snprintf(message, sizeof(message),
"Unknown Error %d", error_code);
break;
}
return message;
}
static void
tsig_cleanup(void *data)
{
tsig_record_type *tsig = (tsig_record_type *) data;
region_destroy(tsig->rr_region);
region_destroy(tsig->context_region);
}
void
tsig_create_record(tsig_record_type *tsig, region_type *region)
{
tsig_create_record_custom(tsig, region, DEFAULT_CHUNK_SIZE,
DEFAULT_LARGE_OBJECT_SIZE, DEFAULT_INITIAL_CLEANUP_SIZE);
}
void
tsig_create_record_custom(tsig_record_type *tsig, region_type *region,
size_t chunk_size, size_t large_object_size, size_t initial_cleanup_size)
{
tsig->rr_region = region_create_custom(xalloc, free, chunk_size,
large_object_size, initial_cleanup_size, 0);
tsig->context_region = region_create_custom(xalloc, free, chunk_size,
large_object_size, initial_cleanup_size, 0);
if(region)
region_add_cleanup(region, tsig_cleanup, tsig);
tsig_init_record(tsig, NULL, NULL);
}
void
tsig_delete_record(tsig_record_type* tsig, region_type* region)
{
if(region)
region_remove_cleanup(region, tsig_cleanup, tsig);
region_destroy(tsig->rr_region);
region_destroy(tsig->context_region);
}
void
tsig_init_record(tsig_record_type *tsig,
tsig_algorithm_type *algorithm,
tsig_key_type *key)
{
tsig->status = TSIG_NOT_PRESENT;
tsig->error_code = TSIG_ERROR_NOERROR;
tsig->position = 0;
tsig->response_count = 0;
tsig->context = NULL;
tsig->algorithm = algorithm;
tsig->key = key;
tsig->prior_mac_size = 0;
tsig->prior_mac_data = NULL;
region_free_all(tsig->context_region);
}
int
tsig_from_query(tsig_record_type *tsig)
{
tsig_key_type *key = NULL;
tsig_algorithm_table_type *algorithm_entry;
tsig_algorithm_type *algorithm = NULL;
uint64_t current_time;
uint64_t signed_time;
assert(tsig->status == TSIG_OK);
assert(!tsig->algorithm);
assert(!tsig->key);
key = (tsig_key_type*)tsig_find_key(tsig->key_name);
for (algorithm_entry = tsig_algorithm_table;
algorithm_entry;
algorithm_entry = algorithm_entry->next)
{
if (dname_compare(
tsig->algorithm_name,
algorithm_entry->algorithm->wireformat_name) == 0)
{
algorithm = algorithm_entry->algorithm;
break;
}
}
if (!algorithm || !key) {
/* Algorithm or key is unknown, cannot authenticate. */
tsig->error_code = TSIG_ERROR_BADKEY;
return 0;
}
if ((tsig->algorithm && algorithm != tsig->algorithm)
|| (tsig->key && key != tsig->key))
{
/*
* Algorithm or key changed during a single connection,
* return error.
*/
tsig->error_code = TSIG_ERROR_BADKEY;
return 0;
}
signed_time = ((((uint64_t) tsig->signed_time_high) << 32) |
((uint64_t) tsig->signed_time_low));
current_time = (uint64_t) time(NULL);
if ((current_time < signed_time - tsig->signed_time_fudge)
|| (current_time > signed_time + tsig->signed_time_fudge))
{
uint16_t current_time_high;
uint32_t current_time_low;
#if 0 /* debug */
char current_time_text[26];
char signed_time_text[26];
time_t clock;
clock = (time_t) current_time;
ctime_r(&clock, current_time_text);
current_time_text[24] = '\0';
clock = (time_t) signed_time;
ctime_r(&clock, signed_time_text);
signed_time_text[24] = '\0';
log_msg(LOG_ERR,
"current server time %s is outside the range of TSIG"
" signed time %s with fudge %u",
current_time_text,
signed_time_text,
(unsigned) tsig->signed_time_fudge);
#endif
tsig->error_code = TSIG_ERROR_BADTIME;
current_time_high = (uint16_t) (current_time >> 32);
current_time_low = (uint32_t) current_time;
tsig->other_size = 6;
tsig->other_data = (uint8_t *) region_alloc(
tsig->rr_region, sizeof(uint16_t) + sizeof(uint32_t));
write_uint16(tsig->other_data, current_time_high);
write_uint32(tsig->other_data + 2, current_time_low);
return 0;
}
tsig->algorithm = algorithm;
tsig->key = key;
tsig->response_count = 0;
tsig->prior_mac_size = 0;
return 1;
}
void
tsig_init_query(tsig_record_type *tsig, uint16_t original_query_id)
{
assert(tsig);
assert(tsig->algorithm);
assert(tsig->key);
tsig->response_count = 0;
tsig->prior_mac_size = 0;
tsig->algorithm_name = tsig->algorithm->wireformat_name;
tsig->key_name = tsig->key->name;
tsig->mac_size = 0;
tsig->mac_data = NULL;
tsig->original_query_id = original_query_id;
tsig->error_code = TSIG_ERROR_NOERROR;
tsig->other_size = 0;
tsig->other_data = NULL;
}
void
tsig_prepare(tsig_record_type *tsig)
{
if (!tsig->context) {
assert(tsig->algorithm);
tsig->context = tsig->algorithm->hmac_create_context(
tsig->context_region);
tsig->prior_mac_data = (uint8_t *) region_alloc(
tsig->context_region,
tsig->algorithm->maximum_digest_size);
}
tsig->algorithm->hmac_init_context(tsig->context,
tsig->algorithm,
tsig->key);
if (tsig->prior_mac_size > 0) {
uint16_t mac_size = htons(tsig->prior_mac_size);
tsig->algorithm->hmac_update(tsig->context,
&mac_size,
sizeof(mac_size));
tsig->algorithm->hmac_update(tsig->context,
tsig->prior_mac_data,
tsig->prior_mac_size);
}
tsig->updates_since_last_prepare = 0;
}
void
tsig_update(tsig_record_type *tsig, buffer_type *packet, size_t length)
{
uint16_t original_query_id = htons(tsig->original_query_id);
assert(length <= buffer_limit(packet));
tsig->algorithm->hmac_update(tsig->context,
&original_query_id,
sizeof(original_query_id));
tsig->algorithm->hmac_update(
tsig->context,
buffer_at(packet, sizeof(original_query_id)),
length - sizeof(original_query_id));
if (QR(packet)) {
++tsig->response_count;
}
++tsig->updates_since_last_prepare;
}
void
tsig_sign(tsig_record_type *tsig)
{
uint64_t current_time = (uint64_t) time(NULL);
tsig->signed_time_high = (uint16_t) (current_time >> 32);
tsig->signed_time_low = (uint32_t) current_time;
tsig->signed_time_fudge = 300; /* XXX; hardcoded value */
tsig_digest_variables(tsig, tsig->response_count > 1);
tsig->algorithm->hmac_final(tsig->context,
tsig->prior_mac_data,
&tsig->prior_mac_size);
tsig->mac_size = tsig->prior_mac_size;
tsig->mac_data = tsig->prior_mac_data;
}
int
tsig_verify(tsig_record_type *tsig)
{
tsig_digest_variables(tsig, tsig->response_count > 1);
tsig->algorithm->hmac_final(tsig->context,
tsig->prior_mac_data,
&tsig->prior_mac_size);
if (tsig->mac_size != tsig->prior_mac_size
|| CRYPTO_memcmp(tsig->mac_data,
tsig->prior_mac_data,
tsig->mac_size) != 0)
{
/* Digest is incorrect, cannot authenticate. */
tsig->error_code = TSIG_ERROR_BADSIG;
return 0;
} else {
return 1;
}
}
int
tsig_find_rr(tsig_record_type *tsig, buffer_type *packet)
{
size_t saved_position = buffer_position(packet);
size_t rrcount = ((size_t)QDCOUNT(packet)
+ (size_t)ANCOUNT(packet)
+ (size_t)NSCOUNT(packet)
+ (size_t)ARCOUNT(packet));
size_t i;
int result;
if (ARCOUNT(packet) == 0) {
tsig->status = TSIG_NOT_PRESENT;
return 1;
}
if(rrcount > 65530) {
/* impossibly high number of records in 64k, reject packet */
buffer_set_position(packet, saved_position);
return 0;
}
buffer_set_position(packet, QHEADERSZ);
/* TSIG must be the last record, so skip all others. */
for (i = 0; i < rrcount - 1; ++i) {
if (!packet_skip_rr(packet, i < QDCOUNT(packet))) {
buffer_set_position(packet, saved_position);
return 0;
}
}
result = tsig_parse_rr(tsig, packet);
buffer_set_position(packet, saved_position);
return result;
}
int
tsig_parse_rr(tsig_record_type *tsig, buffer_type *packet)
{
uint16_t type;
uint16_t klass;
uint32_t ttl;
uint16_t rdlen;
tsig->status = TSIG_NOT_PRESENT;
tsig->position = buffer_position(packet);
tsig->key_name = NULL;
tsig->algorithm_name = NULL;
tsig->mac_data = NULL;
tsig->other_data = NULL;
region_free_all(tsig->rr_region);
tsig->key_name = dname_make_from_packet(tsig->rr_region, packet, 1, 1);
if (!tsig->key_name) {
buffer_set_position(packet, tsig->position);
return 0;
}
if (!buffer_available(packet, 10)) {
buffer_set_position(packet, tsig->position);
return 0;
}
type = buffer_read_u16(packet);
klass = buffer_read_u16(packet);
/* TSIG not present */
if (type != TYPE_TSIG || klass != CLASS_ANY) {
buffer_set_position(packet, tsig->position);
return 1;
}
ttl = buffer_read_u32(packet);
rdlen = buffer_read_u16(packet);
tsig->status = TSIG_ERROR;
tsig->error_code = RCODE_FORMAT;
if (ttl != 0 || !buffer_available(packet, rdlen)) {
buffer_set_position(packet, tsig->position);
return 0;
}
tsig->algorithm_name = dname_make_from_packet(
tsig->rr_region, packet, 1, 1);
if (!tsig->algorithm_name || !buffer_available(packet, 10)) {
buffer_set_position(packet, tsig->position);
return 0;
}
tsig->signed_time_high = buffer_read_u16(packet);
tsig->signed_time_low = buffer_read_u32(packet);
tsig->signed_time_fudge = buffer_read_u16(packet);
tsig->mac_size = buffer_read_u16(packet);
if (!buffer_available(packet, tsig->mac_size)) {
buffer_set_position(packet, tsig->position);
tsig->mac_size = 0;
return 0;
}
if(tsig->mac_size > 16384) {
/* the hash should not be too big, really 512/8=64 bytes */
buffer_set_position(packet, tsig->position);
tsig->mac_size = 0;
return 0;
}
tsig->mac_data = (uint8_t *) region_alloc_init(
tsig->rr_region, buffer_current(packet), tsig->mac_size);
buffer_skip(packet, tsig->mac_size);
if (!buffer_available(packet, 6)) {
buffer_set_position(packet, tsig->position);
return 0;
}
tsig->original_query_id = buffer_read_u16(packet);
tsig->error_code = buffer_read_u16(packet);
tsig->other_size = buffer_read_u16(packet);
if (!buffer_available(packet, tsig->other_size) || tsig->other_size > 16) {
tsig->other_size = 0;
buffer_set_position(packet, tsig->position);
return 0;
}
tsig->other_data = (uint8_t *) region_alloc_init(
tsig->rr_region, buffer_current(packet), tsig->other_size);
buffer_skip(packet, tsig->other_size);
tsig->status = TSIG_OK;
return 1;
}
void
tsig_append_rr(tsig_record_type *tsig, buffer_type *packet)
{
size_t rdlength_pos;
/* XXX: TODO key name compression? */
if(tsig->key_name)
buffer_write(packet, dname_name(tsig->key_name),
tsig->key_name->name_size);
else buffer_write_u8(packet, 0);
buffer_write_u16(packet, TYPE_TSIG);
buffer_write_u16(packet, CLASS_ANY);
buffer_write_u32(packet, 0); /* TTL */
rdlength_pos = buffer_position(packet);
buffer_skip(packet, sizeof(uint16_t));
if(tsig->algorithm_name)
buffer_write(packet, dname_name(tsig->algorithm_name),
tsig->algorithm_name->name_size);
else buffer_write_u8(packet, 0);
buffer_write_u16(packet, tsig->signed_time_high);
buffer_write_u32(packet, tsig->signed_time_low);
buffer_write_u16(packet, tsig->signed_time_fudge);
buffer_write_u16(packet, tsig->mac_size);
buffer_write(packet, tsig->mac_data, tsig->mac_size);
buffer_write_u16(packet, tsig->original_query_id);
buffer_write_u16(packet, tsig->error_code);
buffer_write_u16(packet, tsig->other_size);
buffer_write(packet, tsig->other_data, tsig->other_size);
buffer_write_u16_at(packet, rdlength_pos,
buffer_position(packet) - rdlength_pos
- sizeof(uint16_t));
}
size_t
tsig_reserved_space(tsig_record_type *tsig)
{
if (tsig->status == TSIG_NOT_PRESENT)
return 0;
return (
(tsig->key_name?tsig->key_name->name_size:1) /* Owner */
+ sizeof(uint16_t) /* Type */
+ sizeof(uint16_t) /* Class */
+ sizeof(uint32_t) /* TTL */
+ sizeof(uint16_t) /* RDATA length */
+ (tsig->algorithm_name?tsig->algorithm_name->name_size:1)
+ sizeof(uint16_t) /* Signed time (high) */
+ sizeof(uint32_t) /* Signed time (low) */
+ sizeof(uint16_t) /* Signed time fudge */
+ sizeof(uint16_t) /* MAC size */
+ max_algo_digest_size /* MAC data */
+ sizeof(uint16_t) /* Original query ID */
+ sizeof(uint16_t) /* Error code */
+ sizeof(uint16_t) /* Other size */
+ tsig->other_size); /* Other data */
}
void
tsig_error_reply(tsig_record_type *tsig)
{
if(tsig->mac_data)
memset(tsig->mac_data, 0, tsig->mac_size);
tsig->mac_size = 0;
}
void
tsig_finalize()
{
#if defined(HAVE_SSL)
tsig_openssl_finalize();
#endif /* defined(HAVE_SSL) */
}