/*
* 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) */
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.