2 * Copyright (C)2006 USAGI/WIDE Project
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * Kazunori Miyazawa <miyazawa@linux-ipv6.org>
22 #include <crypto/internal/hash.h>
23 #include <linux/err.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
27 static u_int32_t ks
[12] = {0x01010101, 0x01010101, 0x01010101, 0x01010101,
28 0x02020202, 0x02020202, 0x02020202, 0x02020202,
29 0x03030303, 0x03030303, 0x03030303, 0x03030303};
32 * +------------------------
34 * +------------------------
36 * +------------------------
37 * | consts (block size * 2)
38 * +------------------------
41 struct crypto_cipher
*child
;
46 * +------------------------
48 * +------------------------
50 * +------------------------
52 * +------------------------
54 * +------------------------
56 struct xcbc_desc_ctx
{
61 static int crypto_xcbc_digest_setkey(struct crypto_shash
*parent
,
62 const u8
*inkey
, unsigned int keylen
)
64 unsigned long alignmask
= crypto_shash_alignmask(parent
);
65 struct xcbc_tfm_ctx
*ctx
= crypto_shash_ctx(parent
);
66 int bs
= crypto_shash_blocksize(parent
);
67 u8
*consts
= PTR_ALIGN(&ctx
->ctx
[0], alignmask
+ 1);
71 if ((err
= crypto_cipher_setkey(ctx
->child
, inkey
, keylen
)))
74 crypto_cipher_encrypt_one(ctx
->child
, consts
, (u8
*)ks
+ bs
);
75 crypto_cipher_encrypt_one(ctx
->child
, consts
+ bs
, (u8
*)ks
+ bs
* 2);
76 crypto_cipher_encrypt_one(ctx
->child
, key1
, (u8
*)ks
);
78 return crypto_cipher_setkey(ctx
->child
, key1
, bs
);
82 static int crypto_xcbc_digest_init(struct shash_desc
*pdesc
)
84 unsigned long alignmask
= crypto_shash_alignmask(pdesc
->tfm
);
85 struct xcbc_desc_ctx
*ctx
= shash_desc_ctx(pdesc
);
86 int bs
= crypto_shash_blocksize(pdesc
->tfm
);
87 u8
*prev
= PTR_ALIGN(&ctx
->ctx
[0], alignmask
+ 1) + bs
;
95 static int crypto_xcbc_digest_update(struct shash_desc
*pdesc
, const u8
*p
,
98 struct crypto_shash
*parent
= pdesc
->tfm
;
99 unsigned long alignmask
= crypto_shash_alignmask(parent
);
100 struct xcbc_tfm_ctx
*tctx
= crypto_shash_ctx(parent
);
101 struct xcbc_desc_ctx
*ctx
= shash_desc_ctx(pdesc
);
102 struct crypto_cipher
*tfm
= tctx
->child
;
103 int bs
= crypto_shash_blocksize(parent
);
104 u8
*odds
= PTR_ALIGN(&ctx
->ctx
[0], alignmask
+ 1);
105 u8
*prev
= odds
+ bs
;
107 /* checking the data can fill the block */
108 if ((ctx
->len
+ len
) <= bs
) {
109 memcpy(odds
+ ctx
->len
, p
, len
);
114 /* filling odds with new data and encrypting it */
115 memcpy(odds
+ ctx
->len
, p
, bs
- ctx
->len
);
116 len
-= bs
- ctx
->len
;
119 crypto_xor(prev
, odds
, bs
);
120 crypto_cipher_encrypt_one(tfm
, prev
, prev
);
122 /* clearing the length */
125 /* encrypting the rest of data */
127 crypto_xor(prev
, p
, bs
);
128 crypto_cipher_encrypt_one(tfm
, prev
, prev
);
133 /* keeping the surplus of blocksize */
135 memcpy(odds
, p
, len
);
142 static int crypto_xcbc_digest_final(struct shash_desc
*pdesc
, u8
*out
)
144 struct crypto_shash
*parent
= pdesc
->tfm
;
145 unsigned long alignmask
= crypto_shash_alignmask(parent
);
146 struct xcbc_tfm_ctx
*tctx
= crypto_shash_ctx(parent
);
147 struct xcbc_desc_ctx
*ctx
= shash_desc_ctx(pdesc
);
148 struct crypto_cipher
*tfm
= tctx
->child
;
149 int bs
= crypto_shash_blocksize(parent
);
150 u8
*consts
= PTR_ALIGN(&tctx
->ctx
[0], alignmask
+ 1);
151 u8
*odds
= PTR_ALIGN(&ctx
->ctx
[0], alignmask
+ 1);
152 u8
*prev
= odds
+ bs
;
153 unsigned int offset
= 0;
155 if (ctx
->len
!= bs
) {
157 u8
*p
= odds
+ ctx
->len
;
162 rlen
= bs
- ctx
->len
-1;
169 crypto_xor(prev
, odds
, bs
);
170 crypto_xor(prev
, consts
+ offset
, bs
);
172 crypto_cipher_encrypt_one(tfm
, out
, prev
);
177 static int xcbc_init_tfm(struct crypto_tfm
*tfm
)
179 struct crypto_cipher
*cipher
;
180 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
181 struct crypto_spawn
*spawn
= crypto_instance_ctx(inst
);
182 struct xcbc_tfm_ctx
*ctx
= crypto_tfm_ctx(tfm
);
184 cipher
= crypto_spawn_cipher(spawn
);
186 return PTR_ERR(cipher
);
193 static void xcbc_exit_tfm(struct crypto_tfm
*tfm
)
195 struct xcbc_tfm_ctx
*ctx
= crypto_tfm_ctx(tfm
);
196 crypto_free_cipher(ctx
->child
);
199 static int xcbc_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
201 struct shash_instance
*inst
;
202 struct crypto_alg
*alg
;
203 unsigned long alignmask
;
206 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SHASH
);
210 alg
= crypto_get_attr_alg(tb
, CRYPTO_ALG_TYPE_CIPHER
,
211 CRYPTO_ALG_TYPE_MASK
);
215 switch(alg
->cra_blocksize
) {
222 inst
= shash_alloc_instance("xcbc", alg
);
227 err
= crypto_init_spawn(shash_instance_ctx(inst
), alg
,
228 shash_crypto_instance(inst
),
229 CRYPTO_ALG_TYPE_MASK
);
233 alignmask
= alg
->cra_alignmask
| 3;
234 inst
->alg
.base
.cra_alignmask
= alignmask
;
235 inst
->alg
.base
.cra_priority
= alg
->cra_priority
;
236 inst
->alg
.base
.cra_blocksize
= alg
->cra_blocksize
;
238 inst
->alg
.digestsize
= alg
->cra_blocksize
;
239 inst
->alg
.descsize
= ALIGN(sizeof(struct xcbc_desc_ctx
),
240 crypto_tfm_ctx_alignment()) +
242 ~(crypto_tfm_ctx_alignment() - 1)) +
243 alg
->cra_blocksize
* 2;
245 inst
->alg
.base
.cra_ctxsize
= ALIGN(sizeof(struct xcbc_tfm_ctx
),
247 alg
->cra_blocksize
* 2;
248 inst
->alg
.base
.cra_init
= xcbc_init_tfm
;
249 inst
->alg
.base
.cra_exit
= xcbc_exit_tfm
;
251 inst
->alg
.init
= crypto_xcbc_digest_init
;
252 inst
->alg
.update
= crypto_xcbc_digest_update
;
253 inst
->alg
.final
= crypto_xcbc_digest_final
;
254 inst
->alg
.setkey
= crypto_xcbc_digest_setkey
;
256 err
= shash_register_instance(tmpl
, inst
);
259 shash_free_instance(shash_crypto_instance(inst
));
267 static struct crypto_template crypto_xcbc_tmpl
= {
269 .create
= xcbc_create
,
270 .free
= shash_free_instance
,
271 .module
= THIS_MODULE
,
274 static int __init
crypto_xcbc_module_init(void)
276 return crypto_register_template(&crypto_xcbc_tmpl
);
279 static void __exit
crypto_xcbc_module_exit(void)
281 crypto_unregister_template(&crypto_xcbc_tmpl
);
284 module_init(crypto_xcbc_module_init
);
285 module_exit(crypto_xcbc_module_exit
);
287 MODULE_LICENSE("GPL");
288 MODULE_DESCRIPTION("XCBC keyed hash algorithm");
289 MODULE_ALIAS_CRYPTO("xcbc");