/contrib/bind9/lib/dns/key.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 180 lines · 126 code · 36 blank · 18 comment · 27 complexity · 8ada7fec358762c6f9afe099c906e637 MD5 · raw file

  1. /*
  2. * Copyright (C) 2004-2007, 2011, 2012 Internet Systems Consortium, Inc. ("ISC")
  3. * Copyright (C) 2001 Internet Software Consortium.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for any
  6. * purpose with or without fee is hereby granted, provided that the above
  7. * copyright notice and this permission notice appear in all copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10. * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11. * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12. * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15. * PERFORMANCE OF THIS SOFTWARE.
  16. */
  17. /* $Id$ */
  18. #include <config.h>
  19. #include <stddef.h>
  20. #include <stdlib.h>
  21. #include <isc/region.h>
  22. #include <isc/util.h>
  23. #include <dns/keyvalues.h>
  24. #include <dst/dst.h>
  25. #include "dst_internal.h"
  26. isc_uint16_t
  27. dst_region_computeid(const isc_region_t *source, unsigned int alg) {
  28. isc_uint32_t ac;
  29. const unsigned char *p;
  30. int size;
  31. REQUIRE(source != NULL);
  32. REQUIRE(source->length >= 4);
  33. p = source->base;
  34. size = source->length;
  35. if (alg == DST_ALG_RSAMD5)
  36. return ((p[size - 3] << 8) + p[size - 2]);
  37. for (ac = 0; size > 1; size -= 2, p += 2)
  38. ac += ((*p) << 8) + *(p + 1);
  39. if (size > 0)
  40. ac += ((*p) << 8);
  41. ac += (ac >> 16) & 0xffff;
  42. return ((isc_uint16_t)(ac & 0xffff));
  43. }
  44. isc_uint16_t
  45. dst_region_computerid(const isc_region_t *source, unsigned int alg) {
  46. isc_uint32_t ac;
  47. const unsigned char *p;
  48. int size;
  49. REQUIRE(source != NULL);
  50. REQUIRE(source->length >= 4);
  51. p = source->base;
  52. size = source->length;
  53. if (alg == DST_ALG_RSAMD5)
  54. return ((p[size - 3] << 8) + p[size - 2]);
  55. ac = ((*p) << 8) + *(p + 1);
  56. ac |= DNS_KEYFLAG_REVOKE;
  57. for (size -= 2, p +=2; size > 1; size -= 2, p += 2)
  58. ac += ((*p) << 8) + *(p + 1);
  59. if (size > 0)
  60. ac += ((*p) << 8);
  61. ac += (ac >> 16) & 0xffff;
  62. return ((isc_uint16_t)(ac & 0xffff));
  63. }
  64. dns_name_t *
  65. dst_key_name(const dst_key_t *key) {
  66. REQUIRE(VALID_KEY(key));
  67. return (key->key_name);
  68. }
  69. unsigned int
  70. dst_key_size(const dst_key_t *key) {
  71. REQUIRE(VALID_KEY(key));
  72. return (key->key_size);
  73. }
  74. unsigned int
  75. dst_key_proto(const dst_key_t *key) {
  76. REQUIRE(VALID_KEY(key));
  77. return (key->key_proto);
  78. }
  79. unsigned int
  80. dst_key_alg(const dst_key_t *key) {
  81. REQUIRE(VALID_KEY(key));
  82. return (key->key_alg);
  83. }
  84. isc_uint32_t
  85. dst_key_flags(const dst_key_t *key) {
  86. REQUIRE(VALID_KEY(key));
  87. return (key->key_flags);
  88. }
  89. dns_keytag_t
  90. dst_key_id(const dst_key_t *key) {
  91. REQUIRE(VALID_KEY(key));
  92. return (key->key_id);
  93. }
  94. dns_keytag_t
  95. dst_key_rid(const dst_key_t *key) {
  96. REQUIRE(VALID_KEY(key));
  97. return (key->key_rid);
  98. }
  99. dns_rdataclass_t
  100. dst_key_class(const dst_key_t *key) {
  101. REQUIRE(VALID_KEY(key));
  102. return (key->key_class);
  103. }
  104. isc_boolean_t
  105. dst_key_iszonekey(const dst_key_t *key) {
  106. REQUIRE(VALID_KEY(key));
  107. if ((key->key_flags & DNS_KEYTYPE_NOAUTH) != 0)
  108. return (ISC_FALSE);
  109. if ((key->key_flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE)
  110. return (ISC_FALSE);
  111. if (key->key_proto != DNS_KEYPROTO_DNSSEC &&
  112. key->key_proto != DNS_KEYPROTO_ANY)
  113. return (ISC_FALSE);
  114. return (ISC_TRUE);
  115. }
  116. isc_boolean_t
  117. dst_key_isnullkey(const dst_key_t *key) {
  118. REQUIRE(VALID_KEY(key));
  119. if ((key->key_flags & DNS_KEYFLAG_TYPEMASK) != DNS_KEYTYPE_NOKEY)
  120. return (ISC_FALSE);
  121. if ((key->key_flags & DNS_KEYFLAG_OWNERMASK) != DNS_KEYOWNER_ZONE)
  122. return (ISC_FALSE);
  123. if (key->key_proto != DNS_KEYPROTO_DNSSEC &&
  124. key->key_proto != DNS_KEYPROTO_ANY)
  125. return (ISC_FALSE);
  126. return (ISC_TRUE);
  127. }
  128. void
  129. dst_key_setbits(dst_key_t *key, isc_uint16_t bits) {
  130. unsigned int maxbits;
  131. REQUIRE(VALID_KEY(key));
  132. if (bits != 0) {
  133. RUNTIME_CHECK(dst_key_sigsize(key, &maxbits) == ISC_R_SUCCESS);
  134. maxbits *= 8;
  135. REQUIRE(bits <= maxbits);
  136. }
  137. key->key_bits = bits;
  138. }
  139. isc_uint16_t
  140. dst_key_getbits(const dst_key_t *key) {
  141. REQUIRE(VALID_KEY(key));
  142. return (key->key_bits);
  143. }
  144. /*! \file */