Fast Simple Secure Encryption Routine

Introduction

This Crypt routine uses an algorithm created by Rodney Thayer. This algorithm can use keys of various sizes. With a 40-bit key (5 characters) it can be freely exported from the U.S. The cipher is considered robust with 128 bits of key material but can use up to 2048 bits. It is compatible with RSA’s RC4 algorithm.

void Crypt(TCHAR *inp, DWORD inplen, TCHAR* key = "", DWORD keylen = 0)
{
    //we will consider size of sbox 256 bytes

    //(extra byte are only to prevent any mishep just in case)

    TCHAR Sbox[257], Sbox2[257];
    unsigned long i, j, t, x;

    //this unsecured key is to be used only when there is no input key from user

    static const TCHAR  OurUnSecuredKey[] = "www.systweak.com" ;
    static const int OurKeyLen = _tcslen(OurUnSecuredKey);    
    TCHAR temp , k;
    i = j = k = t =  x = 0;
    temp = 0;

    //always initialize the arrays with zero

    ZeroMemory(Sbox, sizeof(Sbox));
    ZeroMemory(Sbox2, sizeof(Sbox2));

    //initialize sbox i

    for(i = 0; i < 256U; i++)
    {
        Sbox[i] = (TCHAR)i;
    }

    j = 0;
    //whether user has sent any inpur key

    if(keylen)
    {
        //initialize the sbox2 with user key

        for(i = 0; i < 256U ; i++)
        {
            if(j == keylen)
            {
                j = 0;
            }
            Sbox2[i] = key[j++];
        }    
    }
    else
    {
        //initialize the sbox2 with our key

        for(i = 0; i < 256U ; i++)
        {
            if(j == OurKeyLen)
            {
                j = 0;
            }
            Sbox2[i] = OurUnSecuredKey[j++];
        }
    }

    j = 0 ; //Initialize j

    //scramble sbox1 with sbox2

    for(i = 0; i < 256; i++)
    {
        j = (j + (unsigned long) Sbox[i] + (unsigned long) Sbox2[i]) % 256U ;
        temp =  Sbox[i];                    
        Sbox[i] = Sbox[j];
        Sbox[j] =  temp;
    }

    i = j = 0;
    for(x = 0; x < inplen; x++)
    {
        //increment i

        i = (i + 1U) % 256U;
        //increment j

        j = (j + (unsigned long) Sbox[i]) % 256U;

        //Scramble SBox #1 further so encryption routine will

        //will repeat itself at great interval

        temp = Sbox[i];
        Sbox[i] = Sbox[j] ;
        Sbox[j] = temp;

        //Get ready to create pseudo random  byte for encryption key

        t = ((unsigned long) Sbox[i] + (unsigned long) Sbox[j]) %  256U ;

        //get the random byte

        k = Sbox[t];

        //xor with the data and done

        inp[x] = (inp[x] ^ k);
    }    
}

The only moral here is that we are generating a 256 bit key given from the user. To encrypt we always pick a random byte from the key and encrypt the text with that key. If we have a large pattern of repeating text with this algorithm the key repeat interval (distance between n repetitions) will be approximately of 2¹⁷⁰⁰ (2 to the 1700th power).

For very good security I recommend using 128 bits (16 characters) of key material. If you want optimal security you could use 2048 bits (256 characters) of key material (but this is usually considered an overkill).

This routine is constructed from a draft taken from Internet Engineering Task Force (IETF) at http://www.ietf.cnri.reston.va.us/home.htm

I have tested the routine on a 27 MB file to test that it produce valid decrypted output from input and get the valid results.

Using this routine it is fairly simple.

//to encrypt a text

TCHAR HelloCrypt[] = "Hello Crypt";

//we do not enter the key so we will be using default key provide by the crypt 

//routine

Crypt(HelloCrypt, _tcslen(HelloCrypt));

//now to decrypt

Crypt(HelloCrypt, _tcslen(HelloCrypt));

////////////////////////////////////////////////////////////////////////////////

//if we have to supply a key we have to use crypt as follows

TCHAR Data[] = "abcdefghijklmnopqrstuvwxyz"
TCHAR Key[] = "Strong key";

//Encrypt

Crypt(Data, _tcslen(Data), Key, _tcslen(Data));

//Decrypt

Crypt(Data, _tcslen(Data), Key, _tcslen(Data));
/////////////////////////////////////////////////////////////////////////////


//thats all

Please visit My Web Site for more tutorials, tweaks, reference.