crypto/tea.c

   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
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/mm.h>
  20 #include <asm/byteorder.h>
  21 #include <linux/crypto.h>
  22 #include <linux/types.h>
  23
  24 #define TEA_KEY_SIZE            16
  25 #define TEA_BLOCK_SIZE          8
  26 #define TEA_ROUNDS              32
  27 #define TEA_DELTA               0x9e3779b9
  28
  29 #define XTEA_KEY_SIZE           16
  30 #define XTEA_BLOCK_SIZE         8
  31 #define XTEA_ROUNDS             32
  32 #define XTEA_DELTA              0x9e3779b9
  33
  34 struct tea_ctx {
  35         u32 KEY[4];
  36 };
  37
  38 struct xtea_ctx {
  39         u32 KEY[4];
  40 };
  41
  42 static int tea_setkey(struct crypto_tfm *tfm, const u8 *in_key,
  43                       unsigned int key_len)
  44 {
  45         struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  46         const __le32 *key = (const __le32 *)in_key;
  47
  48         ctx->KEY[0] = le32_to_cpu(key[0]);
  49         ctx->KEY[1] = le32_to_cpu(key[1]);
  50         ctx->KEY[2] = le32_to_cpu(key[2]);
  51         ctx->KEY[3] = le32_to_cpu(key[3]);
  52
  53         return 0;
  54
  55 }
  56
  57 static void tea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  58 {
  59         u32 y, z, n, sum = 0;
  60         u32 k0, k1, k2, k3;
  61         struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  62         const __le32 *in = (const __le32 *)src;
  63         __le32 *out = (__le32 *)dst;
  64
  65         y = le32_to_cpu(in[0]);
  66         z = le32_to_cpu(in[1]);
  67
  68         k0 = ctx->KEY[0];
  69         k1 = ctx->KEY[1];
  70         k2 = ctx->KEY[2];
  71         k3 = ctx->KEY[3];
  72
  73         n = TEA_ROUNDS;
  74
  75         while (n-- > 0) {
  76                 sum += TEA_DELTA;
  77                 y += ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
  78                 z += ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
  79         }
  80
  81         out[0] = cpu_to_le32(y);
  82         out[1] = cpu_to_le32(z);
  83 }
  84
  85 static void tea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
  86 {
  87         u32 y, z, n, sum;
  88         u32 k0, k1, k2, k3;
  89         struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
  90         const __le32 *in = (const __le32 *)src;
  91         __le32 *out = (__le32 *)dst;
  92
  93         y = le32_to_cpu(in[0]);
  94         z = le32_to_cpu(in[1]);
  95
  96         k0 = ctx->KEY[0];
  97         k1 = ctx->KEY[1];
  98         k2 = ctx->KEY[2];
  99         k3 = ctx->KEY[3];
 100
 101         sum = TEA_DELTA << 5;
 102
 103         n = TEA_ROUNDS;
 104
 105         while (n-- > 0) {
 106                 z -= ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
 107                 y -= ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
 108                 sum -= TEA_DELTA;
 109         }
 110
 111         out[0] = cpu_to_le32(y);
 112         out[1] = cpu_to_le32(z);
 113 }
 114
 115 static int xtea_setkey(struct crypto_tfm *tfm, const u8 *in_key,
 116                        unsigned int key_len)
 117 {
 118         struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);
 119         const __le32 *key = (const __le32 *)in_key;
 120
 121         ctx->KEY[0] = le32_to_cpu(key[0]);
 122         ctx->KEY[1] = le32_to_cpu(key[1]);
 123         ctx->KEY[2] = le32_to_cpu(key[2]);
 124         ctx->KEY[3] = le32_to_cpu(key[3]);
 125
 126         return 0;
 127
 128 }
 129
 130 static void xtea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 131 {
 132         u32 y, z, sum = 0;
 133         u32 limit = XTEA_DELTA * XTEA_ROUNDS;
 134         struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);
 135         const __le32 *in = (const __le32 *)src;
 136         __le32 *out = (__le32 *)dst;
 137
 138         y = le32_to_cpu(in[0]);
 139         z = le32_to_cpu(in[1]);
 140
 141         while (sum != limit) {
 142                 y += ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum&3]);
 143                 sum += XTEA_DELTA;
 144                 z += ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 &3]);
 145         }
 146
 147         out[0] = cpu_to_le32(y);
 148         out[1] = cpu_to_le32(z);
 149 }
 150
 151 static void xtea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 152 {
 153         u32 y, z, sum;
 154         struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
 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         sum = XTEA_DELTA * XTEA_ROUNDS;
 162
 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
 169         out[0] = cpu_to_le32(y);
 170         out[1] = cpu_to_le32(z);
 171 }
 172
 173
 174 static void xeta_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 175 {
 176         u32 y, z, sum = 0;
 177         u32 limit = XTEA_DELTA * XTEA_ROUNDS;
 178         struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);
 179         const __le32 *in = (const __le32 *)src;
 180         __le32 *out = (__le32 *)dst;
 181
 182         y = le32_to_cpu(in[0]);
 183         z = le32_to_cpu(in[1]);
 184
 185         while (sum != limit) {
 186                 y += (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum&3];
 187                 sum += XTEA_DELTA;
 188                 z += (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 &3];
 189         }
 190
 191         out[0] = cpu_to_le32(y);
 192         out[1] = cpu_to_le32(z);
 193 }
 194
 195 static void xeta_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 196 {
 197         u32 y, z, sum;
 198         struct tea_ctx *ctx = crypto_tfm_ctx(tfm);
 199         const __le32 *in = (const __le32 *)src;
 200         __le32 *out = (__le32 *)dst;
 201
 202         y = le32_to_cpu(in[0]);
 203         z = le32_to_cpu(in[1]);
 204
 205         sum = XTEA_DELTA * XTEA_ROUNDS;
 206
 207         while (sum) {
 208                 z -= (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 & 3];
 209                 sum -= XTEA_DELTA;
 210                 y -= (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum & 3];
 211         }
 212
 213         out[0] = cpu_to_le32(y);
 214         out[1] = cpu_to_le32(z);
 215 }
 216
 217 static struct crypto_alg tea_algs[3] = { {
 218         .cra_name               =       "tea",
 219         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 220         .cra_blocksize          =       TEA_BLOCK_SIZE,
 221         .cra_ctxsize            =       sizeof (struct tea_ctx),
 222         .cra_alignmask          =       3,
 223         .cra_module             =       THIS_MODULE,
 224         .cra_u                  =       { .cipher = {
 225         .cia_min_keysize        =       TEA_KEY_SIZE,
 226         .cia_max_keysize        =       TEA_KEY_SIZE,
 227         .cia_setkey             =       tea_setkey,
 228         .cia_encrypt            =       tea_encrypt,
 229         .cia_decrypt            =       tea_decrypt } }
 230 }, {
 231         .cra_name               =       "xtea",
 232         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 233         .cra_blocksize          =       XTEA_BLOCK_SIZE,
 234         .cra_ctxsize            =       sizeof (struct xtea_ctx),
 235         .cra_alignmask          =       3,
 236         .cra_module             =       THIS_MODULE,
 237         .cra_u                  =       { .cipher = {
 238         .cia_min_keysize        =       XTEA_KEY_SIZE,
 239         .cia_max_keysize        =       XTEA_KEY_SIZE,
 240         .cia_setkey             =       xtea_setkey,
 241         .cia_encrypt            =       xtea_encrypt,
 242         .cia_decrypt            =       xtea_decrypt } }
 243 }, {
 244         .cra_name               =       "xeta",
 245         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 246         .cra_blocksize          =       XTEA_BLOCK_SIZE,
 247         .cra_ctxsize            =       sizeof (struct xtea_ctx),
 248         .cra_alignmask          =       3,
 249         .cra_module             =       THIS_MODULE,
 250         .cra_u                  =       { .cipher = {
 251         .cia_min_keysize        =       XTEA_KEY_SIZE,
 252         .cia_max_keysize        =       XTEA_KEY_SIZE,
 253         .cia_setkey             =       xtea_setkey,
 254         .cia_encrypt            =       xeta_encrypt,
 255         .cia_decrypt            =       xeta_decrypt } }
 256 } };
 257
 258 static int __init tea_mod_init(void)
 259 {
 260         return crypto_register_algs(tea_algs, ARRAY_SIZE(tea_algs));
 261 }
 262
 263 static void __exit tea_mod_fini(void)
 264 {
 265         crypto_unregister_algs(tea_algs, ARRAY_SIZE(tea_algs));
 266 }
 267
 268 MODULE_ALIAS_CRYPTO("tea");
 269 MODULE_ALIAS_CRYPTO("xtea");
 270 MODULE_ALIAS_CRYPTO("xeta");
 271
 272 subsys_initcall(tea_mod_init);
 273 module_exit(tea_mod_fini);
 274
 275 MODULE_LICENSE("GPL");
 276 MODULE_DESCRIPTION("TEA, XTEA & XETA Cryptographic Algorithms");