GC23005/Component/Encrypt/encrypt_xxtea.c

#include "encrypt_xxtea.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define XXTEA_MX (z >> 5 ^ y << 2) + (y >> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z)
#define XXTEA_DELTA 0x9E3779B9
unsigned char* xxtea_encrypt(unsigned char *data, xxtea_uint data_len, unsigned char *key, xxtea_uint key_len, xxtea_uint *ret_length);
unsigned char* xxtea_decrypt(unsigned char *data, xxtea_uint data_len, unsigned char *key, xxtea_uint key_len, xxtea_uint *ret_length);


void xxtea_uint_encrypt(xxtea_uint *v, xxtea_uint len, xxtea_uint *k) //对整型字节流进行加密,最终处理
{
    xxtea_uint n = len - 1;
    xxtea_uint z = v[n], y = v[0], p, q = 6 + 52 / (n + 1), sum = 0, e;
    if (n < 1)
    {
        return;
    }
    while (0 < q--)
    {
        sum += XXTEA_DELTA;
        e = sum >> 2 & 3;
        for (p = 0; p < n; p++)
        {
            y = v[p + 1];
            z = v[p] += XXTEA_MX;
        }
        y = v[0];
        z = v[n] += XXTEA_MX;
    }
}
void xxtea_uint_decrypt(xxtea_uint *v, xxtea_uint len, xxtea_uint *k) //对整型字节流进行解密，最终处理
{
    xxtea_uint n = len - 1;
    xxtea_uint z = v[n], y = v[0], p, q = 6 + 52 / (n + 1), sum = q * XXTEA_DELTA, e;
    if (n < 1)
    {
        return;
    }
    while (sum != 0)
    {
        e = sum >> 2 & 3;
        for (p = n; p > 0; p--)
        {
            z = v[p - 1];
            y = v[p] -= XXTEA_MX;
        }
        z = v[n];
        y = v[0] -= XXTEA_MX;
        sum -= XXTEA_DELTA;
    }
}
static unsigned char* fix_key_length(unsigned char *key, xxtea_uint key_len) //如果长度不够，则进行填充
{
    unsigned char *tmp = (unsigned char *)malloc(16); //申请16字节
    memcpy(tmp, key, key_len);                        //拷贝
    memset(tmp + key_len, '\0', 16 - key_len);        //将多余部分置零
    return tmp;                                       //返回可加密数据
}
static xxtea_uint* xxtea_to_uint_array(unsigned char *data, xxtea_uint len, int include_length, xxtea_uint *ret_len) //将数据转换成整型流，方便加密
{
    xxtea_uint i, n, *result;

    n = len >> 2; //右移2位，相当与*2
    n = (((len & 3) == 0) ? n : n + 1); //与运算，问号表达
    if (include_length)
    {
        result = (xxtea_uint *)malloc((n + 1) << 2);
        result[n] = len;
        *ret_len = n + 1;
    } else
    {
        result = (xxtea_uint *)malloc(n << 2);
        *ret_len = n;
    }
    memset(result, 0, n << 2);
    for (i = 0; i < len; i++)
    {
        result[i >> 2] |= (xxtea_uint)data[i] << ((i & 3) << 3);
    }

    return result;
}
static unsigned char* xxtea_to_byte_array(xxtea_uint *data, xxtea_uint len, int include_length, xxtea_uint *ret_len)  //将整型流转换成无符号字节流
{
    xxtea_uint i, n, m;
    unsigned char *result;

    n = len << 2;
    if (include_length)
    {
        m = data[len - 1];
        if ((m < n - 7) || (m > n - 4)) return NULL;
        n = m;
    }
    result = (unsigned char *)malloc(n + 1);
    for (i = 0; i < n; i++)
    {
        result[i] = (unsigned char)((data[i >> 2] >> ((i & 3) << 3)) & 0xff);
    }
    result[n] = '\0';
    *ret_len = n;

    return result;
}
static unsigned char* do_xxtea_encrypt(unsigned char *data, xxtea_uint len, unsigned char *key, xxtea_uint *ret_len) //第二级初始操作（已经补位），这里数据还为字符串
{
    unsigned char *result;
    xxtea_uint *v, *k, v_len, k_len;

    v = xxtea_to_uint_array(data, len, 1, &v_len);
    k = xxtea_to_uint_array(key, 16, 0, &k_len);
    xxtea_uint_encrypt(v, v_len, k);
    result = xxtea_to_byte_array(v, v_len, 0, ret_len);
    free(v);
    free(k);

    return result;
}
static unsigned char* do_xxtea_decrypt(unsigned char *data, xxtea_uint len, unsigned char *key, xxtea_uint *ret_len) //对称解密
{
    unsigned char *result;
    xxtea_uint *v, *k, v_len, k_len;

    v = xxtea_to_uint_array(data, len, 0, &v_len); //data变成整型数组流
    k = xxtea_to_uint_array(key, 16, 0, &k_len); //key 变成整型数组流
    xxtea_uint_decrypt(v, v_len, k);
    result = xxtea_to_byte_array(v, v_len, 1, ret_len); //xxtea_to_byte_array(v, v_len, 0, ret_len);
    free(v);
    free(k);

    return result;
}
unsigned char* xxtea_encrypt(unsigned char *data, xxtea_uint data_len, unsigned char *key, xxtea_uint key_len, xxtea_uint *ret_length) //初始操作，加密;
{
    unsigned char *result;

    *ret_length = 0;

    if (key_len < 16) //如果长度不够，进行补位
    {
        unsigned char *key2 = fix_key_length(key, key_len);
        result = do_xxtea_encrypt(data, data_len, key2, ret_length);
        free(key2);
    } else
    {
        result = do_xxtea_encrypt(data, data_len, key, ret_length);
    }

    return result;
}
unsigned char* xxtea_decrypt(unsigned char *data, xxtea_uint data_len, unsigned char *key, xxtea_uint key_len, xxtea_uint *ret_length) //初始操作，解密;
{
    unsigned char *result;

    *ret_length = 0;

    if (key_len < 16) //长度不够时，补位
    {
        unsigned char *key2 = fix_key_length(key, key_len);
        result = do_xxtea_decrypt(data, data_len, key2, ret_length);
        free(key2);
    } else
    {
        result = do_xxtea_decrypt(data, data_len, key, ret_length);
    }

    return result;
}