Криптоалгоритм: исходник не компилируется

/********************************************************************
 
Daginda - experimental software symmetric block cipher
 
Runs with 512..2048 bit key and 256 bit block.
 
Edition 1.0 dated: 21.03.2009
 
(C) 2009 Alexander Myasnikov, public domain
 
Web: [url]www.alexanderwdark.narod.ru[/url]
 
********************************************************************/
 
#include <stdlib.h>
#include <string.h>
 
#ifdef PRNG_TEST
#include <stdio.h>
#endif
 
typedef unsigned char u8;
typedef unsigned long u32;
typedef unsigned short u16;
 
/************** Full key size 256 - 4096 ***************************/
#define keysizebits  512
/*******************************************************************/
 
static const u32 keysizebytes = keysizebits / 8;
static const u32 keysize = keysizebytes / 4;
 
/************** Sbox type 1 - 7 ************************************/
#define sizeshift 4
/*******************************************************************/
 
/************** How to shift in F function  ************************/
#define SHLVAL 6
#define SHRVAL 8
/*******************************************************************/
 
/************** Optimal constants for key expand  ******************/
#define delta  0xb7e15163
#define cdelta 0x9e3779b9
/*******************************************************************/
 
/************** How to expand key **********************************/
#define USE_EXTRA_KS
/*******************************************************************/
 
 
#define rounds 64
 
static const u32 sboxsize = (2 << sizeshift);
 
#include "sbox.h"
 
#define ROL(x,y) _lrotl((x), (y))
#define ROR(x,y) _lrotr((x), (y))
 
#define subst(x,a,b,c,d, r) (ROL((sbox[a][(x) >> 24 & 255] << 24 | sbox[b][(x) >> 16 & 255] << 16 |  sbox[c][(x) >> 8 & 255] << 8 | sbox[d][(x) & 255]),(r)))
 
#define BSWAP(x) (((x) << 16) | ((x) >> 16))
 
#define FQ(x, y) ((x ^ y) + ((x << SHLVAL) ^ (x >> SHRVAL)))
#define F(x) (BSWAP(x) + ((x << SHLVAL) ^ (x >> SHRVAL)))
#define byte(x,n)   ((u8)((x) >> (8 * n)))
 
u32 roundkeys[rounds], _roundkeys[rounds];
 
u32 rawkey[16];
 
 
void __stdcall
setup (u32 * key)
{
 
#ifdef USE_EXTRA_KS
    u8 *subkeys = (u8 *) & roundkeys[0];
    u8 *material = (u8 *) & _roundkeys[0];
    u8 tmp;
#endif
 
    u32 cnt = delta, kcnt = cdelta, i, n;
    u32 rk[keysize];
 
 
    for (i = 0; i != keysize; i++)
    {
        rk[i] = key[i];
    }
 
    for (i = 0; i != rounds; i++)
    {
 
        _roundkeys[i] = rk[i % keysize];
        kcnt += rk[i % keysize] + cdelta;
        _roundkeys[i] += cnt;
        _roundkeys[i] =
            subst (_roundkeys[i], i % sboxsize, cnt % sboxsize,
            _roundkeys[i] % sboxsize, kcnt % sboxsize, 11);
        kcnt += _roundkeys[i];
        _roundkeys[i] = F (_roundkeys[i]) + rk[i % keysize];
        _roundkeys[i] =
            subst (_roundkeys[i], kcnt % sboxsize, _roundkeys[i] % sboxsize,
            cnt % sboxsize, i % sboxsize, 11);
        kcnt += _roundkeys[i];
        cnt += delta;
 
    }
 
#ifdef USE_EXTRA_KS
 
    cnt = 0;
 
    for (n = 0; n != rounds >> 6; n++)
    {
 
        for (i = 0; i != 256; i++)
        {
            subkeys[i] = i;
        }
 
        for (i = 0; i != 768; i++)
        {
            cnt = subkeys[(cnt + subkeys[i & 0xff] + material[i % 256]) & 0xff];
            tmp = subkeys[i & 0xff];
            subkeys[i & 0xff] = subkeys[cnt & 0xff];
            subkeys[cnt & 0xff] = tmp;
        }
 
        subkeys += 0x100;
        material += 0x100;
    }
 
#else
 
    for (i = 0; i != rounds; i++)
    {
 
        roundkeys[i] = _roundkeys[i];
    }
 
#endif
 
 
 
    for (i = 0; i != 16; i++)
    {
        rawkey[i] = rk[i];
    }
 
    if (keysize >= 32)
 
    {
        for (i = 16; i != 32; i++)
 
        {
 
            rawkey[i % 16] += rk[i];
 
        }
 
    }
 
    if (keysize > 32)
 
    {
        for (i = 32; i != keysize; i++)
 
        {
 
            rawkey[i % 16] ^= rk[i];
 
        }
    }
 
 
}
 
 
#define SHR(x,n) ( (x) >> n)
 
#define S0(x) (ROR(x, 7) ^ ROR(x,18) ^  SHR(x, 3))
#define S1(x) (ROR(x,17) ^ ROR(x,19) ^  SHR(x,10))
 
#define S2(x) (ROR(x, 2) ^ ROR(x,13) ^ ROR(x,22))
#define S3(x) (ROR(x, 6) ^ ROR(x,11) ^ ROR(x,25))
 
#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))
 
#define P(a,b,c,d,e,f,g,h,x,K)  temp1 = h + S3(e) + F1(e,f,g) + K + x;  temp2 = S2(a) + F0(a,b,c);  d += temp1; h = temp1 + temp2;
#define R(a,b,c,d,e,f,g,h,x,K)  temp2 = S2(a) + F0(a,b,c);  h -= temp2; d -= h;  h -= S3(e) + F1(e,f,g) + K + x;
 
 
 
void __stdcall
crypt (u32 * data)
{
 
    u32 temp1, temp2;
    u32 A, B, C, D, E, F, G, H;
 
    A = data[0] + rawkey[0];
    B = data[1] + rawkey[1];
    C = data[2] + rawkey[2];
    D = data[3] + rawkey[3];
    E = data[4] + rawkey[4];
    F = data[5] + rawkey[5];
    G = data[6] + rawkey[6];
    H = data[7] + rawkey[7];
 
    P (A, B, C, D, E, F, G, H, roundkeys[0], 0x428A2F98);
    P (H, A, B, C, D, E, F, G, roundkeys[1], 0x71374491);
    P (G, H, A, B, C, D, E, F, roundkeys[2], 0xB5C0FBCF);
    P (F, G, H, A, B, C, D, E, roundkeys[3], 0xE9B5DBA5);
    P (E, F, G, H, A, B, C, D, roundkeys[4], 0x3956C25B);
    P (D, E, F, G, H, A, B, C, roundkeys[5], 0x59F111F1);
    P (C, D, E, F, G, H, A, B, roundkeys[6], 0x923F82A4);
    P (B, C, D, E, F, G, H, A, roundkeys[7], 0xAB1C5ED5);
    P (A, B, C, D, E, F, G, H, roundkeys[8], 0xD807AA98);
    P (H, A, B, C, D, E, F, G, roundkeys[9], 0x12835B01);
    P (G, H, A, B, C, D, E, F, roundkeys[10], 0x243185BE);
    P (F, G, H, A, B, C, D, E, roundkeys[11], 0x550C7DC3);
    P (E, F, G, H, A, B, C, D, roundkeys[12], 0x72BE5D74);
    P (D, E, F, G, H, A, B, C, roundkeys[13], 0x80DEB1FE);
    P (C, D, E, F, G, H, A, B, roundkeys[14], 0x9BDC06A7);
    P (B, C, D, E, F, G, H, A, roundkeys[15], 0xC19BF174);
    P (A, B, C, D, E, F, G, H, roundkeys[16], 0xE49B69C1);
    P (H, A, B, C, D, E, F, G, roundkeys[17], 0xEFBE4786);
    P (G, H, A, B, C, D, E, F, roundkeys[18], 0x0FC19DC6);
    P (F, G, H, A, B, C, D, E, roundkeys[19], 0x240CA1CC);
    P (E, F, G, H, A, B, C, D, roundkeys[20], 0x2DE92C6F);
    P (D, E, F, G, H, A, B, C, roundkeys[21], 0x4A7484AA);
    P (C, D, E, F, G, H, A, B, roundkeys[22], 0x5CB0A9DC);
    P (B, C, D, E, F, G, H, A, roundkeys[23], 0x76F988DA);
    P (A, B, C, D, E, F, G, H, roundkeys[24], 0x983E5152);
    P (H, A, B, C, D, E, F, G, roundkeys[25], 0xA831C66D);
    P (G, H, A, B, C, D, E, F, roundkeys[26], 0xB00327C8);
    P (F, G, H, A, B, C, D, E, roundkeys[27], 0xBF597FC7);
    P (E, F, G, H, A, B, C, D, roundkeys[28], 0xC6E00BF3);
    P (D, E, F, G, H, A, B, C, roundkeys[29], 0xD5A79147);
    P (C, D, E, F, G, H, A, B, roundkeys[30], 0x06CA6351);
    P (B, C, D, E, F, G, H, A, roundkeys[31], 0x14292967);
    P (A, B, C, D, E, F, G, H, roundkeys[32], 0x27B70A85);
    P (H, A, B, C, D, E, F, G, roundkeys[33], 0x2E1B2138);
    P (G, H, A, B, C, D, E, F, roundkeys[34], 0x4D2C6DFC);
    P (F, G, H, A, B, C, D, E, roundkeys[35], 0x53380D13);
    P (E, F, G, H, A, B, C, D, roundkeys[36], 0x650A7354);
    P (D, E, F, G, H, A, B, C, roundkeys[37], 0x766A0ABB);
    P (C, D, E, F, G, H, A, B, roundkeys[38], 0x81C2C92E);
    P (B, C, D, E, F, G, H, A, roundkeys[39], 0x92722C85);
    P (A, B, C, D, E, F, G, H, roundkeys[40], 0xA2BFE8A1);
    P (H, A, B, C, D, E, F, G, roundkeys[41], 0xA81A664B);
    P (G, H, A, B, C, D, E, F, roundkeys[42], 0xC24B8B70);
    P (F, G, H, A, B, C, D, E, roundkeys[43], 0xC76C51A3);
    P (E, F, G, H, A, B, C, D, roundkeys[44], 0xD192E819);
    P (D, E, F, G, H, A, B, C, roundkeys[45], 0xD6990624);
    P (C, D, E, F, G, H, A, B, roundkeys[46], 0xF40E3585);
    P (B, C, D, E, F, G, H, A, roundkeys[47], 0x106AA070);
    P (A, B, C, D, E, F, G, H, roundkeys[48], 0x19A4C116);
    P (H, A, B, C, D, E, F, G, roundkeys[49], 0x1E376C08);
    P (G, H, A, B, C, D, E, F, roundkeys[50], 0x2748774C);
    P (F, G, H, A, B, C, D, E, roundkeys[51], 0x34B0BCB5);
    P (E, F, G, H, A, B, C, D, roundkeys[52], 0x391C0CB3);
    P (D, E, F, G, H, A, B, C, roundkeys[53], 0x4ED8AA4A);
    P (C, D, E, F, G, H, A, B, roundkeys[54], 0x5B9CCA4F);
    P (B, C, D, E, F, G, H, A, roundkeys[55], 0x682E6FF3);
    P (A, B, C, D, E, F, G, H, roundkeys[56], 0x748F82EE);
    P (H, A, B, C, D, E, F, G, roundkeys[57], 0x78A5636F);
    P (G, H, A, B, C, D, E, F, roundkeys[58], 0x84C87814);
    P (F, G, H, A, B, C, D, E, roundkeys[59], 0x8CC70208);
    P (E, F, G, H, A, B, C, D, roundkeys[60], 0x90BEFFFA);
    P (D, E, F, G, H, A, B, C, roundkeys[61], 0xA4506CEB);
    P (C, D, E, F, G, H, A, B, roundkeys[62], 0xBEF9A3F7);
    P (B, C, D, E, F, G, H, A, roundkeys[63], 0xC67178F2);
 
    data[0] = A ^ rawkey[8];
    data[1] = B ^ rawkey[9];
    data[2] = C ^ rawkey[10];
    data[3] = D ^ rawkey[11];
    data[4] = E ^ rawkey[12];
    data[5] = F ^ rawkey[13];
    data[6] = G ^ rawkey[14];
    data[7] = H ^ rawkey[15];
 
}
 
 
void __stdcall
decrypt (u32 * data)
{
    u32 temp1, temp2;
    u32 A, B, C, D, E, F, G, H;
 
    A = data[0] ^ rawkey[8];
    B = data[1] ^ rawkey[9];
    C = data[2] ^ rawkey[10];
    D = data[3] ^ rawkey[11];
    E = data[4] ^ rawkey[12];
    F = data[5] ^ rawkey[13];
    G = data[6] ^ rawkey[14];
    H = data[7] ^ rawkey[15];
 
    R (B, C, D, E, F, G, H, A, roundkeys[63], 0xC67178F2);
    R (C, D, E, F, G, H, A, B, roundkeys[62], 0xBEF9A3F7);
    R (D, E, F, G, H, A, B, C, roundkeys[61], 0xA4506CEB);
    R (E, F, G, H, A, B, C, D, roundkeys[60], 0x90BEFFFA);
    R (F, G, H, A, B, C, D, E, roundkeys[59], 0x8CC70208);
    R (G, H, A, B, C, D, E, F, roundkeys[58], 0x84C87814);
    R (H, A, B, C, D, E, F, G, roundkeys[57], 0x78A5636F);
    R (A, B, C, D, E, F, G, H, roundkeys[56], 0x748F82EE);
    R (B, C, D, E, F, G, H, A, roundkeys[55], 0x682E6FF3);
    R (C, D, E, F, G, H, A, B, roundkeys[54], 0x5B9CCA4F);
    R (D, E, F, G, H, A, B, C, roundkeys[53], 0x4ED8AA4A);
    R (E, F, G, H, A, B, C, D, roundkeys[52], 0x391C0CB3);
    R (F, G, H, A, B, C, D, E, roundkeys[51], 0x34B0BCB5);
    R (G, H, A, B, C, D, E, F, roundkeys[50], 0x2748774C);
    R (H, A, B, C, D, E, F, G, roundkeys[49], 0x1E376C08);
    R (A, B, C, D, E, F, G, H, roundkeys[48], 0x19A4C116);
    R (B, C, D, E, F, G, H, A, roundkeys[47], 0x106AA070);
    R (C, D, E, F, G, H, A, B, roundkeys[46], 0xF40E3585);
    R (D, E, F, G, H, A, B, C, roundkeys[45], 0xD6990624);
    R (E, F, G, H, A, B, C, D, roundkeys[44], 0xD192E819);
    R (F, G, H, A, B, C, D, E, roundkeys[43], 0xC76C51A3);
    R (G, H, A, B, C, D, E, F, roundkeys[42], 0xC24B8B70);
    R (H, A, B, C, D, E, F, G, roundkeys[41], 0xA81A664B);
    R (A, B, C, D, E, F, G, H, roundkeys[40], 0xA2BFE8A1);
    R (B, C, D, E, F, G, H, A, roundkeys[39], 0x92722C85);
    R (C, D, E, F, G, H, A, B, roundkeys[38], 0x81C2C92E);
    R (D, E, F, G, H, A, B, C, roundkeys[37], 0x766A0ABB);
    R (E, F, G, H, A, B, C, D, roundkeys[36], 0x650A7354);
    R (F, G, H, A, B, C, D, E, roundkeys[35], 0x53380D13);
    R (G, H, A, B, C, D, E, F, roundkeys[34], 0x4D2C6DFC);
    R (H, A, B, C, D, E, F, G, roundkeys[33], 0x2E1B2138);
    R (A, B, C, D, E, F, G, H, roundkeys[32], 0x27B70A85);
    R (B, C, D, E, F, G, H, A, roundkeys[31], 0x14292967);
    R (C, D, E, F, G, H, A, B, roundkeys[30], 0x06CA6351);
    R (D, E, F, G, H, A, B, C, roundkeys[29], 0xD5A79147);
    R (E, F, G, H, A, B, C, D, roundkeys[28], 0xC6E00BF3);
    R (F, G, H, A, B, C, D, E, roundkeys[27], 0xBF597FC7);
    R (G, H, A, B, C, D, E, F, roundkeys[26], 0xB00327C8);
    R (H, A, B, C, D, E, F, G, roundkeys[25], 0xA831C66D);
    R (A, B, C, D, E, F, G, H, roundkeys[24], 0x983E5152);
    R (B, C, D, E, F, G, H, A, roundkeys[23], 0x76F988DA);
    R (C, D, E, F, G, H, A, B, roundkeys[22], 0x5CB0A9DC);
    R (D, E, F, G, H, A, B, C, roundkeys[21], 0x4A7484AA);
    R (E, F, G, H, A, B, C, D, roundkeys[20], 0x2DE92C6F);
    R (F, G, H, A, B, C, D, E, roundkeys[19], 0x240CA1CC);
    R (G, H, A, B, C, D, E, F, roundkeys[18], 0x0FC19DC6);
    R (H, A, B, C, D, E, F, G, roundkeys[17], 0xEFBE4786);
    R (A, B, C, D, E, F, G, H, roundkeys[16], 0xE49B69C1);
    R (B, C, D, E, F, G, H, A, roundkeys[15], 0xC19BF174);
    R (C, D, E, F, G, H, A, B, roundkeys[14], 0x9BDC06A7);
    R (D, E, F, G, H, A, B, C, roundkeys[13], 0x80DEB1FE);
    R (E, F, G, H, A, B, C, D, roundkeys[12], 0x72BE5D74);
    R (F, G, H, A, B, C, D, E, roundkeys[11], 0x550C7DC3);
    R (G, H, A, B, C, D, E, F, roundkeys[10], 0x243185BE);
    R (H, A, B, C, D, E, F, G, roundkeys[9], 0x12835B01);
    R (A, B, C, D, E, F, G, H, roundkeys[8], 0xD807AA98);
    R (B, C, D, E, F, G, H, A, roundkeys[7], 0xAB1C5ED5);
    R (C, D, E, F, G, H, A, B, roundkeys[6], 0x923F82A4);
    R (D, E, F, G, H, A, B, C, roundkeys[5], 0x59F111F1);
    R (E, F, G, H, A, B, C, D, roundkeys[4], 0x3956C25B);
    R (F, G, H, A, B, C, D, E, roundkeys[3], 0xE9B5DBA5);
    R (G, H, A, B, C, D, E, F, roundkeys[2], 0xB5C0FBCF);
    R (H, A, B, C, D, E, F, G, roundkeys[1], 0x71374491);
    R (A, B, C, D, E, F, G, H, roundkeys[0], 0x428A2F98);
 
    data[0] = A - rawkey[0];
    data[1] = B - rawkey[1];
    data[2] = C - rawkey[2];
    data[3] = D - rawkey[3];
    data[4] = E - rawkey[4];
    data[5] = F - rawkey[5];
    data[6] = G - rawkey[6];
    data[7] = H - rawkey[7];
 
}
 
 
#ifdef PRNG_TEST
 
u32 buf[8] =
{ 0xC4A60B29, 0x1DF6907A, 0xE5F8D137, 0x86C02E59, 0x18286078, 0x13354c5f,
0x060a181e, 0x809d3aba
};
u32 cbuf[8] =
{ 0xBFE60D0F, 0x7CCB60D6, 0x326A9747, 0x17EE621F, 0x704b7393, 0xdd31d176,
0x15c74369, 0xa9815b14
};
u32 key[16] =
{ 0x58819022, 0xAC3F8B9D, 0x9CEDAECB, 0x89EA9D3D, 0xB43CD725, 0xF04F4E02,
0x12DF1FF7, 0xDBED2295, 0x9140703B, 0x63C99153, 0x786F5204, 0xF1DEA408,
0x3BE2517F, 0xEB12063E, 0xBEC1F2A8, 0x3A498DC2
};
 
int
main (int argc, char *argv[])
{
    FILE *f;
    int i, n;
 
    if (argc < 2)
    {
        fprintf (stderr, "usage: %s <output filename>\n", argv[0]);
        return (1);
    }
    if ((f = fopen (argv[1], "wb+")) == NULL)
    {
        fprintf (stderr, "failed to open '%s' for writing.\n", argv[1]);
        return (1);
    }
 
 
 
    setup (&key[0]);
    for (i = 0; i != 33554431; i++)
    {
 
        crypt (&buf[0]);
 
        for (n = 0; n != 8; n++)
        {
            cbuf[n] ^= buf[n];
        }
 
        fwrite (cbuf, 32, 1, f);
 
 
    }
 
    fclose (f);
    return (0);
}
 
#endif
 
 
u32 __stdcall getblocksize ()
{
    return 256;
}
 
u32 __stdcall getkeysize ()
{
    return keysizebits;
}
 
void __stdcall getciphername (unsigned char *p)
{
strcpy(p, "DAGINDA");
}

void __stdcall getciphername (unsigned char *p)
{
strcpy((char*)p, "DAGINDA");
}