Quelle tea.c Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Cryptographic API.
*
* TEA, XTEA, and XETA crypto alogrithms
*
* The TEA and Xtended TEA algorithms were developed by David Wheeler
* and Roger Needham at the Computer Laboratory of Cambridge University.
*
* Due to the order of evaluation in XTEA many people have incorrectly
* implemented it.  XETA (XTEA in the wrong order), exists for
* compatibility with these implementations.
*
* Copyright (c) 2004 Aaron Grothe ajgrothe@yahoo.com
*/

#include <crypto/algapi.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/unaligned.h>
#include <linux/types.h>

#define TEA_KEY_SIZE  16
#define TEA_BLOCK_SIZE  8
#define TEA_ROUNDS  32
#define TEA_DELTA  0x9e3779b9

#define XTEA_KEY_SIZE  16
#define XTEA_BLOCK_SIZE  8
#define XTEA_ROUNDS  32
#define XTEA_DELTA  0x9e3779b9

struct tea_ctx {
u32 KEY[4];
};

struct xtea_ctx {
u32 KEY[4];
};

static int tea_setkey(struct crypto_tfm *tfm, const u8 *in_key,
        unsigned int key_len)
{
struct tea_ctx *ctx = crypto_tfm_ctx(tfm);

ctx->KEY[0] = get_unaligned_le32(&in_key[0]);
ctx->KEY[1] = get_unaligned_le32(&in_key[4]);
ctx->KEY[2] = get_unaligned_le32(&in_key[8]);
ctx->KEY[3] = get_unaligned_le32(&in_key[12]);

return 0;

}

static void tea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
u32 y, z, n, sum = 0;
u32 k0, k1, k2, k3;
struct tea_ctx *ctx = crypto_tfm_ctx(tfm);

y = get_unaligned_le32(&src[0]);
z = get_unaligned_le32(&src[4]);

k0 = ctx->KEY[0];
k1 = ctx->KEY[1];
k2 = ctx->KEY[2];
k3 = ctx->KEY[3];

n = TEA_ROUNDS;

while (n-- > 0) {
  sum += TEA_DELTA;
  y += ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
  z += ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
}

put_unaligned_le32(y, &dst[0]);
put_unaligned_le32(z, &dst[4]);
}

static void tea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
u32 y, z, n, sum;
u32 k0, k1, k2, k3;
struct tea_ctx *ctx = crypto_tfm_ctx(tfm);

y = get_unaligned_le32(&src[0]);
z = get_unaligned_le32(&src[4]);

k0 = ctx->KEY[0];
k1 = ctx->KEY[1];
k2 = ctx->KEY[2];
k3 = ctx->KEY[3];

sum = TEA_DELTA << 5;

n = TEA_ROUNDS;

while (n-- > 0) {
  z -= ((y << 4) + k2) ^ (y + sum) ^ ((y >> 5) + k3);
  y -= ((z << 4) + k0) ^ (z + sum) ^ ((z >> 5) + k1);
  sum -= TEA_DELTA;
}

put_unaligned_le32(y, &dst[0]);
put_unaligned_le32(z, &dst[4]);
}

static int xtea_setkey(struct crypto_tfm *tfm, const u8 *in_key,
         unsigned int key_len)
{
struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);

ctx->KEY[0] = get_unaligned_le32(&in_key[0]);
ctx->KEY[1] = get_unaligned_le32(&in_key[4]);
ctx->KEY[2] = get_unaligned_le32(&in_key[8]);
ctx->KEY[3] = get_unaligned_le32(&in_key[12]);

return 0;

}

static void xtea_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
u32 y, z, sum = 0;
u32 limit = XTEA_DELTA * XTEA_ROUNDS;
struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);

y = get_unaligned_le32(&src[0]);
z = get_unaligned_le32(&src[4]);

while (sum != limit) {
  y += ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum&3]);
  sum += XTEA_DELTA;
  z += ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 &3]);
}

put_unaligned_le32(y, &dst[0]);
put_unaligned_le32(z, &dst[4]);
}

static void xtea_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
u32 y, z, sum;
struct tea_ctx *ctx = crypto_tfm_ctx(tfm);

y = get_unaligned_le32(&src[0]);
z = get_unaligned_le32(&src[4]);

sum = XTEA_DELTA * XTEA_ROUNDS;

while (sum) {
  z -= ((y << 4 ^ y >> 5) + y) ^ (sum + ctx->KEY[sum>>11 & 3]);
  sum -= XTEA_DELTA;
  y -= ((z << 4 ^ z >> 5) + z) ^ (sum + ctx->KEY[sum & 3]);
}

put_unaligned_le32(y, &dst[0]);
put_unaligned_le32(z, &dst[4]);
}

static void xeta_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
u32 y, z, sum = 0;
u32 limit = XTEA_DELTA * XTEA_ROUNDS;
struct xtea_ctx *ctx = crypto_tfm_ctx(tfm);

y = get_unaligned_le32(&src[0]);
z = get_unaligned_le32(&src[4]);

while (sum != limit) {
  y += (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum&3];
  sum += XTEA_DELTA;
  z += (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 &3];
}

put_unaligned_le32(y, &dst[0]);
put_unaligned_le32(z, &dst[4]);
}

static void xeta_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
u32 y, z, sum;
struct tea_ctx *ctx = crypto_tfm_ctx(tfm);

y = get_unaligned_le32(&src[0]);
z = get_unaligned_le32(&src[4]);

sum = XTEA_DELTA * XTEA_ROUNDS;

while (sum) {
  z -= (y << 4 ^ y >> 5) + (y ^ sum) + ctx->KEY[sum>>11 & 3];
  sum -= XTEA_DELTA;
  y -= (z << 4 ^ z >> 5) + (z ^ sum) + ctx->KEY[sum & 3];
}

put_unaligned_le32(y, &dst[0]);
put_unaligned_le32(z, &dst[4]);
}

static struct crypto_alg tea_algs[3] = { {
.cra_name  = "tea",
.cra_driver_name = "tea-generic",
.cra_flags  = CRYPTO_ALG_TYPE_CIPHER,
.cra_blocksize  = TEA_BLOCK_SIZE,
.cra_ctxsize  = sizeof (struct tea_ctx),
.cra_module  = THIS_MODULE,
.cra_u   = { .cipher = {
.cia_min_keysize = TEA_KEY_SIZE,
.cia_max_keysize = TEA_KEY_SIZE,
.cia_setkey  =  tea_setkey,
.cia_encrypt  = tea_encrypt,
.cia_decrypt  = tea_decrypt } }
}, {
.cra_name  = "xtea",
.cra_driver_name = "xtea-generic",
.cra_flags  = CRYPTO_ALG_TYPE_CIPHER,
.cra_blocksize  = XTEA_BLOCK_SIZE,
.cra_ctxsize  = sizeof (struct xtea_ctx),
.cra_module  = THIS_MODULE,
.cra_u   = { .cipher = {
.cia_min_keysize = XTEA_KEY_SIZE,
.cia_max_keysize = XTEA_KEY_SIZE,
.cia_setkey  =  xtea_setkey,
.cia_encrypt  = xtea_encrypt,
.cia_decrypt  = xtea_decrypt } }
}, {
.cra_name  = "xeta",
.cra_driver_name = "xeta-generic",
.cra_flags  = CRYPTO_ALG_TYPE_CIPHER,
.cra_blocksize  = XTEA_BLOCK_SIZE,
.cra_ctxsize  = sizeof (struct xtea_ctx),
.cra_module  = THIS_MODULE,
.cra_u   = { .cipher = {
.cia_min_keysize = XTEA_KEY_SIZE,
.cia_max_keysize = XTEA_KEY_SIZE,
.cia_setkey  =  xtea_setkey,
.cia_encrypt  = xeta_encrypt,
.cia_decrypt  = xeta_decrypt } }
} };

static int __init tea_mod_init(void)
{
return crypto_register_algs(tea_algs, ARRAY_SIZE(tea_algs));
}

static void __exit tea_mod_fini(void)
{
crypto_unregister_algs(tea_algs, ARRAY_SIZE(tea_algs));
}

MODULE_ALIAS_CRYPTO("tea");
MODULE_ALIAS_CRYPTO("xtea");
MODULE_ALIAS_CRYPTO("xeta");

module_init(tea_mod_init);
module_exit(tea_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("TEA, XTEA & XETA Cryptographic Algorithms");

quality88%

¤ Dauer der Verarbeitung: 0.7 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.