379 lines
8.4 KiB
C
379 lines
8.4 KiB
C
/*
|
|
* Copyright (C) 1998,1999,2000,2001 Nikos Mavroyanopoulos
|
|
*
|
|
* This library is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU Library General Public License as published
|
|
* by the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <libdefs.h>
|
|
|
|
#include <mcrypt_modules.h>
|
|
#include "wake.h"
|
|
|
|
#define _mcrypt_set_key wake_LTX__mcrypt_set_key
|
|
#define _mcrypt_encrypt wake_LTX__mcrypt_encrypt
|
|
#define _mcrypt_decrypt wake_LTX__mcrypt_decrypt
|
|
#define _mcrypt_get_size wake_LTX__mcrypt_get_size
|
|
#define _mcrypt_get_block_size wake_LTX__mcrypt_get_block_size
|
|
#define _is_block_algorithm wake_LTX__is_block_algorithm
|
|
#define _mcrypt_get_key_size wake_LTX__mcrypt_get_key_size
|
|
#define _mcrypt_get_algo_iv_size wake_LTX__mcrypt_get_algo_iv_size
|
|
#define _mcrypt_get_supported_key_sizes wake_LTX__mcrypt_get_supported_key_sizes
|
|
#define _mcrypt_get_algorithms_name wake_LTX__mcrypt_get_algorithms_name
|
|
#define _mcrypt_self_test wake_LTX__mcrypt_self_test
|
|
#define _mcrypt_algorithm_version wake_LTX__mcrypt_algorithm_version
|
|
|
|
/* WAKE reference C-code, based on the description in David J. Wheeler's
|
|
* paper "A bulk Data Encryption Algorithm"
|
|
*/
|
|
|
|
/* #define USE_IV */
|
|
/* IV is an mcrypt extension */
|
|
|
|
static const word32 tt[10] = {
|
|
0x726a8f3bUL,
|
|
0xe69a3b5cUL,
|
|
0xd3c71fe5UL,
|
|
0xab3c73d2UL,
|
|
0x4d3a8eb3UL,
|
|
0x0396d6e8UL,
|
|
0x3d4c2f7aUL,
|
|
0x9ee27cf3UL
|
|
};
|
|
|
|
WIN32DLL_DEFINE
|
|
int _mcrypt_set_key(WAKE_KEY * wake_key, word32 * key, int len,
|
|
word32 * IV, int ivlen)
|
|
{
|
|
word32 x, z, p;
|
|
word32 k[4];
|
|
/* the key must be exactly 256 bits */
|
|
if (len != 32)
|
|
return -1;
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
k[0] = byteswap32(key[0]);
|
|
k[1] = byteswap32(key[1]);
|
|
k[2] = byteswap32(key[2]);
|
|
k[3] = byteswap32(key[3]);
|
|
#else
|
|
k[0] = key[0];
|
|
k[1] = key[1];
|
|
k[2] = key[2];
|
|
k[3] = key[3];
|
|
#endif
|
|
|
|
for (p = 0; p < 4; p++) {
|
|
wake_key->t[p] = k[p];
|
|
}
|
|
|
|
for (p = 4; p < 256; p++) {
|
|
x = wake_key->t[p - 4] + wake_key->t[p - 1];
|
|
wake_key->t[p] = x >> 3 ^ tt[x & 7];
|
|
}
|
|
|
|
for (p = 0; p < 23; p++)
|
|
wake_key->t[p] += wake_key->t[p + 89];
|
|
|
|
x = wake_key->t[33];
|
|
z = wake_key->t[59] | 0x01000001;
|
|
z &= 0xff7fffff;
|
|
|
|
for (p = 0; p < 256; p++) {
|
|
x = (x & 0xff7fffff) + z;
|
|
wake_key->t[p] = (wake_key->t[p] & 0x00ffffff) ^ x;
|
|
}
|
|
|
|
wake_key->t[256] = wake_key->t[0];
|
|
x &= 0xff;
|
|
|
|
for (p = 0; p < 256; p++) {
|
|
wake_key->t[p] = wake_key->t[x =
|
|
(wake_key->t[p ^ x] ^ x) &
|
|
0xff];
|
|
wake_key->t[x] = wake_key->t[p + 1];
|
|
}
|
|
|
|
wake_key->counter = 0;
|
|
wake_key->r[0] = k[0];
|
|
wake_key->r[1] = k[1];
|
|
wake_key->r[2] = k[2];
|
|
#ifdef WORDS_BIGENDIAN
|
|
wake_key->r[3] = byteswap32(k[3]);
|
|
#else
|
|
wake_key->r[3] = k[3];
|
|
#endif
|
|
#ifdef USE_IV
|
|
wake_key->started = 0;
|
|
if (ivlen > 32)
|
|
wake_key->ivsize = 32;
|
|
else
|
|
wake_key->ivsize = ivlen / 4 * 4;
|
|
|
|
if (IV == NULL)
|
|
wake_key->ivsize = 0;
|
|
if (wake_key->ivsize > 0 && IV != NULL)
|
|
memcpy(&wake_key->iv, IV, wake_key->ivsize);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* in order to read the code easier */
|
|
#define r2 wake_key->tmp
|
|
#define r1 wake_key->tmp
|
|
#define counter wake_key->counter
|
|
|
|
/* M(X,Y) = (X+Y)>>8 XOR t[(X+Y) & 0xff] */
|
|
#define M(X,Y) _int_M(X,Y, wake_key)
|
|
//inline
|
|
static word32 _int_M(word32 X, word32 Y, WAKE_KEY * wake_key)
|
|
{
|
|
register word32 TMP;
|
|
|
|
TMP = X + Y;
|
|
return ((((TMP) >> 8) & 0x00ffffff) ^ wake_key->t[(TMP) & 0xff]);
|
|
}
|
|
|
|
WIN32DLL_DEFINE
|
|
void _mcrypt_encrypt(WAKE_KEY * wake_key, byte * input, int len)
|
|
{
|
|
register word32 r3, r4, r5;
|
|
word32 r6;
|
|
int i;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
r3 = wake_key->r[0];
|
|
r4 = wake_key->r[1];
|
|
r5 = wake_key->r[2];
|
|
r6 = wake_key->r[3];
|
|
|
|
#ifdef USE_IV
|
|
if (wake_key->started == 0) {
|
|
wake_key->started = 1;
|
|
_mcrypt_encrypt(wake_key, (byte *) & wake_key->iv,
|
|
wake_key->ivsize);
|
|
}
|
|
#endif
|
|
|
|
for (i = 0; i < len; i++) {
|
|
/* R1 = V[n] = V[n] XOR R6 - here we do it per byte --sloooow */
|
|
/* R1 is ignored */
|
|
input[i] ^= ((byte *) & r6)[counter];
|
|
|
|
/* R2 = V[n] = R1 - per byte also */
|
|
((byte *) & r2)[counter] = input[i];
|
|
counter++;
|
|
|
|
if (counter == 4) { /* r6 was used - update it! */
|
|
counter = 0;
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
/* these swaps are because we do operations per byte */
|
|
r2 = byteswap32(r2);
|
|
r6 = byteswap32(r6);
|
|
#endif
|
|
r3 = M(r3, r2);
|
|
r4 = M(r4, r3);
|
|
r5 = M(r5, r4);
|
|
r6 = M(r6, r5);
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
r6 = byteswap32(r6);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
wake_key->r[0] = r3;
|
|
wake_key->r[1] = r4;
|
|
wake_key->r[2] = r5;
|
|
wake_key->r[3] = r6;
|
|
|
|
}
|
|
|
|
|
|
WIN32DLL_DEFINE
|
|
void _mcrypt_decrypt(WAKE_KEY * wake_key, byte * input, int len)
|
|
{
|
|
register word32 r3, r4, r5;
|
|
word32 r6;
|
|
int i;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
r3 = wake_key->r[0];
|
|
r4 = wake_key->r[1];
|
|
r5 = wake_key->r[2];
|
|
r6 = wake_key->r[3];
|
|
|
|
#ifdef USE_IV
|
|
if (wake_key->started == 0) {
|
|
wake_key->started = 1;
|
|
_mcrypt_encrypt(wake_key, (byte *) & wake_key->iv,
|
|
wake_key->ivsize);
|
|
wake_key->r[0] = r3;
|
|
wake_key->r[1] = r4;
|
|
wake_key->r[2] = r5;
|
|
wake_key->r[3] = r6;
|
|
_mcrypt_decrypt(wake_key, (byte *) & wake_key->iv,
|
|
wake_key->ivsize);
|
|
}
|
|
#endif
|
|
|
|
for (i = 0; i < len; i++) {
|
|
/* R1 = V[n] */
|
|
((byte *) & r1)[counter] = input[i];
|
|
/* R2 = V[n] = V[n] ^ R6 */
|
|
/* R2 is ignored */
|
|
input[i] ^= ((byte *) & r6)[counter];
|
|
counter++;
|
|
|
|
if (counter == 4) {
|
|
counter = 0;
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
r1 = byteswap32(r1);
|
|
r6 = byteswap32(r6);
|
|
#endif
|
|
r3 = M(r3, r1);
|
|
r4 = M(r4, r3);
|
|
r5 = M(r5, r4);
|
|
r6 = M(r6, r5);
|
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
r6 = byteswap32(r6);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
wake_key->r[0] = r3;
|
|
wake_key->r[1] = r4;
|
|
wake_key->r[2] = r5;
|
|
wake_key->r[3] = r6;
|
|
|
|
}
|
|
|
|
|
|
WIN32DLL_DEFINE int _mcrypt_get_size()
|
|
{
|
|
return sizeof(WAKE_KEY);
|
|
}
|
|
WIN32DLL_DEFINE int _mcrypt_get_block_size()
|
|
{
|
|
return 1;
|
|
}
|
|
WIN32DLL_DEFINE int _mcrypt_get_algo_iv_size()
|
|
{
|
|
#ifdef USE_IV
|
|
return 32;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
WIN32DLL_DEFINE int _is_block_algorithm()
|
|
{
|
|
return 0;
|
|
}
|
|
WIN32DLL_DEFINE int _mcrypt_get_key_size()
|
|
{
|
|
return 32;
|
|
}
|
|
|
|
static const int key_sizes[] = { 32 };
|
|
WIN32DLL_DEFINE const int *_mcrypt_get_supported_key_sizes(int *len)
|
|
{
|
|
*len = sizeof(key_sizes)/sizeof(int);
|
|
return key_sizes;
|
|
}
|
|
|
|
WIN32DLL_DEFINE const char *_mcrypt_get_algorithms_name()
|
|
{
|
|
return "WAKE";
|
|
}
|
|
|
|
#define CIPHER "434d575db053acfe6e4076f05298bedbd5f4f000be555d029b1367cffc7cd51bba61c76aa17da3530fb7d9"
|
|
|
|
WIN32DLL_DEFINE int _mcrypt_self_test()
|
|
{
|
|
unsigned char *keyword;
|
|
unsigned char plaintext[43];
|
|
unsigned char ciphertext[43];
|
|
int blocksize = 43, j;
|
|
void *key, *key2;
|
|
unsigned char cipher_tmp[200];
|
|
|
|
keyword = calloc(1, _mcrypt_get_key_size());
|
|
for (j = 0; j < _mcrypt_get_key_size(); j++) {
|
|
keyword[j] = (j * 5 + 10) & 0xff;
|
|
}
|
|
|
|
for (j = 0; j < blocksize; j++) {
|
|
plaintext[j] = (j + 5) % 0xff;
|
|
}
|
|
key = malloc(_mcrypt_get_size());
|
|
key2 = malloc(_mcrypt_get_size());
|
|
|
|
memcpy(ciphertext, plaintext, blocksize);
|
|
|
|
_mcrypt_set_key(key, (void *) keyword, _mcrypt_get_key_size(),
|
|
NULL, 0);
|
|
_mcrypt_encrypt(key, (void *) ciphertext, blocksize);
|
|
free(key);
|
|
|
|
for (j = 0; j < blocksize; j++) {
|
|
sprintf(&((char *) cipher_tmp)[2 * j], "%.2x",
|
|
ciphertext[j]);
|
|
}
|
|
|
|
if (strcmp((char *) cipher_tmp, CIPHER) != 0) {
|
|
printf("failed compatibility\n");
|
|
printf("Expected: %s\nGot: %s\n", CIPHER,
|
|
(char *) cipher_tmp);
|
|
free(key);
|
|
free(key2);
|
|
return -1;
|
|
}
|
|
_mcrypt_set_key(key2, (void *) keyword, _mcrypt_get_key_size(),
|
|
NULL, 0);
|
|
free(keyword);
|
|
|
|
_mcrypt_decrypt(key2, (void *) ciphertext, blocksize);
|
|
free(key2);
|
|
|
|
if (memcmp(ciphertext, plaintext, blocksize) != 0) {
|
|
printf("failed internally\n");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
WIN32DLL_DEFINE word32 _mcrypt_algorithm_version()
|
|
{
|
|
return 20010801;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
# ifdef USE_LTDL
|
|
WIN32DLL_DEFINE int main (void)
|
|
{
|
|
/* empty main function to avoid linker error (see cygwin FAQ) */
|
|
}
|
|
# endif
|
|
#endif
|