base
This commit is contained in:
biosvos
@@ -0,0 +1,377 @@
|
||||
/*
|
||||
* 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
|
||||
Reference in New Issue
Block a user