blob: 12ad3e3a84e3d7d570e75fad4c521718a3bf9790
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 |