Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/crypto/ghash-generic.c

  1 /*
  2  * GHASH: digest algorithm for GCM (Galois/Counter Mode).
  3  *
  4  * Copyright (c) 2007 Nokia Siemens Networks - Mikko Herranen <mh1@iki.fi>
  5  * Copyright (c) 2009 Intel Corp.
  6  *   Author: Huang Ying <ying.huang@intel.com>
  7  *
  8  * The algorithm implementation is copied from gcm.c.
  9  *
 10  * This program is free software; you can redistribute it and/or modify it
 11  * under the terms of the GNU General Public License version 2 as published
 12  * by the Free Software Foundation.
 13  */
 14 
 15 #include <crypto/algapi.h>
 16 #include <crypto/gf128mul.h>
 17 #include <crypto/ghash.h>
 18 #include <crypto/internal/hash.h>
 19 #include <linux/crypto.h>
 20 #include <linux/init.h>
 21 #include <linux/kernel.h>
 22 #include <linux/module.h>
 23 
 24 static int ghash_init(struct shash_desc *desc)
 25 {
 26         struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);
 27 
 28         memset(dctx, 0, sizeof(*dctx));
 29 
 30         return 0;
 31 }
 32 
 33 static int ghash_setkey(struct crypto_shash *tfm,
 34                         const u8 *key, unsigned int keylen)
 35 {
 36         struct ghash_ctx *ctx = crypto_shash_ctx(tfm);
 37 
 38         if (keylen != GHASH_BLOCK_SIZE) {
 39                 crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
 40                 return -EINVAL;
 41         }
 42 
 43         if (ctx->gf128)
 44                 gf128mul_free_4k(ctx->gf128);
 45         ctx->gf128 = gf128mul_init_4k_lle((be128 *)key);
 46         if (!ctx->gf128)
 47                 return -ENOMEM;
 48 
 49         return 0;
 50 }
 51 
 52 static int ghash_update(struct shash_desc *desc,
 53                          const u8 *src, unsigned int srclen)
 54 {
 55         struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);
 56         struct ghash_ctx *ctx = crypto_shash_ctx(desc->tfm);
 57         u8 *dst = dctx->buffer;
 58 
 59         if (!ctx->gf128)
 60                 return -ENOKEY;
 61 
 62         if (dctx->bytes) {
 63                 int n = min(srclen, dctx->bytes);
 64                 u8 *pos = dst + (GHASH_BLOCK_SIZE - dctx->bytes);
 65 
 66                 dctx->bytes -= n;
 67                 srclen -= n;
 68 
 69                 while (n--)
 70                         *pos++ ^= *src++;
 71 
 72                 if (!dctx->bytes)
 73                         gf128mul_4k_lle((be128 *)dst, ctx->gf128);
 74         }
 75 
 76         while (srclen >= GHASH_BLOCK_SIZE) {
 77                 crypto_xor(dst, src, GHASH_BLOCK_SIZE);
 78                 gf128mul_4k_lle((be128 *)dst, ctx->gf128);
 79                 src += GHASH_BLOCK_SIZE;
 80                 srclen -= GHASH_BLOCK_SIZE;
 81         }
 82 
 83         if (srclen) {
 84                 dctx->bytes = GHASH_BLOCK_SIZE - srclen;
 85                 while (srclen--)
 86                         *dst++ ^= *src++;
 87         }
 88 
 89         return 0;
 90 }
 91 
 92 static void ghash_flush(struct ghash_ctx *ctx, struct ghash_desc_ctx *dctx)
 93 {
 94         u8 *dst = dctx->buffer;
 95 
 96         if (dctx->bytes) {
 97                 u8 *tmp = dst + (GHASH_BLOCK_SIZE - dctx->bytes);
 98 
 99                 while (dctx->bytes--)
100                         *tmp++ ^= 0;
101 
102                 gf128mul_4k_lle((be128 *)dst, ctx->gf128);
103         }
104 
105         dctx->bytes = 0;
106 }
107 
108 static int ghash_final(struct shash_desc *desc, u8 *dst)
109 {
110         struct ghash_desc_ctx *dctx = shash_desc_ctx(desc);
111         struct ghash_ctx *ctx = crypto_shash_ctx(desc->tfm);
112         u8 *buf = dctx->buffer;
113 
114         if (!ctx->gf128)
115                 return -ENOKEY;
116 
117         ghash_flush(ctx, dctx);
118         memcpy(dst, buf, GHASH_BLOCK_SIZE);
119 
120         return 0;
121 }
122 
123 static void ghash_exit_tfm(struct crypto_tfm *tfm)
124 {
125         struct ghash_ctx *ctx = crypto_tfm_ctx(tfm);
126         if (ctx->gf128)
127                 gf128mul_free_4k(ctx->gf128);
128 }
129 
130 static struct shash_alg ghash_alg = {
131         .digestsize     = GHASH_DIGEST_SIZE,
132         .init           = ghash_init,
133         .update         = ghash_update,
134         .final          = ghash_final,
135         .setkey         = ghash_setkey,
136         .descsize       = sizeof(struct ghash_desc_ctx),
137         .base           = {
138                 .cra_name               = "ghash",
139                 .cra_driver_name        = "ghash-generic",
140                 .cra_priority           = 100,
141                 .cra_flags              = CRYPTO_ALG_TYPE_SHASH,
142                 .cra_blocksize          = GHASH_BLOCK_SIZE,
143                 .cra_ctxsize            = sizeof(struct ghash_ctx),
144                 .cra_module             = THIS_MODULE,
145                 .cra_exit               = ghash_exit_tfm,
146         },
147 };
148 
149 static int __init ghash_mod_init(void)
150 {
151         return crypto_register_shash(&ghash_alg);
152 }
153 
154 static void __exit ghash_mod_exit(void)
155 {
156         crypto_unregister_shash(&ghash_alg);
157 }
158 
159 module_init(ghash_mod_init);
160 module_exit(ghash_mod_exit);
161 
162 MODULE_LICENSE("GPL");
163 MODULE_DESCRIPTION("GHASH Message Digest Algorithm");
164 MODULE_ALIAS_CRYPTO("ghash");
165 MODULE_ALIAS_CRYPTO("ghash-generic");
166 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us