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 <linux/crypto.h>
23 #include <linux/err.h>
24 #include <linux/kernel.h>
26 #include <linux/rtnetlink.h>
27 #include <linux/slab.h>
28 #include <linux/scatterlist.h>
31 u_int32_t ks
[12] = {0x01010101, 0x01010101, 0x01010101, 0x01010101,
32 0x02020202, 0x02020202, 0x02020202, 0x02020202,
33 0x03030303, 0x03030303, 0x03030303, 0x03030303};
35 * +------------------------
37 * +------------------------
39 * +------------------------
41 * +------------------------
43 * +------------------------
45 * +------------------------
46 * | consts (block size * 3)
47 * +------------------------
49 struct crypto_xcbc_ctx
{
50 struct crypto_tfm
*child
;
55 void (*xor)(u8
*a
, const u8
*b
, unsigned int bs
);
60 static void xor_128(u8
*a
, const u8
*b
, unsigned int bs
)
62 ((u32
*)a
)[0] ^= ((u32
*)b
)[0];
63 ((u32
*)a
)[1] ^= ((u32
*)b
)[1];
64 ((u32
*)a
)[2] ^= ((u32
*)b
)[2];
65 ((u32
*)a
)[3] ^= ((u32
*)b
)[3];
68 static int _crypto_xcbc_digest_setkey(struct crypto_hash
*parent
,
69 struct crypto_xcbc_ctx
*ctx
)
71 int bs
= crypto_hash_blocksize(parent
);
75 if ((err
= crypto_cipher_setkey(ctx
->child
, ctx
->key
, ctx
->keylen
)))
78 ctx
->child
->__crt_alg
->cra_cipher
.cia_encrypt(ctx
->child
, key1
,
81 return crypto_cipher_setkey(ctx
->child
, key1
, bs
);
84 static int crypto_xcbc_digest_setkey(struct crypto_hash
*parent
,
85 const u8
*inkey
, unsigned int keylen
)
87 struct crypto_xcbc_ctx
*ctx
= crypto_hash_ctx_aligned(parent
);
89 if (keylen
!= crypto_tfm_alg_blocksize(ctx
->child
))
93 memcpy(ctx
->key
, inkey
, keylen
);
94 ctx
->consts
= (u8
*)ks
;
96 return _crypto_xcbc_digest_setkey(parent
, ctx
);
99 int crypto_xcbc_digest_init(struct hash_desc
*pdesc
)
101 struct crypto_xcbc_ctx
*ctx
= crypto_hash_ctx_aligned(pdesc
->tfm
);
102 int bs
= crypto_hash_blocksize(pdesc
->tfm
);
105 memset(ctx
->odds
, 0, bs
);
106 memset(ctx
->prev
, 0, bs
);
111 int crypto_xcbc_digest_update(struct hash_desc
*pdesc
, struct scatterlist
*sg
, unsigned int nbytes
)
113 struct crypto_hash
*parent
= pdesc
->tfm
;
114 struct crypto_xcbc_ctx
*ctx
= crypto_hash_ctx_aligned(parent
);
115 struct crypto_tfm
*tfm
= ctx
->child
;
116 int bs
= crypto_hash_blocksize(parent
);
121 struct page
*pg
= sg
[i
].page
;
122 unsigned int offset
= sg
[i
].offset
;
123 unsigned int slen
= sg
[i
].length
;
126 unsigned int len
= min(slen
, ((unsigned int)(PAGE_SIZE
)) - offset
);
127 char *p
= crypto_kmap(pg
, 0) + offset
;
129 /* checking the data can fill the block */
130 if ((ctx
->len
+ len
) <= bs
) {
131 memcpy(ctx
->odds
+ ctx
->len
, p
, len
);
135 /* checking the rest of the page */
136 if (len
+ offset
>= PAGE_SIZE
) {
143 crypto_yield(tfm
->crt_flags
);
147 /* filling odds with new data and encrypting it */
148 memcpy(ctx
->odds
+ ctx
->len
, p
, bs
- ctx
->len
);
149 len
-= bs
- ctx
->len
;
152 ctx
->xor(ctx
->prev
, ctx
->odds
, bs
);
153 tfm
->__crt_alg
->cra_cipher
.cia_encrypt(tfm
, ctx
->prev
, ctx
->prev
);
155 /* clearing the length */
158 /* encrypting the rest of data */
160 ctx
->xor(ctx
->prev
, p
, bs
);
161 tfm
->__crt_alg
->cra_cipher
.cia_encrypt(tfm
, ctx
->prev
, ctx
->prev
);
166 /* keeping the surplus of blocksize */
168 memcpy(ctx
->odds
, p
, len
);
172 crypto_yield(tfm
->crt_flags
);
173 slen
-= min(slen
, ((unsigned int)(PAGE_SIZE
)) - offset
);
177 nbytes
-=sg
[i
].length
;
184 int crypto_xcbc_digest_final(struct hash_desc
*pdesc
, u8
*out
)
186 struct crypto_hash
*parent
= pdesc
->tfm
;
187 struct crypto_xcbc_ctx
*ctx
= crypto_hash_ctx_aligned(parent
);
188 struct crypto_tfm
*tfm
= ctx
->child
;
189 int bs
= crypto_hash_blocksize(parent
);
192 if (ctx
->len
== bs
) {
195 if ((err
= crypto_cipher_setkey(tfm
, ctx
->key
, ctx
->keylen
)) != 0)
198 tfm
->__crt_alg
->cra_cipher
.cia_encrypt(tfm
, key2
, (const u8
*)(ctx
->consts
+bs
));
200 ctx
->xor(ctx
->prev
, ctx
->odds
, bs
);
201 ctx
->xor(ctx
->prev
, key2
, bs
);
202 _crypto_xcbc_digest_setkey(parent
, ctx
);
204 tfm
->__crt_alg
->cra_cipher
.cia_encrypt(tfm
, out
, ctx
->prev
);
208 u8
*p
= ctx
->odds
+ ctx
->len
;
212 rlen
= bs
- ctx
->len
-1;
216 if ((err
= crypto_cipher_setkey(tfm
, ctx
->key
, ctx
->keylen
)) != 0)
219 tfm
->__crt_alg
->cra_cipher
.cia_encrypt(tfm
, key3
, (const u8
*)(ctx
->consts
+bs
*2));
221 ctx
->xor(ctx
->prev
, ctx
->odds
, bs
);
222 ctx
->xor(ctx
->prev
, key3
, bs
);
224 _crypto_xcbc_digest_setkey(parent
, ctx
);
226 tfm
->__crt_alg
->cra_cipher
.cia_encrypt(tfm
, out
, ctx
->prev
);
232 static int crypto_xcbc_digest(struct hash_desc
*pdesc
,
233 struct scatterlist
*sg
, unsigned int nbytes
, u8
*out
)
235 crypto_xcbc_digest_init(pdesc
);
236 crypto_xcbc_digest_update(pdesc
, sg
, nbytes
);
237 return crypto_xcbc_digest_final(pdesc
, out
);
240 static int xcbc_init_tfm(struct crypto_tfm
*tfm
)
242 struct crypto_instance
*inst
= (void *)tfm
->__crt_alg
;
243 struct crypto_spawn
*spawn
= crypto_instance_ctx(inst
);
244 struct crypto_xcbc_ctx
*ctx
= crypto_hash_ctx_aligned(__crypto_hash_cast(tfm
));
245 int bs
= crypto_hash_blocksize(__crypto_hash_cast(tfm
));
247 tfm
= crypto_spawn_tfm(spawn
);
259 ctx
->child
= crypto_cipher_cast(tfm
);
260 ctx
->odds
= (u8
*)(ctx
+1);
261 ctx
->prev
= ctx
->odds
+ bs
;
262 ctx
->key
= ctx
->prev
+ bs
;
267 static void xcbc_exit_tfm(struct crypto_tfm
*tfm
)
269 struct crypto_xcbc_ctx
*ctx
= crypto_hash_ctx_aligned(__crypto_hash_cast(tfm
));
270 crypto_free_cipher(ctx
->child
);
273 static struct crypto_instance
*xcbc_alloc(void *param
, unsigned int len
)
275 struct crypto_instance
*inst
;
276 struct crypto_alg
*alg
;
277 alg
= crypto_get_attr_alg(param
, len
, CRYPTO_ALG_TYPE_CIPHER
,
278 CRYPTO_ALG_TYPE_HASH_MASK
| CRYPTO_ALG_ASYNC
);
280 return ERR_PTR(PTR_ERR(alg
));
282 switch(alg
->cra_blocksize
) {
286 return ERR_PTR(PTR_ERR(alg
));
289 inst
= crypto_alloc_instance("xcbc", alg
);
293 inst
->alg
.cra_flags
= CRYPTO_ALG_TYPE_HASH
;
294 inst
->alg
.cra_priority
= alg
->cra_priority
;
295 inst
->alg
.cra_blocksize
= alg
->cra_blocksize
;
296 inst
->alg
.cra_alignmask
= alg
->cra_alignmask
;
297 inst
->alg
.cra_type
= &crypto_hash_type
;
299 inst
->alg
.cra_hash
.digestsize
=
300 (alg
->cra_flags
& CRYPTO_ALG_TYPE_MASK
) ==
301 CRYPTO_ALG_TYPE_HASH
? alg
->cra_hash
.digestsize
:
303 inst
->alg
.cra_ctxsize
= sizeof(struct crypto_xcbc_ctx
) +
304 ALIGN(inst
->alg
.cra_blocksize
* 3, sizeof(void *));
305 inst
->alg
.cra_init
= xcbc_init_tfm
;
306 inst
->alg
.cra_exit
= xcbc_exit_tfm
;
308 inst
->alg
.cra_hash
.init
= crypto_xcbc_digest_init
;
309 inst
->alg
.cra_hash
.update
= crypto_xcbc_digest_update
;
310 inst
->alg
.cra_hash
.final
= crypto_xcbc_digest_final
;
311 inst
->alg
.cra_hash
.digest
= crypto_xcbc_digest
;
312 inst
->alg
.cra_hash
.setkey
= crypto_xcbc_digest_setkey
;
319 static void xcbc_free(struct crypto_instance
*inst
)
321 crypto_drop_spawn(crypto_instance_ctx(inst
));
325 static struct crypto_template crypto_xcbc_tmpl
= {
329 .module
= THIS_MODULE
,
332 static int __init
crypto_xcbc_module_init(void)
334 return crypto_register_template(&crypto_xcbc_tmpl
);
337 static void __exit
crypto_xcbc_module_exit(void)
339 crypto_unregister_template(&crypto_xcbc_tmpl
);
342 module_init(crypto_xcbc_module_init
);
343 module_exit(crypto_xcbc_module_exit
);
345 MODULE_LICENSE("GPL");
346 MODULE_DESCRIPTION("XCBC keyed hash algorithm");