hmac.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:5k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 2001-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  *
  7.  * Some parts of this code originally written by Adam Stubblefield,
  8.  * astubble@rice.edu.
  9.  */
  10. #include "db_config.h"
  11. #ifndef lint
  12. static const char revid[] = "$Id: hmac.c,v 1.25 2002/09/10 02:40:40 bostic Exp $";
  13. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <string.h>
  16. #endif
  17. #include "db_int.h"
  18. #include "dbinc/crypto.h"
  19. #include "dbinc/db_page.h" /* for hash.h only */
  20. #include "dbinc/hash.h"
  21. #include "dbinc/hmac.h"
  22. #define HMAC_OUTPUT_SIZE 20
  23. #define HMAC_BLOCK_SIZE 64
  24. static void __db_hmac __P((u_int8_t *, u_int8_t *, size_t, u_int8_t *));
  25. /*
  26.  * !!!
  27.  * All of these functions use a ctx structure on the stack.  The __db_SHA1Init
  28.  * call does not initialize the 64-byte buffer portion of it.  The
  29.  * underlying SHA1 functions will properly pad the buffer if the data length
  30.  * is less than 64-bytes, so there isn't a chance of reading uninitialized
  31.  * memory.  Although it would be cleaner to do a memset(ctx.buffer, 0, 64)
  32.  * we do not want to incur that penalty if we don't have to for performance.
  33.  */
  34. /*
  35.  * __db_hmac --
  36.  * Do a hashed MAC.
  37.  */
  38. static void
  39. __db_hmac(k, data, data_len, mac)
  40. u_int8_t *k, *data, *mac;
  41. size_t data_len;
  42. {
  43. SHA1_CTX ctx;
  44. u_int8_t key[HMAC_BLOCK_SIZE];
  45. u_int8_t ipad[HMAC_BLOCK_SIZE];
  46. u_int8_t opad[HMAC_BLOCK_SIZE];
  47. u_int8_t tmp[HMAC_OUTPUT_SIZE];
  48. int i;
  49. memset(key, 0x00, HMAC_BLOCK_SIZE);
  50. memset(ipad, 0x36, HMAC_BLOCK_SIZE);
  51. memset(opad, 0x5C, HMAC_BLOCK_SIZE);
  52. memcpy(key, k, HMAC_OUTPUT_SIZE);
  53. for (i = 0; i < HMAC_BLOCK_SIZE; i++) {
  54. ipad[i] ^= key[i];
  55. opad[i] ^= key[i];
  56. }
  57. __db_SHA1Init(&ctx);
  58. __db_SHA1Update(&ctx, ipad, HMAC_BLOCK_SIZE);
  59. __db_SHA1Update(&ctx, data, data_len);
  60. __db_SHA1Final(tmp, &ctx);
  61. __db_SHA1Init(&ctx);
  62. __db_SHA1Update(&ctx, opad, HMAC_BLOCK_SIZE);
  63. __db_SHA1Update(&ctx, tmp, HMAC_OUTPUT_SIZE);
  64. __db_SHA1Final(mac, &ctx);
  65. return;
  66. }
  67. /*
  68.  * __db_chksum --
  69.  * Create a MAC/SHA1 checksum.
  70.  *
  71.  * PUBLIC: void __db_chksum __P((u_int8_t *, size_t, u_int8_t *, u_int8_t *));
  72.  */
  73. void
  74. __db_chksum(data, data_len, mac_key, store)
  75. u_int8_t *data;
  76. size_t data_len;
  77. u_int8_t *mac_key;
  78. u_int8_t *store;
  79. {
  80. int sumlen;
  81. u_int32_t hash4;
  82. u_int8_t tmp[DB_MAC_KEY];
  83. /*
  84.  * Since the checksum might be on a page of data we are checksumming
  85.  * we might be overwriting after checksumming, we zero-out the
  86.  * checksum value so that we can have a known value there when
  87.  * we verify the checksum.
  88.  */
  89. if (mac_key == NULL)
  90. sumlen = sizeof(u_int32_t);
  91. else
  92. sumlen = DB_MAC_KEY;
  93. memset(store, 0, sumlen);
  94. if (mac_key == NULL) {
  95. /* Just a hash, no MAC */
  96. hash4 = __ham_func4(NULL, data, (u_int32_t)data_len);
  97. memcpy(store, &hash4, sumlen);
  98. } else {
  99. memset(tmp, 0, DB_MAC_KEY);
  100. __db_hmac(mac_key, data, data_len, tmp);
  101. memcpy(store, tmp, sumlen);
  102. }
  103. return;
  104. }
  105. /*
  106.  * __db_derive_mac --
  107.  * Create a MAC/SHA1 key.
  108.  *
  109.  * PUBLIC: void __db_derive_mac __P((u_int8_t *, size_t, u_int8_t *));
  110.  */
  111. void
  112. __db_derive_mac(passwd, plen, mac_key)
  113. u_int8_t *passwd;
  114. size_t plen;
  115. u_int8_t *mac_key;
  116. {
  117. SHA1_CTX ctx;
  118. /* Compute the MAC key. mac_key must be 20 bytes. */
  119. __db_SHA1Init(&ctx);
  120. __db_SHA1Update(&ctx, passwd, plen);
  121. __db_SHA1Update(&ctx, (u_int8_t *)DB_MAC_MAGIC, strlen(DB_MAC_MAGIC));
  122. __db_SHA1Update(&ctx, passwd, plen);
  123. __db_SHA1Final(mac_key, &ctx);
  124. return;
  125. }
  126. /*
  127.  * __db_check_chksum --
  128.  * Verify a checksum.
  129.  *
  130.  * Return 0 on success, >0 (errno) on error, -1 on checksum mismatch.
  131.  *
  132.  * PUBLIC: int __db_check_chksum __P((DB_ENV *,
  133.  * PUBLIC:     DB_CIPHER *, u_int8_t *, void *, size_t, int));
  134.  */
  135. int
  136. __db_check_chksum(dbenv, db_cipher, chksum, data, data_len, is_hmac)
  137. DB_ENV *dbenv;
  138. DB_CIPHER *db_cipher;
  139. u_int8_t *chksum;
  140. void *data;
  141. size_t data_len;
  142. int is_hmac;
  143. {
  144. int ret;
  145. size_t sum_len;
  146. u_int32_t hash4;
  147. u_int8_t *mac_key, old[DB_MAC_KEY], new[DB_MAC_KEY];
  148. /*
  149.  * If we are just doing checksumming and not encryption, then checksum
  150.  * is 4 bytes.  Otherwise, it is DB_MAC_KEY size.  Check for illegal
  151.  * combinations of crypto/non-crypto checksums.
  152.  */
  153. if (is_hmac == 0) {
  154. if (db_cipher != NULL) {
  155. __db_err(dbenv,
  156.     "Unencrypted checksum with a supplied encryption key");
  157. return (EINVAL);
  158. }
  159. sum_len = sizeof(u_int32_t);
  160. mac_key = NULL;
  161. } else {
  162. if (db_cipher == NULL) {
  163. __db_err(dbenv,
  164.     "Encrypted checksum: no encryption key specified");
  165. return (EINVAL);
  166. }
  167. sum_len = DB_MAC_KEY;
  168. mac_key = db_cipher->mac_key;
  169. }
  170. /*
  171.  * !!!
  172.  * Since the checksum might be on the page, we need to have known data
  173.  * there so that we can generate the same original checksum.  We zero
  174.  * it out, just like we do in __db_chksum above.
  175.  */
  176. memcpy(old, chksum, sum_len);
  177. memset(chksum, 0, sum_len);
  178. if (mac_key == NULL) {
  179. /* Just a hash, no MAC */
  180. hash4 = __ham_func4(NULL, data, (u_int32_t)data_len);
  181. ret = memcmp((u_int32_t *)old, &hash4, sum_len) ? -1 : 0;
  182. } else {
  183. __db_hmac(mac_key, data, data_len, new);
  184. ret = memcmp(old, new, sum_len) ? -1 : 0;
  185. }
  186. return (ret);
  187. }