tea.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Cryptographic API.
  4. *
  5. * TEA, XTEA, and XETA crypto alogrithms
  6. *
  7. * The TEA and Xtended TEA algorithms were developed by David Wheeler
  8. * and Roger Needham at the Computer Laboratory of Cambridge University.
  9. *
  10. * Due to the order of evaluation in XTEA many people have incorrectly
  11. * implemented it. XETA (XTEA in the wrong order), exists for
  12. * compatibility with these implementations.
  13. *
  14. * Copyright (c) 2004 Aaron Grothe ajgrothe@yahoo.com
  15. */
  16. #include <linux/init.h>
  17. #include <linux/module.h>
  18. #include <linux/mm.h>
  19. #include <asm/byteorder.h>
  20. #include <linux/crypto.h>
  21. #include <linux/types.h>
  22. #define TEA_KEY_SIZE 16
  23. #define TEA_BLOCK_SIZE 8
  24. #define TEA_ROUNDS 32
  25. #define TEA_DELTA 0x9e3779b9
  26. #define XTEA_KEY_SIZE 16
  27. #define XTEA_BLOCK_SIZE 8
  28. #define XTEA_ROUNDS 32
  29. #define XTEA_DELTA 0x9e3779b9
  30. struct tea_ctx {
  31. u32 KEY[4];
  32. };
  33. struct xtea_ctx {
  34. u32 KEY[4];
  35. };
  36. static int tea_setkey(struct crypto_tfm *tfm, const u8 *in_key,
  37. unsigned int key_len)
  38. {
  39. struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  40. const __le32 *key = (const __le32 *)in_key;
  41. ctx->KEY[0] = le32_to_cpu(key[0]);
  42. ctx->KEY[1] = le32_to_cpu(key[1]);
  43. ctx->KEY[2] = le32_to_cpu(key[2]);
  44. ctx->KEY[3] = le32_to_cpu(key[3]);
  45. return 0;
  46. }
  47. static void tea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  48. {
  49. u32 y, z, n, sum = 0;
  50. u32 k0, k1, k2, k3;
  51. struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  52. const __le32 *in = (const __le32 *)src;
  53. __le32 *out = (__le32 *)dst;
  54. y = le32_to_cpu(in[0]);
  55. z = le32_to_cpu(in[1]);
  56. k0 = ctx->KEY[0];
  57. k1 = ctx->KEY[1];
  58. k2 = ctx->KEY[2];
  59. k3 = ctx->KEY[3];
  60. n = TEA_ROUNDS;
  61. while (n-- > 0) {
  62. sum += TEA_DELTA;
  63. y += ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
  64. z += ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
  65. }
  66. out[0] = cpu_to_le32(y);
  67. out[1] = cpu_to_le32(z);
  68. }
  69. static void tea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  70. {
  71. u32 y, z, n, sum;
  72. u32 k0, k1, k2, k3;
  73. struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  74. const __le32 *in = (const __le32 *)src;
  75. __le32 *out = (__le32 *)dst;
  76. y = le32_to_cpu(in[0]);
  77. z = le32_to_cpu(in[1]);
  78. k0 = ctx->KEY[0];
  79. k1 = ctx->KEY[1];
  80. k2 = ctx->KEY[2];
  81. k3 = ctx->KEY[3];
  82. sum = TEA_DELTA << 5;
  83. n = TEA_ROUNDS;
  84. while (n-- > 0) {
  85. z -= ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
  86. y -= ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
  87. sum -= TEA_DELTA;
  88. }
  89. out[0] = cpu_to_le32(y);
  90. out[1] = cpu_to_le32(z);
  91. }
  92. static int xtea_setkey(struct crypto_tfm *tfm, const u8 *in_key,
  93. unsigned int key_len)
  94. {
  95. struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);
  96. const __le32 *key = (const __le32 *)in_key;
  97. ctx->KEY[0] = le32_to_cpu(key[0]);
  98. ctx->KEY[1] = le32_to_cpu(key[1]);
  99. ctx->KEY[2] = le32_to_cpu(key[2]);
  100. ctx->KEY[3] = le32_to_cpu(key[3]);
  101. return 0;
  102. }
  103. static void xtea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  104. {
  105. u32 y, z, sum = 0;
  106. u32 limit = XTEA_DELTA * XTEA_ROUNDS;
  107. struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);
  108. const __le32 *in = (const __le32 *)src;
  109. __le32 *out = (__le32 *)dst;
  110. y = le32_to_cpu(in[0]);
  111. z = le32_to_cpu(in[1]);
  112. while (sum != limit) {
  113. y += ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum&3]);
  114. sum += XTEA_DELTA;
  115. z += ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 &3]);
  116. }
  117. out[0] = cpu_to_le32(y);
  118. out[1] = cpu_to_le32(z);
  119. }
  120. static void xtea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  121. {
  122. u32 y, z, sum;
  123. struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  124. const __le32 *in = (const __le32 *)src;
  125. __le32 *out = (__le32 *)dst;
  126. y = le32_to_cpu(in[0]);
  127. z = le32_to_cpu(in[1]);
  128. sum = XTEA_DELTA * XTEA_ROUNDS;
  129. while (sum) {
  130. z -= ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 & 3]);
  131. sum -= XTEA_DELTA;
  132. y -= ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum & 3]);
  133. }
  134. out[0] = cpu_to_le32(y);
  135. out[1] = cpu_to_le32(z);
  136. }
  137. static void xeta_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  138. {
  139. u32 y, z, sum = 0;
  140. u32 limit = XTEA_DELTA * XTEA_ROUNDS;
  141. struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);
  142. const __le32 *in = (const __le32 *)src;
  143. __le32 *out = (__le32 *)dst;
  144. y = le32_to_cpu(in[0]);
  145. z = le32_to_cpu(in[1]);
  146. while (sum != limit) {
  147. y += (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum&3];
  148. sum += XTEA_DELTA;
  149. z += (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 &3];
  150. }
  151. out[0] = cpu_to_le32(y);
  152. out[1] = cpu_to_le32(z);
  153. }
  154. static void xeta_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  155. {
  156. u32 y, z, sum;
  157. struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  158. const __le32 *in = (const __le32 *)src;
  159. __le32 *out = (__le32 *)dst;
  160. y = le32_to_cpu(in[0]);
  161. z = le32_to_cpu(in[1]);
  162. sum = XTEA_DELTA * XTEA_ROUNDS;
  163. while (sum) {
  164. z -= (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 & 3];
  165. sum -= XTEA_DELTA;
  166. y -= (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum & 3];
  167. }
  168. out[0] = cpu_to_le32(y);
  169. out[1] = cpu_to_le32(z);
  170. }
  171. static struct crypto_alg tea_algs[3] = { {
  172. .cra_name = "tea",
  173. .cra_driver_name = "tea-generic",
  174. .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
  175. .cra_blocksize = TEA_BLOCK_SIZE,
  176. .cra_ctxsize = sizeof (struct tea_ctx),
  177. .cra_alignmask = 3,
  178. .cra_module = THIS_MODULE,
  179. .cra_u = { .cipher = {
  180. .cia_min_keysize = TEA_KEY_SIZE,
  181. .cia_max_keysize = TEA_KEY_SIZE,
  182. .cia_setkey = tea_setkey,
  183. .cia_encrypt = tea_encrypt,
  184. .cia_decrypt = tea_decrypt } }
  185. }, {
  186. .cra_name = "xtea",
  187. .cra_driver_name = "xtea-generic",
  188. .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
  189. .cra_blocksize = XTEA_BLOCK_SIZE,
  190. .cra_ctxsize = sizeof (struct xtea_ctx),
  191. .cra_alignmask = 3,
  192. .cra_module = THIS_MODULE,
  193. .cra_u = { .cipher = {
  194. .cia_min_keysize = XTEA_KEY_SIZE,
  195. .cia_max_keysize = XTEA_KEY_SIZE,
  196. .cia_setkey = xtea_setkey,
  197. .cia_encrypt = xtea_encrypt,
  198. .cia_decrypt = xtea_decrypt } }
  199. }, {
  200. .cra_name = "xeta",
  201. .cra_driver_name = "xeta-generic",
  202. .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
  203. .cra_blocksize = XTEA_BLOCK_SIZE,
  204. .cra_ctxsize = sizeof (struct xtea_ctx),
  205. .cra_alignmask = 3,
  206. .cra_module = THIS_MODULE,
  207. .cra_u = { .cipher = {
  208. .cia_min_keysize = XTEA_KEY_SIZE,
  209. .cia_max_keysize = XTEA_KEY_SIZE,
  210. .cia_setkey = xtea_setkey,
  211. .cia_encrypt = xeta_encrypt,
  212. .cia_decrypt = xeta_decrypt } }
  213. } };
  214. static int __init tea_mod_init(void)
  215. {
  216. return crypto_register_algs(tea_algs, ARRAY_SIZE(tea_algs));
  217. }
  218. static void __exit tea_mod_fini(void)
  219. {
  220. crypto_unregister_algs(tea_algs, ARRAY_SIZE(tea_algs));
  221. }
  222. MODULE_ALIAS_CRYPTO("tea");
  223. MODULE_ALIAS_CRYPTO("xtea");
  224. MODULE_ALIAS_CRYPTO("xeta");
  225. subsys_initcall(tea_mod_init);
  226. module_exit(tea_mod_fini);
  227. MODULE_LICENSE("GPL");
  228. MODULE_DESCRIPTION("TEA, XTEA & XETA Cryptographic Algorithms");