crypto/tea.c

   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/scatterlist.h>
  26 #include <linux/crypto.h>
  27
  28 #define TEA_KEY_SIZE            16
  29 #define TEA_BLOCK_SIZE          8
  30 #define TEA_ROUNDS              32
  31 #define TEA_DELTA               0x9e3779b9
  32
  33 #define XTEA_KEY_SIZE           16
  34 #define XTEA_BLOCK_SIZE         8
  35 #define XTEA_ROUNDS             32
  36 #define XTEA_DELTA              0x9e3779b9
  37
  38 #define u32_in(x) le32_to_cpu(*(const __le32 *)(x))
  39 #define u32_out(to, from) (*(__le32 *)(to) = cpu_to_le32(from))
  40
  41 struct tea_ctx {
  42         u32 KEY[4];
  43 };
  44
  45 struct xtea_ctx {
  46         u32 KEY[4];
  47 };
  48
  49 static int tea_setkey(void *ctx_arg, const u8 *in_key,
  50                        unsigned int key_len, u32 *flags)
  51 {
  52
  53         struct tea_ctx *ctx = ctx_arg;
  54
  55         if (key_len != 16)
  56         {
  57                 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
  58                 return -EINVAL;
  59         }
  60
  61         ctx->KEY[0] = u32_in (in_key);
  62         ctx->KEY[1] = u32_in (in_key + 4);
  63         ctx->KEY[2] = u32_in (in_key + 8);
  64         ctx->KEY[3] = u32_in (in_key + 12);
  65
  66         return 0;
  67
  68 }
  69
  70 static void tea_encrypt(void *ctx_arg, u8 *dst, const u8 *src)
  71 {
  72         u32 y, z, n, sum = 0;
  73         u32 k0, k1, k2, k3;
  74
  75         struct tea_ctx *ctx = ctx_arg;
  76
  77         y = u32_in (src);
  78         z = u32_in (src + 4);
  79
  80         k0 = ctx->KEY[0];
  81         k1 = ctx->KEY[1];
  82         k2 = ctx->KEY[2];
  83         k3 = ctx->KEY[3];
  84
  85         n = TEA_ROUNDS;
  86
  87         while (n-- > 0) {
  88                 sum += TEA_DELTA;
  89                 y += ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
  90                 z += ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
  91         }
  92
  93         u32_out (dst, y);
  94         u32_out (dst + 4, z);
  95 }
  96
  97 static void tea_decrypt(void *ctx_arg, u8 *dst, const u8 *src)
  98 {
  99         u32 y, z, n, sum;
 100         u32 k0, k1, k2, k3;
 101
 102         struct tea_ctx *ctx = ctx_arg;
 103
 104         y = u32_in (src);
 105         z = u32_in (src + 4);
 106
 107         k0 = ctx->KEY[0];
 108         k1 = ctx->KEY[1];
 109         k2 = ctx->KEY[2];
 110         k3 = ctx->KEY[3];
 111
 112         sum = TEA_DELTA << 5;
 113
 114         n = TEA_ROUNDS;
 115
 116         while (n-- > 0) {
 117                 z -= ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
 118                 y -= ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
 119                 sum -= TEA_DELTA;
 120         }
 121
 122         u32_out (dst, y);
 123         u32_out (dst + 4, z);
 124
 125 }
 126
 127 static int xtea_setkey(void *ctx_arg, const u8 *in_key,
 128                        unsigned int key_len, u32 *flags)
 129 {
 130
 131         struct xtea_ctx *ctx = ctx_arg;
 132
 133         if (key_len != 16)
 134         {
 135                 *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
 136                 return -EINVAL;
 137         }
 138
 139         ctx->KEY[0] = u32_in (in_key);
 140         ctx->KEY[1] = u32_in (in_key + 4);
 141         ctx->KEY[2] = u32_in (in_key + 8);
 142         ctx->KEY[3] = u32_in (in_key + 12);
 143
 144         return 0;
 145
 146 }
 147
 148 static void xtea_encrypt(void *ctx_arg, u8 *dst, const u8 *src)
 149 {
 150
 151         u32 y, z, sum = 0;
 152         u32 limit = XTEA_DELTA * XTEA_ROUNDS;
 153
 154         struct xtea_ctx *ctx = ctx_arg;
 155
 156         y = u32_in (src);
 157         z = u32_in (src + 4);
 158
 159         while (sum != limit) {
 160                 y += ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum&3]);
 161                 sum += XTEA_DELTA;
 162                 z += ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 &3]);
 163         }
 164
 165         u32_out (dst, y);
 166         u32_out (dst + 4, z);
 167
 168 }
 169
 170 static void xtea_decrypt(void *ctx_arg, u8 *dst, const u8 *src)
 171 {
 172
 173         u32 y, z, sum;
 174         struct tea_ctx *ctx = ctx_arg;
 175
 176         y = u32_in (src);
 177         z = u32_in (src + 4);
 178
 179         sum = XTEA_DELTA * XTEA_ROUNDS;
 180
 181         while (sum) {
 182                 z -= ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 & 3]);
 183                 sum -= XTEA_DELTA;
 184                 y -= ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum & 3]);
 185         }
 186
 187         u32_out (dst, y);
 188         u32_out (dst + 4, z);
 189
 190 }
 191
 192
 193 static void xeta_encrypt(void *ctx_arg, u8 *dst, const u8 *src)
 194 {
 195
 196         u32 y, z, sum = 0;
 197         u32 limit = XTEA_DELTA * XTEA_ROUNDS;
 198
 199         struct xtea_ctx *ctx = ctx_arg;
 200
 201         y = u32_in (src);
 202         z = u32_in (src + 4);
 203
 204         while (sum != limit) {
 205                 y += (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum&3];
 206                 sum += XTEA_DELTA;
 207                 z += (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 &3];
 208         }
 209
 210         u32_out (dst, y);
 211         u32_out (dst + 4, z);
 212
 213 }
 214
 215 static void xeta_decrypt(void *ctx_arg, u8 *dst, const u8 *src)
 216 {
 217
 218         u32 y, z, sum;
 219         struct tea_ctx *ctx = ctx_arg;
 220
 221         y = u32_in (src);
 222         z = u32_in (src + 4);
 223
 224         sum = XTEA_DELTA * XTEA_ROUNDS;
 225
 226         while (sum) {
 227                 z -= (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 & 3];
 228                 sum -= XTEA_DELTA;
 229                 y -= (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum & 3];
 230         }
 231
 232         u32_out (dst, y);
 233         u32_out (dst + 4, z);
 234
 235 }
 236
 237 static struct crypto_alg tea_alg = {
 238         .cra_name               =       "tea",
 239         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 240         .cra_blocksize          =       TEA_BLOCK_SIZE,
 241         .cra_ctxsize            =       sizeof (struct tea_ctx),
 242         .cra_module             =       THIS_MODULE,
 243         .cra_list               =       LIST_HEAD_INIT(tea_alg.cra_list),
 244         .cra_u                  =       { .cipher = {
 245         .cia_min_keysize        =       TEA_KEY_SIZE,
 246         .cia_max_keysize        =       TEA_KEY_SIZE,
 247         .cia_setkey             =       tea_setkey,
 248         .cia_encrypt            =       tea_encrypt,
 249         .cia_decrypt            =       tea_decrypt } }
 250 };
 251
 252 static struct crypto_alg xtea_alg = {
 253         .cra_name               =       "xtea",
 254         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 255         .cra_blocksize          =       XTEA_BLOCK_SIZE,
 256         .cra_ctxsize            =       sizeof (struct xtea_ctx),
 257         .cra_module             =       THIS_MODULE,
 258         .cra_list               =       LIST_HEAD_INIT(xtea_alg.cra_list),
 259         .cra_u                  =       { .cipher = {
 260         .cia_min_keysize        =       XTEA_KEY_SIZE,
 261         .cia_max_keysize        =       XTEA_KEY_SIZE,
 262         .cia_setkey             =       xtea_setkey,
 263         .cia_encrypt            =       xtea_encrypt,
 264         .cia_decrypt            =       xtea_decrypt } }
 265 };
 266
 267 static struct crypto_alg xeta_alg = {
 268         .cra_name               =       "xeta",
 269         .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 270         .cra_blocksize          =       XTEA_BLOCK_SIZE,
 271         .cra_ctxsize            =       sizeof (struct xtea_ctx),
 272         .cra_module             =       THIS_MODULE,
 273         .cra_list               =       LIST_HEAD_INIT(xtea_alg.cra_list),
 274         .cra_u                  =       { .cipher = {
 275         .cia_min_keysize        =       XTEA_KEY_SIZE,
 276         .cia_max_keysize        =       XTEA_KEY_SIZE,
 277         .cia_setkey             =       xtea_setkey,
 278         .cia_encrypt            =       xeta_encrypt,
 279         .cia_decrypt            =       xeta_decrypt } }
 280 };
 281
 282 static int __init init(void)
 283 {
 284         int ret = 0;
 285
 286         ret = crypto_register_alg(&tea_alg);
 287         if (ret < 0)
 288                 goto out;
 289
 290         ret = crypto_register_alg(&xtea_alg);
 291         if (ret < 0) {
 292                 crypto_unregister_alg(&tea_alg);
 293                 goto out;
 294         }
 295
 296         ret = crypto_register_alg(&xeta_alg);
 297         if (ret < 0) {
 298                 crypto_unregister_alg(&tea_alg);
 299                 crypto_unregister_alg(&xtea_alg);
 300                 goto out;
 301         }
 302
 303 out:
 304         return ret;
 305 }
 306
 307 static void __exit fini(void)
 308 {
 309         crypto_unregister_alg(&tea_alg);
 310         crypto_unregister_alg(&xtea_alg);
 311         crypto_unregister_alg(&xeta_alg);
 312 }
 313
 314 MODULE_ALIAS("xtea");
 315 MODULE_ALIAS("xeta");
 316
 317 module_init(init);
 318 module_exit(fini);
 319
 320 MODULE_LICENSE("GPL");
 321 MODULE_DESCRIPTION("TEA, XTEA & XETA Cryptographic Algorithms");