Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * Cryptographic API.
3 *
4 * TEA, XTEA, and XETA crypto alogrithms
5 *
6 * The TEA and Xtended TEA algorithms were developed by David Wheeler
7 * and Roger Needham at the Computer Laboratory of Cambridge University.
8 *
9 * Due to the order of evaluation in XTEA many people have incorrectly
10 * implemented it. XETA (XTEA in the wrong order), exists for
11 * compatibility with these implementations.
12 *
13 * Copyright (c) 2004 Aaron Grothe ajgrothe@yahoo.com
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 */
21
22#include <linux/init.h>
23#include <linux/module.h>
24#include <linux/mm.h>
25#include <asm/byteorder.h>
26#include <asm/scatterlist.h>
27#include <linux/crypto.h>
28#include <linux/types.h>
29
30#define TEA_KEY_SIZE 16
31#define TEA_BLOCK_SIZE 8
32#define TEA_ROUNDS 32
33#define TEA_DELTA 0x9e3779b9
34
35#define XTEA_KEY_SIZE 16
36#define XTEA_BLOCK_SIZE 8
37#define XTEA_ROUNDS 32
38#define XTEA_DELTA 0x9e3779b9
39
40struct tea_ctx {
41 u32 KEY[4];
42};
43
44struct xtea_ctx {
45 u32 KEY[4];
46};
47
48static int tea_setkey(void *ctx_arg, const u8 *in_key,
49 unsigned int key_len, u32 *flags)
50{
51 struct tea_ctx *ctx = ctx_arg;
52 const __le32 *key = (const __le32 *)in_key;
53
54 if (key_len != 16)
55 {
56 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
57 return -EINVAL;
58 }
59
60 ctx->KEY[0] = le32_to_cpu(key[0]);
61 ctx->KEY[1] = le32_to_cpu(key[1]);
62 ctx->KEY[2] = le32_to_cpu(key[2]);
63 ctx->KEY[3] = le32_to_cpu(key[3]);
64
65 return 0;
66
67}
68
69static void tea_encrypt(void *ctx_arg, u8 *dst, const u8 *src)
70{
71 u32 y, z, n, sum = 0;
72 u32 k0, k1, k2, k3;
73
74 struct tea_ctx *ctx = ctx_arg;
75 const __le32 *in = (const __le32 *)src;
76 __le32 *out = (__le32 *)dst;
77
78 y = le32_to_cpu(in[0]);
79 z = le32_to_cpu(in[1]);
80
81 k0 = ctx->KEY[0];
82 k1 = ctx->KEY[1];
83 k2 = ctx->KEY[2];
84 k3 = ctx->KEY[3];
85
86 n = TEA_ROUNDS;
87
88 while (n-- > 0) {
89 sum += TEA_DELTA;
90 y += ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
91 z += ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
92 }
93
94 out[0] = cpu_to_le32(y);
95 out[1] = cpu_to_le32(z);
96}
97
98static void tea_decrypt(void *ctx_arg, u8 *dst, const u8 *src)
99{
100 u32 y, z, n, sum;
101 u32 k0, k1, k2, k3;
102 struct tea_ctx *ctx = ctx_arg;
103 const __le32 *in = (const __le32 *)src;
104 __le32 *out = (__le32 *)dst;
105
106 y = le32_to_cpu(in[0]);
107 z = le32_to_cpu(in[1]);
108
109 k0 = ctx->KEY[0];
110 k1 = ctx->KEY[1];
111 k2 = ctx->KEY[2];
112 k3 = ctx->KEY[3];
113
114 sum = TEA_DELTA << 5;
115
116 n = TEA_ROUNDS;
117
118 while (n-- > 0) {
119 z -= ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
120 y -= ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
121 sum -= TEA_DELTA;
122 }
123
124 out[0] = cpu_to_le32(y);
125 out[1] = cpu_to_le32(z);
126}
127
128static int xtea_setkey(void *ctx_arg, const u8 *in_key,
129 unsigned int key_len, u32 *flags)
130{
131 struct xtea_ctx *ctx = ctx_arg;
132 const __le32 *key = (const __le32 *)in_key;
133
134 if (key_len != 16)
135 {
136 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
137 return -EINVAL;
138 }
139
140 ctx->KEY[0] = le32_to_cpu(key[0]);
141 ctx->KEY[1] = le32_to_cpu(key[1]);
142 ctx->KEY[2] = le32_to_cpu(key[2]);
143 ctx->KEY[3] = le32_to_cpu(key[3]);
144
145 return 0;
146
147}
148
149static void xtea_encrypt(void *ctx_arg, u8 *dst, const u8 *src)
150{
151 u32 y, z, sum = 0;
152 u32 limit = XTEA_DELTA * XTEA_ROUNDS;
153
154 struct xtea_ctx *ctx = ctx_arg;
155 const __le32 *in = (const __le32 *)src;
156 __le32 *out = (__le32 *)dst;
157
158 y = le32_to_cpu(in[0]);
159 z = le32_to_cpu(in[1]);
160
161 while (sum != limit) {
162 y += ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum&3]);
163 sum += XTEA_DELTA;
164 z += ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 &3]);
165 }
166
167 out[0] = cpu_to_le32(y);
168 out[1] = cpu_to_le32(z);
169}
170
171static void xtea_decrypt(void *ctx_arg, u8 *dst, const u8 *src)
172{
173 u32 y, z, sum;
174 struct tea_ctx *ctx = ctx_arg;
175 const __le32 *in = (const __le32 *)src;
176 __le32 *out = (__le32 *)dst;
177
178 y = le32_to_cpu(in[0]);
179 z = le32_to_cpu(in[1]);
180
181 sum = XTEA_DELTA * XTEA_ROUNDS;
182
183 while (sum) {
184 z -= ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 & 3]);
185 sum -= XTEA_DELTA;
186 y -= ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum & 3]);
187 }
188
189 out[0] = cpu_to_le32(y);
190 out[1] = cpu_to_le32(z);
191}
192
193
194static void xeta_encrypt(void *ctx_arg, u8 *dst, const u8 *src)
195{
196 u32 y, z, sum = 0;
197 u32 limit = XTEA_DELTA * XTEA_ROUNDS;
198
199 struct xtea_ctx *ctx = ctx_arg;
200 const __le32 *in = (const __le32 *)src;
201 __le32 *out = (__le32 *)dst;
202
203 y = le32_to_cpu(in[0]);
204 z = le32_to_cpu(in[1]);
205
206 while (sum != limit) {
207 y += (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum&3];
208 sum += XTEA_DELTA;
209 z += (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 &3];
210 }
211
212 out[0] = cpu_to_le32(y);
213 out[1] = cpu_to_le32(z);
214}
215
216static void xeta_decrypt(void *ctx_arg, u8 *dst, const u8 *src)
217{
218 u32 y, z, sum;
219 struct tea_ctx *ctx = ctx_arg;
220 const __le32 *in = (const __le32 *)src;
221 __le32 *out = (__le32 *)dst;
222
223 y = le32_to_cpu(in[0]);
224 z = le32_to_cpu(in[1]);
225
226 sum = XTEA_DELTA * XTEA_ROUNDS;
227
228 while (sum) {
229 z -= (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 & 3];
230 sum -= XTEA_DELTA;
231 y -= (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum & 3];
232 }
233
234 out[0] = cpu_to_le32(y);
235 out[1] = cpu_to_le32(z);
236}
237
238static struct crypto_alg tea_alg = {
239 .cra_name = "tea",
240 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
241 .cra_blocksize = TEA_BLOCK_SIZE,
242 .cra_ctxsize = sizeof (struct tea_ctx),
243 .cra_alignmask = 3,
244 .cra_module = THIS_MODULE,
245 .cra_list = LIST_HEAD_INIT(tea_alg.cra_list),
246 .cra_u = { .cipher = {
247 .cia_min_keysize = TEA_KEY_SIZE,
248 .cia_max_keysize = TEA_KEY_SIZE,
249 .cia_setkey = tea_setkey,
250 .cia_encrypt = tea_encrypt,
251 .cia_decrypt = tea_decrypt } }
252};
253
254static struct crypto_alg xtea_alg = {
255 .cra_name = "xtea",
256 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
257 .cra_blocksize = XTEA_BLOCK_SIZE,
258 .cra_ctxsize = sizeof (struct xtea_ctx),
259 .cra_alignmask = 3,
260 .cra_module = THIS_MODULE,
261 .cra_list = LIST_HEAD_INIT(xtea_alg.cra_list),
262 .cra_u = { .cipher = {
263 .cia_min_keysize = XTEA_KEY_SIZE,
264 .cia_max_keysize = XTEA_KEY_SIZE,
265 .cia_setkey = xtea_setkey,
266 .cia_encrypt = xtea_encrypt,
267 .cia_decrypt = xtea_decrypt } }
268};
269
270static struct crypto_alg xeta_alg = {
271 .cra_name = "xeta",
272 .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
273 .cra_blocksize = XTEA_BLOCK_SIZE,
274 .cra_ctxsize = sizeof (struct xtea_ctx),
275 .cra_alignmask = 3,
276 .cra_module = THIS_MODULE,
277 .cra_list = LIST_HEAD_INIT(xtea_alg.cra_list),
278 .cra_u = { .cipher = {
279 .cia_min_keysize = XTEA_KEY_SIZE,
280 .cia_max_keysize = XTEA_KEY_SIZE,
281 .cia_setkey = xtea_setkey,
282 .cia_encrypt = xeta_encrypt,
283 .cia_decrypt = xeta_decrypt } }
284};
285
286static int __init init(void)
287{
288 int ret = 0;
289
290 ret = crypto_register_alg(&tea_alg);
291 if (ret < 0)
292 goto out;
293
294 ret = crypto_register_alg(&xtea_alg);
295 if (ret < 0) {
296 crypto_unregister_alg(&tea_alg);
297 goto out;
298 }
299
300 ret = crypto_register_alg(&xeta_alg);
301 if (ret < 0) {
302 crypto_unregister_alg(&tea_alg);
303 crypto_unregister_alg(&xtea_alg);
304 goto out;
305 }
306
307out:
308 return ret;
309}
310
311static void __exit fini(void)
312{
313 crypto_unregister_alg(&tea_alg);
314 crypto_unregister_alg(&xtea_alg);
315 crypto_unregister_alg(&xeta_alg);
316}
317
318MODULE_ALIAS("xtea");
319MODULE_ALIAS("xeta");
320
321module_init(init);
322module_exit(fini);
323
324MODULE_LICENSE("GPL");
325MODULE_DESCRIPTION("TEA, XTEA & XETA Cryptographic Algorithms");