Annotation of embedaddon/bird/lib/mac.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD Library -- Message Authentication Codes
! 3: *
! 4: * (c) 2016 Ondrej Zajicek <santiago@crfreenet.org>
! 5: * (c) 2016 CZ.NIC z.s.p.o.
! 6: *
! 7: * Can be freely distributed and used under the terms of the GNU GPL.
! 8: */
! 9:
! 10: /**
! 11: * DOC: Message authentication codes
! 12: *
! 13: * MAC algorithms are simple cryptographic tools for message authentication.
! 14: * They use shared a secret key a and message text to generate authentication
! 15: * code, which is then passed with the message to the other side, where the code
! 16: * is verified. There are multiple families of MAC algorithms based on different
! 17: * cryptographic primitives, BIRD implements two MAC families which use hash
! 18: * functions.
! 19: *
! 20: * The first family is simply a cryptographic hash camouflaged as MAC algorithm.
! 21: * Originally supposed to be (m|k)-hash (message is concatenated with key, and
! 22: * that is hashed), but later it turned out that a raw hash is more practical.
! 23: * This is used for cryptographic authentication in OSPFv2, RIP and BFD.
! 24: *
! 25: * The second family is the standard HMAC (RFC 2104), using inner and outer hash
! 26: * to process key and message. HMAC (with SHA) is used in advanced OSPF and RIP
! 27: * authentication (RFC 5709, RFC 4822).
! 28: */
! 29:
! 30: #include "lib/mac.h"
! 31: #include "lib/md5.h"
! 32: #include "lib/sha1.h"
! 33: #include "lib/sha256.h"
! 34: #include "lib/sha512.h"
! 35:
! 36:
! 37: /*
! 38: * Internal hash calls
! 39: */
! 40:
! 41: static inline void
! 42: hash_init(struct mac_context *mctx, struct hash_context *hctx)
! 43: { mctx->type->hash_init(hctx); }
! 44:
! 45: static inline void
! 46: hash_update(struct mac_context *mctx, struct hash_context *hctx, const byte *buf, uint len)
! 47: { mctx->type->hash_update(hctx, buf, len); }
! 48:
! 49: static inline byte *
! 50: hash_final(struct mac_context *mctx, struct hash_context *hctx)
! 51: { return mctx->type->hash_final(hctx); }
! 52:
! 53: static inline void
! 54: hash_buffer(struct mac_context *mctx, byte *outbuf, const byte *buffer, uint length)
! 55: {
! 56: struct hash_context hctx;
! 57:
! 58: hash_init(mctx, &hctx);
! 59: hash_update(mctx, &hctx, buffer, length);
! 60: memcpy(outbuf, hash_final(mctx, &hctx), mctx->type->hash_size);
! 61: }
! 62:
! 63:
! 64: /*
! 65: * (not-really-MAC) Hash
! 66: */
! 67:
! 68: static void
! 69: nrmh_init(struct mac_context *ctx, const byte *key UNUSED, uint keylen UNUSED)
! 70: {
! 71: struct nrmh_context *ct = (void *) ctx;
! 72: hash_init(ctx, &ct->ictx);
! 73: }
! 74:
! 75: static void
! 76: nrmh_update(struct mac_context *ctx, const byte *data, uint datalen)
! 77: {
! 78: struct nrmh_context *ct = (void *) ctx;
! 79: hash_update(ctx, &ct->ictx, data, datalen);
! 80: }
! 81:
! 82: static byte *
! 83: nrmh_final(struct mac_context *ctx)
! 84: {
! 85: struct nrmh_context *ct = (void *) ctx;
! 86: return hash_final(ctx, &ct->ictx);
! 87: }
! 88:
! 89:
! 90: /*
! 91: * HMAC
! 92: */
! 93:
! 94: static void
! 95: hmac_init(struct mac_context *ctx, const byte *key, uint keylen)
! 96: {
! 97: struct hmac_context *ct = (void *) ctx;
! 98: uint block_size = ctx->type->block_size;
! 99: uint hash_size = ctx->type->hash_size;
! 100:
! 101: byte *keybuf = alloca(block_size);
! 102: byte *buf = alloca(block_size);
! 103: uint i;
! 104:
! 105: /* Hash the key if necessary */
! 106: if (keylen <= block_size)
! 107: {
! 108: memcpy(keybuf, key, keylen);
! 109: memset(keybuf + keylen, 0, block_size - keylen);
! 110: }
! 111: else
! 112: {
! 113: hash_buffer(ctx, keybuf, key, keylen);
! 114: memset(keybuf + hash_size, 0, block_size - hash_size);
! 115: }
! 116:
! 117: /* Initialize the inner digest */
! 118: hash_init(ctx, &ct->ictx);
! 119: for (i = 0; i < block_size; i++)
! 120: buf[i] = keybuf[i] ^ 0x36;
! 121: hash_update(ctx, &ct->ictx, buf, block_size);
! 122:
! 123: /* Initialize the outer digest */
! 124: hash_init(ctx, &ct->octx);
! 125: for (i = 0; i < block_size; i++)
! 126: buf[i] = keybuf[i] ^ 0x5c;
! 127: hash_update(ctx, &ct->octx, buf, block_size);
! 128: }
! 129:
! 130: static void
! 131: hmac_update(struct mac_context *ctx, const byte *data, uint datalen)
! 132: {
! 133: struct hmac_context *ct = (void *) ctx;
! 134:
! 135: /* Just update the inner digest */
! 136: hash_update(ctx, &ct->ictx, data, datalen);
! 137: }
! 138:
! 139: static byte *
! 140: hmac_final(struct mac_context *ctx)
! 141: {
! 142: struct hmac_context *ct = (void *) ctx;
! 143:
! 144: /* Finish the inner digest */
! 145: byte *isha = hash_final(ctx, &ct->ictx);
! 146:
! 147: /* Finish the outer digest */
! 148: hash_update(ctx, &ct->octx, isha, ctx->type->hash_size);
! 149: return hash_final(ctx, &ct->octx);
! 150: }
! 151:
! 152:
! 153: /*
! 154: * Common code
! 155: */
! 156:
! 157: #define HASH_DESC(name, px, PX) \
! 158: { name, PX##_SIZE, sizeof(struct nrmh_context), nrmh_init, nrmh_update, nrmh_final, \
! 159: PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final }
! 160:
! 161: #define HMAC_DESC(name, px, PX) \
! 162: { name, PX##_SIZE, sizeof(struct hmac_context), hmac_init, hmac_update, hmac_final, \
! 163: PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final }
! 164:
! 165: const struct mac_desc mac_table[ALG_MAX] = {
! 166: [ALG_MD5] = HASH_DESC("Keyed MD5", md5, MD5),
! 167: [ALG_SHA1] = HASH_DESC("Keyed SHA-1", sha1, SHA1),
! 168: [ALG_SHA224] = HASH_DESC("Keyed SHA-224", sha224, SHA224),
! 169: [ALG_SHA256] = HASH_DESC("Keyed SHA-256", sha256, SHA256),
! 170: [ALG_SHA384] = HASH_DESC("Keyed SHA-384", sha384, SHA384),
! 171: [ALG_SHA512] = HASH_DESC("Keyed SHA-512", sha512, SHA512),
! 172: [ALG_HMAC_MD5] = HMAC_DESC("HMAC-MD5", md5, MD5),
! 173: [ALG_HMAC_SHA1] = HMAC_DESC("HMAC-SHA-1", sha1, SHA1),
! 174: [ALG_HMAC_SHA224] = HMAC_DESC("HMAC-SHA-224", sha224, SHA224),
! 175: [ALG_HMAC_SHA256] = HMAC_DESC("HMAC-SHA-256", sha256, SHA256),
! 176: [ALG_HMAC_SHA384] = HMAC_DESC("HMAC-SHA-384", sha384, SHA384),
! 177: [ALG_HMAC_SHA512] = HMAC_DESC("HMAC-SHA-512", sha512, SHA512),
! 178: };
! 179:
! 180:
! 181: /**
! 182: * mac_init - initialize MAC algorithm
! 183: * @ctx: context to initialize
! 184: * @id: MAC algorithm ID
! 185: * @key: MAC key
! 186: * @keylen: MAC key length
! 187: *
! 188: * Initialize MAC context @ctx for algorithm @id (e.g., %ALG_HMAC_SHA1), with
! 189: * key @key of length @keylen. After that, message data could be added using
! 190: * mac_update() function.
! 191: */
! 192: void
! 193: mac_init(struct mac_context *ctx, uint id, const byte *key, uint keylen)
! 194: {
! 195: ctx->type = &mac_table[id];
! 196: ctx->type->init(ctx, key, keylen);
! 197: }
! 198:
! 199: #if 0
! 200: /**
! 201: * mac_update - add more data to MAC algorithm
! 202: * @ctx: MAC context
! 203: * @data: data to add
! 204: * @datalen: length of data
! 205: *
! 206: * Push another @datalen bytes of data pointed to by @data into the MAC
! 207: * algorithm currently in @ctx. Can be called multiple times for the same MAC
! 208: * context. It has the same effect as concatenating all the data together and
! 209: * passing them at once.
! 210: */
! 211: void mac_update(struct mac_context *ctx, const byte *data, uint datalen)
! 212: { DUMMY; }
! 213:
! 214: /**
! 215: * mac_final - finalize MAC algorithm
! 216: * @ctx: MAC context
! 217: *
! 218: * Finish MAC computation and return a pointer to the result. No more
! 219: * @mac_update() calls could be done, but the context may be reinitialized
! 220: * later.
! 221: *
! 222: * Note that the returned pointer points into data in the @ctx context. If it
! 223: * ceases to exist, the pointer becomes invalid.
! 224: */
! 225: byte *mac_final(struct mac_context *ctx)
! 226: { DUMMY; }
! 227:
! 228: /**
! 229: * mac_cleanup - cleanup MAC context
! 230: * @ctx: MAC context
! 231: *
! 232: * Cleanup MAC context after computation (by filling with zeros). Not strictly
! 233: * necessary, just to erase sensitive data from stack. This also invalidates the
! 234: * pointer returned by @mac_final().
! 235: */
! 236: void mac_cleanup(struct mac_context *ctx)
! 237: { DUMMY; }
! 238:
! 239: #endif
! 240:
! 241: /**
! 242: * mac_fill - compute and fill MAC
! 243: * @id: MAC algorithm ID
! 244: * @key: secret key
! 245: * @keylen: key length
! 246: * @data: message data
! 247: * @datalen: message length
! 248: * @mac: place to fill MAC
! 249: *
! 250: * Compute MAC for specified key @key and message @data using algorithm @id and
! 251: * copy it to buffer @mac. mac_fill() is a shortcut function doing all usual
! 252: * steps for transmitted messages.
! 253: */
! 254: void
! 255: mac_fill(uint id, const byte *key, uint keylen, const byte *data, uint datalen, byte *mac)
! 256: {
! 257: struct mac_context ctx;
! 258:
! 259: mac_init(&ctx, id, key, keylen);
! 260: mac_update(&ctx, data, datalen);
! 261: memcpy(mac, mac_final(&ctx), mac_get_length(&ctx));
! 262: mac_cleanup(&ctx);
! 263: }
! 264:
! 265: /**
! 266: * mac_verify - compute and verify MAC
! 267: * @id: MAC algorithm ID
! 268: * @key: secret key
! 269: * @keylen: key length
! 270: * @data: message data
! 271: * @datalen: message length
! 272: * @mac: received MAC
! 273: *
! 274: * Compute MAC for specified key @key and message @data using algorithm @id and
! 275: * compare it with received @mac, return whether they are the same. mac_verify()
! 276: * is a shortcut function doing all usual steps for received messages.
! 277: */
! 278: int
! 279: mac_verify(uint id, const byte *key, uint keylen, const byte *data, uint datalen, const byte *mac)
! 280: {
! 281: struct mac_context ctx;
! 282:
! 283: mac_init(&ctx, id, key, keylen);
! 284: mac_update(&ctx, data, datalen);
! 285: int res = !memcmp(mac, mac_final(&ctx), mac_get_length(&ctx));
! 286: mac_cleanup(&ctx);
! 287:
! 288: return res;
! 289: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mac.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird / lib