PALUBA

DECLARE SUB createiv (outfile!)
DECLARE FUNCTION askmode! ()
DECLARE SUB encrypt (infilename$, outfilename$)
DECLARE SUB decrypt (infilename$, outfilename$)
DECLARE SUB readiv (file!)
DECLARE FUNCTION askinput$ ()
DECLARE FUNCTION askoutput$ ()
DECLARE SUB askkey ()
DECLARE SUB init ()
DECLARE FUNCTION cipher! (byte!)

DIM SHARED state(255) AS INTEGER
DIM SHARED keydata(255) AS INTEGER
DIM SHARED keylength AS INTEGER

infilename$ = askinput
outfilename$ = askoutput
   
IF askmode = 0 THEN
        decrypt infilename$, outfilename$
ELSE
        encrypt infilename$, outfilename$
END IF

FUNCTION askinput$

askinput:
        INPUT "Ulazni fajl: ", tmp$
       
        IF tmp$ = "" THEN
                GOTO askinput
        END IF

        askinput$ = tmp$

END FUNCTION

SUB askkey

enterkey:
        INPUT "Unesi kljuc: ", keystring$

        keylength = LEN(keystring$)
        IF keylength = 0 OR keylength > 246 THEN
                GOTO enterkey
        END IF

        FOR i = 0 TO (keylength - 1)
                keydata(i) = ASC(MID$(keystring$, (i + 1), 1))
        NEXT i

END SUB

FUNCTION askmode

        answer = -1
        PRINT "Enkripcija/Dekripcija [e/d]?"
askmode:
        char$ = INKEY$
        IF char$ = "d" OR char$ = "D" THEN
                answer = 0
        END IF
        IF char$ = "e" OR char$ = "E" THEN
                answer = 1
        END IF

        IF answer = -1 THEN GOTO askmode
        askmode = answer
       
END FUNCTION

FUNCTION askoutput$

askoutput:
        INPUT "Izlazni fajl: ", tmp$

        IF (tmp$ = "") THEN
                GOTO askoutput
        END IF

        askoutput$ = tmp$

END FUNCTION

FUNCTION cipher (byte)

        STATIC i, j
        i = (i + 1) MOD 256
        j = (j + state(i)) MOD 256
        SWAP state(i), state(j)
        n = (state(i) + state(j)) MOD 256
        ret = byte XOR state(n)
        
        cipher = ret

END FUNCTION

SUB createiv (outfile)

        RANDOMIZE TIMER

        FOR i = 0 TO 9
                byte = RND * 256
                keydata(keylength + i) = byte
                PRINT #outfile, CHR$(byte);
        NEXT i
        keylength = keylength + 10

END SUB

SUB decrypt (infilename$, outfilename$)
       
        infile = FREEFILE
        OPEN infilename$ FOR BINARY AS #infile
        outfile = FREEFILE
        OPEN outfilename$ FOR OUTPUT AS #outfile

        askkey
        readiv infile
        init

        DO
                char = ASC(INPUT$(1, #infile))
                cchar = cipher(char)
                PRINT #outfile, CHR$(cchar);
        LOOP UNTIL LOC(infile) = LOF(infile)

        CLOSE infile
        CLOSE outfile

END SUB

SUB encrypt (infilename$, outfilename$)
      
        infile = FREEFILE
        OPEN infilename$ FOR BINARY AS #infile
        outfile = FREEFILE
        OPEN outfilename$ FOR OUTPUT AS #outfile

        askkey
        createiv outfile
        init

        DO
                char = ASC(INPUT$(1, #infile))
                cchar = cipher(char)
                PRINT #outfile, CHR$(cchar);
        LOOP UNTIL LOC(infile) = LOF(infile)

        CLOSE infile
        CLOSE outfile


END SUB

SUB init

        FOR i = 0 TO 255
                state(i) = i
        NEXT i
       
        j = 0
        FOR i = 0 TO 255
                n = i MOD keylength
                j = (j + state(i) + keydata(n)) MOD 256
                SWAP state(i), state(j)
        NEXT i

END SUB

SUB readiv (file)

        FOR i = 0 TO 9
                byte = ASC(INPUT$(1, #file))
                keydata(keylength + i) = byte
        NEXT i
        keylength = keylength + 10

END SUB

#include <string.h>
#include <assert.h>


void rc2_keyschedule( unsigned short xkey[64],
                      const unsigned char *key,
                      unsigned len,
                      unsigned bits )
        {
        unsigned char x;
        unsigned i;
        /* tabela permutacija od 256 elemenata */
        static const unsigned char permute[256] = {
            217,120,249,196, 25,221,181,237, 40,233,253,121, 74,160,216,157,
            198,126, 55,131, 43,118, 83,142, 98, 76,100,136, 68,139,251,162,
             23,154, 89,245,135,179, 79, 19, 97, 69,109,141,  9,129,125, 50,
            189,143, 64,235,134,183,123, 11,240,149, 33, 34, 92,107, 78,130,
             84,214,101,147,206, 96,178, 28,115, 86,192, 20,167,140,241,220,
             18,117,202, 31, 59,190,228,209, 66, 61,212, 48,163, 60,182, 38,
            111,191, 14,218, 70,105,  7, 87, 39,242, 29,155,188,148, 67,  3,
            248, 17,199,246,144,239, 62,231,  6,195,213, 47,200,102, 30,215,
              8,232,234,222,128, 82,238,247,132,170,114,172, 53, 77,106, 42,
            150, 26,210,113, 90, 21, 73,116, 75,159,208, 94,  4, 24,164,236,
            194,224, 65,110, 15, 81,203,204, 36,145,175, 80,161,244,112, 57,
            153,124, 58,133, 35,184,180,122,252,  2, 54, 91, 37, 85,151, 49,
             45, 93,250,152,227,138,146,174,  5,223, 41, 16,103,108,186,201,
            211,  0,230,207,225,158,168, 44, 99, 22,  1, 63, 88,226,137,169,
             13, 56, 52, 27,171, 51,255,176,187, 72, 12, 95,185,177,205, 46,
            197,243,219, 71,229,165,156,119, 10,166, 32,104,254,127,193,173
        };

        assert(len > 0 && len <= 128);
        assert(bits <= 1024);
        if (!bits)
                bits = 1024;

        memcpy(xkey, key, len);

        /* Faza 1: Prosirivanje ulaznog kljuca na 128 bajta */
        if (len < 128) {
                i = 0;
                x = ((unsigned char *)xkey)[len-1];
                do {
                        x = permute[(x + ((unsigned char *)xkey)[i++]) & 255];
                        ((unsigned char *)xkey)[len++] = x;
                } while (len < 128);
        }

        /* Faza 2 - smanjivanje efektivne duzine kljuca */
        len = (bits+7) >> 3;
        i = 128-len;
        x = permute[((unsigned char *)xkey)[i] & (255 >> (7 & -bits))];
        ((unsigned char *)xkey)[i] = x;

        while (i--) {
                x = permute[ x ^ ((unsigned char *)xkey)[i+len] ];
                ((unsigned char *)xkey)[i] = x;
        }

        /* Faza 3 - kopiranje u niz xkey[] u "little-endian" oblik */
        i = 63;
        do {
                xkey[i] =  ((unsigned char *)xkey)[2*i] +
                          (((unsigned char *)xkey)[2*i+1] << 8);
        } while (i--);
        }

/**********************************************************************\
* Enkripcija bloka od 8 bajta upotrebom datog kljuca                                                         *
\**********************************************************************/

void rc2_encrypt( const unsigned short xkey[64],
                  const unsigned char *plain,
                  unsigned char *cipher )
        {
        unsigned x76, x54, x32, x10, i;

        x76 = (plain[7] << 8) + plain[6];
        x54 = (plain[5] << 8) + plain[4];
        x32 = (plain[3] << 8) + plain[2];
        x10 = (plain[1] << 8) + plain[0];

        for (i = 0; i < 16; i++) {
                x10 += (x32 & ~x76) + (x54 & x76) + xkey[4*i+0];
                x10 = (x10 << 1) + (x10 >> 15 & 1);
                
                x32 += (x54 & ~x10) + (x76 & x10) + xkey[4*i+1];
                x32 = (x32 << 2) + (x32 >> 14 & 3);

                x54 += (x76 & ~x32) + (x10 & x32) + xkey[4*i+2];
                x54 = (x54 << 3) + (x54 >> 13 & 7);

                x76 += (x10 & ~x54) + (x32 & x54) + xkey[4*i+3];
                x76 = (x76 << 5) + (x76 >> 11 & 31);

                if (i == 4 || i == 10) {
                        x10 += xkey[x76 & 63];
                        x32 += xkey[x10 & 63];
                        x54 += xkey[x32 & 63];
                        x76 += xkey[x54 & 63];
                }
        }

        cipher[0] = (unsigned char)x10;
        cipher[1] = (unsigned char)(x10 >> 8);
        cipher[2] = (unsigned char)x32;
        cipher[3] = (unsigned char)(x32 >> 8);
        cipher[4] = (unsigned char)x54;
        cipher[5] = (unsigned char)(x54 >> 8);
        cipher[6] = (unsigned char)x76;
        cipher[7] = (unsigned char)(x76 >> 8);
        }

/**********************************************************************\
* Dekripcija bloka od 8 bajta upotrebom datog kljuca                                                         *
\**********************************************************************/

void rc2_decrypt( const unsigned short xkey[64],
                  unsigned char *plain,
                  const unsigned char *cipher )
        {
        unsigned x76, x54, x32, x10, i;

        x76 = (cipher[7] << 8) + cipher[6];
        x54 = (cipher[5] << 8) + cipher[4];
        x32 = (cipher[3] << 8) + cipher[2];
        x10 = (cipher[1] << 8) + cipher[0];

        i = 15;
        do {
                x76 &= 65535;
                x76 = (x76 << 11) + (x76 >> 5);
                x76 -= (x10 & ~x54) + (x32 & x54) + xkey[4*i+3];

                x54 &= 65535;
                x54 = (x54 << 13) + (x54 >> 3);
                x54 -= (x76 & ~x32) + (x10 & x32) + xkey[4*i+2];
                
                x32 &= 65535;
                x32 = (x32 << 14) + (x32 >> 2);
                x32 -= (x54 & ~x10) + (x76 & x10) + xkey[4*i+1];

                x10 &= 65535;
                x10 = (x10 << 15) + (x10 >> 1);
                x10 -= (x32 & ~x76) + (x54 & x76) + xkey[4*i+0];

                if (i == 5 || i == 11) {
                        x76 -= xkey[x54 & 63];
                        x54 -= xkey[x32 & 63];
                        x32 -= xkey[x10 & 63];
                        x10 -= xkey[x76 & 63];
                }
        } while (i--);

        plain[0] = (unsigned char)x10;
        plain[1] = (unsigned char)(x10 >> 8);
        plain[2] = (unsigned char)x32;
        plain[3] = (unsigned char)(x32 >> 8);
        plain[4] = (unsigned char)x54;
        plain[5] = (unsigned char)(x54 >> 8);
        plain[6] = (unsigned char)x76;
        plain[7] = (unsigned char)(x76 >> 8);
        }

#ifndef CRYPTOPP_RC6_H
#define CRYPTOPP_RC6_H

#include "seckey.h"
#include "secblock.h"

NAMESPACE_BEGIN(CryptoPP)

//! _
struct RC6_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 0, 255>, public VariableRounds<20>
{
	static const char *StaticAlgorithmName() {return "RC6";}
	typedef word32 RC6_WORD;
};


class RC6 : public RC6_Info, public BlockCipherDocumentation
{
	class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<RC6_Info>
	{
	public:
		void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs &params);

	protected:
		unsigned int r;       
		SecBlock<RC6_WORD> sTable;  
	};

	class CRYPTOPP_NO_VTABLE Enc : public Base
	{
	public:
		void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
	};

	class CRYPTOPP_NO_VTABLE Dec : public Base
	{
	public:
		void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
	};

public:
	typedef BlockCipherFinal<ENCRYPTION, Enc> Encryption;
	typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
};

typedef RC6::Encryption RC6Encryption;
typedef RC6::Decryption RC6Decryption;

NAMESPACE_END

#endif

#include "pch.h"
#include "rc6.h"
#include "misc.h"
#include "secblock.h"

NAMESPACE_BEGIN(CryptoPP)

void RC6::Base::UncheckedSetKey(const byte *k, unsigned int keylen, const NameValuePairs &params)
{
	AssertValidKeyLength(keylen);

	r = GetRoundsAndThrowIfInvalid(params, this);
	sTable.New(2*(r+2));

	static const RC6_WORD MAGIC_P = 0xb7e15163L;    // magic constant P for wordsize
	static const RC6_WORD MAGIC_Q = 0x9e3779b9L;    // magic constant Q for wordsize
	static const int U=sizeof(RC6_WORD);

	const unsigned int c = STDMAX((keylen+U-1)/U, 1U);	// RC6 paper says c=1 if keylen==0
	SecBlock<RC6_WORD> l(c);

	GetUserKey(LITTLE_ENDIAN_ORDER, l.begin(), c, k, keylen);

	sTable[0] = MAGIC_P;
	for (unsigned j=1; j<sTable.size();j++)
		sTable[j] = sTable[j-1] + MAGIC_Q;

	RC6_WORD a=0, b=0;
	const unsigned n = 3*STDMAX((unsigned int)sTable.size(), c);

	for (unsigned h=0; h < n; h++)
	{
		a = sTable[h % sTable.size()] = rotlFixed((sTable[h % sTable.size()] + a + b), 3);
		b = l[h % c] = rotlMod((l[h % c] + a + b), (a+b));
	}
}

typedef BlockGetAndPut<RC6::RC6_WORD, LittleEndian> Block;

void RC6::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
{
	const RC6_WORD *sptr = sTable;
	RC6_WORD a, b, c, d, t, u;

	Block::Get(inBlock)(a)(b)(c)(d);
	b += sptr[0];
	d += sptr[1];
	sptr += 2;

	for(unsigned i=0; i<r; i++)
	{
		t = rotlFixed(b*(2*b+1), 5);
		u = rotlFixed(d*(2*d+1), 5);
		a = rotlMod(a^t,u) + sptr[0];
		c = rotlMod(c^u,t) + sptr[1];
		t = a; a = b; b = c; c = d; d = t;
		sptr += 2;
	}

	a += sptr[0];
	c += sptr[1];

	Block::Put(xorBlock, outBlock)(a)(b)(c)(d);
}

void RC6::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
{
	const RC6_WORD *sptr = sTable.end();
	RC6_WORD a, b, c, d, t, u;

	Block::Get(inBlock)(a)(b)(c)(d);

	sptr -= 2;
	c -= sptr[1];
	a -= sptr[0];

	for (unsigned i=0; i < r; i++)
	{
		sptr -= 2;
		t = a; a = d; d = c; c = b; b = t;
		u = rotlFixed(d*(2*d+1), 5);
		t = rotlFixed(b*(2*b+1), 5);
		c = rotrMod(c-sptr[1], t) ^ u;
		a = rotrMod(a-sptr[0], u) ^ t;
	}

	sptr -= 2;
	d -= sTable[1];
	b -= sTable[0];

	Block::Put(xorBlock, outBlock)(a)(b)(c)(d);
}

NAMESPACE_END

c = ceiling( max(b, 1) / u )

for i = b-1 down to 0 do:
    L[i/u] = (L[i/u] << 8) + K[i]
     
S[0] = P_w
for i = 1 to t-1 do:
    S[i] = S[i-1] + Q_w
    
i = j = 0
A = B = 0
do 3 * max(t, c) times:
    A = S[i] = (S[i] + A + B) <<< 3
    B = L[j] = (L[j] + A + B) <<< (A + B)
    i = (i + 1) % t
    j = (j + 1) % c

B = B + S[0]
	D = D + S[1]
	for i = 1 to r do
	{
		t = (B*(2B + 1)) <<< lg w
		u = (D*(2D + 1)) <<< lg w
		A = ((A XOR t) <<< u) + S[2i]
		C = ((C XOR u) <<< t) + S[2i + 1] 
                (A, B, C, D)  =  (B, C, D, A)  НАПОМЕНА: Ово је псеудооперација доделе са цикличном заменом вредности

	}
	A = A + S[2r + 2]
	C = C + S[2r + 3]

C = C - S[2r + 3]
	A = A - S[2r + 2]

	for i = r downto 1 do
	{
	   (A, B, C, D) = (D, A, B, C)  Напомена: ово је инверзна псеудооперација доделе са цикличном заменом вредности
	    u = (D*(2D + 1)) <<< lg w
	    t = (B*(2B + 1)) <<< lg w
	    C = ((C - S[2i + 1]) >>> t) XOR u
	    A = ((A - S[2i]) >>> u) XOR t
	}
	D = D - S[1]
	B = B - S[0]