crypto/hmac.c

   1 /*
   2  * Cryptographic API.
   3  *
   4  * HMAC: Keyed-Hashing for Message Authentication (RFC2104).
   5  *
   6  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   7  * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
   8  *
   9  * The HMAC implementation is derived from USAGI.
  10  * Copyright (c) 2002 Kazunori Miyazawa <miyazawa@linux-ipv6.org> / USAGI
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License as published by the Free
  14  * Software Foundation; either version 2 of the License, or (at your option)
  15  * any later version.
  16  *
  17  */
  18
  19 #include <crypto/algapi.h>
  20 #include <crypto/scatterwalk.h>
  21 #include <linux/err.h>
  22 #include <linux/init.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/scatterlist.h>
  26 #include <linux/slab.h>
  27 #include <linux/string.h>
  28
  29 struct hmac_ctx {
  30         struct crypto_hash *child;
  31 };
  32
  33 static inline void *align_ptr(void *p, unsigned int align)
  34 {
  35         return (void *)ALIGN((unsigned long)p, align);
  36 }
  37
  38 static inline struct hmac_ctx *hmac_ctx(struct crypto_hash *tfm)
  39 {
  40         return align_ptr(crypto_hash_ctx_aligned(tfm) +
  41                          crypto_hash_blocksize(tfm) * 2 +
  42                          crypto_hash_digestsize(tfm), sizeof(void *));
  43 }
  44
  45 static int hmac_setkey(struct crypto_hash *parent,
  46                        const u8 *inkey, unsigned int keylen)
  47 {
  48         int bs = crypto_hash_blocksize(parent);
  49         int ds = crypto_hash_digestsize(parent);
  50         char *ipad = crypto_hash_ctx_aligned(parent);
  51         char *opad = ipad + bs;
  52         char *digest = opad + bs;
  53         struct hmac_ctx *ctx = align_ptr(digest + ds, sizeof(void *));
  54         struct crypto_hash *tfm = ctx->child;
  55         unsigned int i;
  56
  57         if (keylen > bs) {
  58                 struct hash_desc desc;
  59                 struct scatterlist tmp;
  60                 int err;
  61
  62                 desc.tfm = tfm;
  63                 desc.flags = crypto_hash_get_flags(parent);
  64                 desc.flags &= CRYPTO_TFM_REQ_MAY_SLEEP;
  65                 sg_init_one(&tmp, inkey, keylen);
  66
  67                 err = crypto_hash_digest(&desc, &tmp, keylen, digest);
  68                 if (err)
  69                         return err;
  70
  71                 inkey = digest;
  72                 keylen = ds;
  73         }
  74
  75         memcpy(ipad, inkey, keylen);
  76         memset(ipad + keylen, 0, bs - keylen);
  77         memcpy(opad, ipad, bs);
  78
  79         for (i = 0; i < bs; i++) {
  80                 ipad[i] ^= 0x36;
  81                 opad[i] ^= 0x5c;
  82         }
  83
  84         return 0;
  85 }
  86
  87 static int hmac_init(struct hash_desc *pdesc)
  88 {
  89         struct crypto_hash *parent = pdesc->tfm;
  90         int bs = crypto_hash_blocksize(parent);
  91         int ds = crypto_hash_digestsize(parent);
  92         char *ipad = crypto_hash_ctx_aligned(parent);
  93         struct hmac_ctx *ctx = align_ptr(ipad + bs * 2 + ds, sizeof(void *));
  94         struct hash_desc desc;
  95         struct scatterlist tmp;
  96         int err;
  97
  98         desc.tfm = ctx->child;
  99         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
 100         sg_init_one(&tmp, ipad, bs);
 101
 102         err = crypto_hash_init(&desc);
 103         if (unlikely(err))
 104                 return err;
 105
 106         return crypto_hash_update(&desc, &tmp, bs);
 107 }
 108
 109 static int hmac_update(struct hash_desc *pdesc,
 110                        struct scatterlist *sg, unsigned int nbytes)
 111 {
 112         struct hmac_ctx *ctx = hmac_ctx(pdesc->tfm);
 113         struct hash_desc desc;
 114
 115         desc.tfm = ctx->child;
 116         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
 117
 118         return crypto_hash_update(&desc, sg, nbytes);
 119 }
 120
 121 static int hmac_final(struct hash_desc *pdesc, u8 *out)
 122 {
 123         struct crypto_hash *parent = pdesc->tfm;
 124         int bs = crypto_hash_blocksize(parent);
 125         int ds = crypto_hash_digestsize(parent);
 126         char *opad = crypto_hash_ctx_aligned(parent) + bs;
 127         char *digest = opad + bs;
 128         struct hmac_ctx *ctx = align_ptr(digest + ds, sizeof(void *));
 129         struct hash_desc desc;
 130         struct scatterlist tmp;
 131         int err;
 132
 133         desc.tfm = ctx->child;
 134         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
 135         sg_init_one(&tmp, opad, bs + ds);
 136
 137         err = crypto_hash_final(&desc, digest);
 138         if (unlikely(err))
 139                 return err;
 140
 141         return crypto_hash_digest(&desc, &tmp, bs + ds, out);
 142 }
 143
 144 static int hmac_digest(struct hash_desc *pdesc, struct scatterlist *sg,
 145                        unsigned int nbytes, u8 *out)
 146 {
 147         struct crypto_hash *parent = pdesc->tfm;
 148         int bs = crypto_hash_blocksize(parent);
 149         int ds = crypto_hash_digestsize(parent);
 150         char *ipad = crypto_hash_ctx_aligned(parent);
 151         char *opad = ipad + bs;
 152         char *digest = opad + bs;
 153         struct hmac_ctx *ctx = align_ptr(digest + ds, sizeof(void *));
 154         struct hash_desc desc;
 155         struct scatterlist sg1[2];
 156         struct scatterlist sg2[1];
 157         int err;
 158
 159         desc.tfm = ctx->child;
 160         desc.flags = pdesc->flags & CRYPTO_TFM_REQ_MAY_SLEEP;
 161
 162         sg_init_table(sg1, 2);
 163         sg_set_buf(sg1, ipad, bs);
 164         scatterwalk_sg_chain(sg1, 2, sg);
 165
 166         sg_init_table(sg2, 1);
 167         sg_set_buf(sg2, opad, bs + ds);
 168
 169         err = crypto_hash_digest(&desc, sg1, nbytes + bs, digest);
 170         if (unlikely(err))
 171                 return err;
 172
 173         return crypto_hash_digest(&desc, sg2, bs + ds, out);
 174 }
 175
 176 static int hmac_init_tfm(struct crypto_tfm *tfm)
 177 {
 178         struct crypto_hash *hash;
 179         struct crypto_instance *inst = (void *)tfm->__crt_alg;
 180         struct crypto_spawn *spawn = crypto_instance_ctx(inst);
 181         struct hmac_ctx *ctx = hmac_ctx(__crypto_hash_cast(tfm));
 182
 183         hash = crypto_spawn_hash(spawn);
 184         if (IS_ERR(hash))
 185                 return PTR_ERR(hash);
 186
 187         ctx->child = hash;
 188         return 0;
 189 }
 190
 191 static void hmac_exit_tfm(struct crypto_tfm *tfm)
 192 {
 193         struct hmac_ctx *ctx = hmac_ctx(__crypto_hash_cast(tfm));
 194         crypto_free_hash(ctx->child);
 195 }
 196
 197 static void hmac_free(struct crypto_instance *inst)
 198 {
 199         crypto_drop_spawn(crypto_instance_ctx(inst));
 200         kfree(inst);
 201 }
 202
 203 static struct crypto_instance *hmac_alloc(struct rtattr **tb)
 204 {
 205         struct crypto_instance *inst;
 206         struct crypto_alg *alg;
 207         int err;
 208
 209         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_HASH);
 210         if (err)
 211                 return ERR_PTR(err);
 212
 213         alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_HASH,
 214                                   CRYPTO_ALG_TYPE_HASH_MASK);
 215         if (IS_ERR(alg))
 216                 return ERR_PTR(PTR_ERR(alg));
 217
 218         inst = crypto_alloc_instance("hmac", alg);
 219         if (IS_ERR(inst))
 220                 goto out_put_alg;
 221
 222         inst->alg.cra_flags = CRYPTO_ALG_TYPE_HASH;
 223         inst->alg.cra_priority = alg->cra_priority;
 224         inst->alg.cra_blocksize = alg->cra_blocksize;
 225         inst->alg.cra_alignmask = alg->cra_alignmask;
 226         inst->alg.cra_type = &crypto_hash_type;
 227
 228         inst->alg.cra_hash.digestsize =
 229                 (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
 230                 CRYPTO_ALG_TYPE_HASH ? alg->cra_hash.digestsize :
 231                                        alg->cra_digest.dia_digestsize;
 232
 233         inst->alg.cra_ctxsize = sizeof(struct hmac_ctx) +
 234                                 ALIGN(inst->alg.cra_blocksize * 2 +
 235                                       inst->alg.cra_hash.digestsize,
 236                                       sizeof(void *));
 237
 238         inst->alg.cra_init = hmac_init_tfm;
 239         inst->alg.cra_exit = hmac_exit_tfm;
 240
 241         inst->alg.cra_hash.init = hmac_init;
 242         inst->alg.cra_hash.update = hmac_update;
 243         inst->alg.cra_hash.final = hmac_final;
 244         inst->alg.cra_hash.digest = hmac_digest;
 245         inst->alg.cra_hash.setkey = hmac_setkey;
 246
 247 out_put_alg:
 248         crypto_mod_put(alg);
 249         return inst;
 250 }
 251
 252 static struct crypto_template hmac_tmpl = {
 253         .name = "hmac",
 254         .alloc = hmac_alloc,
 255         .free = hmac_free,
 256         .module = THIS_MODULE,
 257 };
 258
 259 static int __init hmac_module_init(void)
 260 {
 261         return crypto_register_template(&hmac_tmpl);
 262 }
 263
 264 static void __exit hmac_module_exit(void)
 265 {
 266         crypto_unregister_template(&hmac_tmpl);
 267 }
 268
 269 module_init(hmac_module_init);
 270 module_exit(hmac_module_exit);
 271
 272 MODULE_LICENSE("GPL");
 273 MODULE_DESCRIPTION("HMAC hash algorithm");