/*************************************************************************
**                                                                      **
**  rc4.cxx                                                             **
**                                                                      **
**  RIVEST CIPHER FOUR (RC4) RANDOM NUMBER GENERATOR AND STREAM CIPHER  **
**                                                                      **
**  Copyright (c)1996 Markku-Juhani O. Saarinen <mjos@math.jyu.fi>      **
**                                                                      **
*************************************************************************/

#include "rc4.h"

#include <string.h>
#include <time.h>
#include <linux/sys.h>
#include <linux/kernel.h>

// konstruktori; alustetaan RC4 satunnaisella avaimella

rc4::rc4()
{
    static struct {
        unsigned long       counter;
        clock_t             clock;
        struct timeval      tv;
        struct timezone     tz;
        struct sysinfo      info;   
        char                *memadr;
    } randseed;

    // alustetaan satunnaissiemenluku

    randseed.counter++;
    gettimeofday(&randseed.tv, &randseed.tz); 
    randseed.clock = clock();
    sysinfo(&randseed.info);
    randseed.memadr = new char[123];
    delete randseed.memadr;

    init( (unsigned char *) &randseed, sizeof(randseed) );

    // nollataan mahdolliset jäänteet muistista
    
    bzero((void *) &randseed, sizeof(randseed) );
}

// konstruktori annetulla avaimella

rc4::rc4(unsigned char *key, int keylen)
{
    init(key, keylen);
}

// destruktori

rc4::~rc4()
{
    int i;
    
    for(i=0; i<256; i++)
        S[i] = 0;
    rc4_i = 0;
    rc4_j = 0;
}

// alustetaan RC4 annetulla avaimella

void rc4::init (unsigned char *key, int keylen)
{
    int     i, j;
    unsigned char t;
    
    for(i=0; i<0x100; i++)
        S[i] = i;
    
    for(i=0, j=0; i<0x100; i++)
    {
        j = (j + S[i] + key[i % keylen]) & 0xff;
        t = S[i];
        S[i] = S[j];
        S[j] = t;
    }
    
    rc4_i = 0;
    rc4_j = 0;
}

// sijoitusoperaattori

rc4& rc4::operator= (rc4& other)
{
    int i;
    for(i=0; i<256; i++)
        this->S[i] = other.S[i];
    this->rc4_i = other.rc4_i;
    this->rc4_j = other.rc4_j;

    return *this;
}

// kryptaa/dekryptaa blokin

void rc4::crypt(unsigned char *pt, size_t l)
{
    register unsigned char Si, Sj;
    register unsigned long i;

    for(i=0; i<l; i++)
    {
        rc4_i = (rc4_i+1) & 0xff;
        Si = S[rc4_i];
        rc4_j = (rc4_j+Si) & 0xff;
        Sj = S[rc4_j];
        S[rc4_i] = Sj;
        S[rc4_j] = Si;

        pt[i] ^= S[(Si + Sj) & 0xff];
    }
}

// tuottaa satunnaistavuja l kpl muistiosoitteeseen pt

void rc4::rand(unsigned char *pt, size_t l)
{
    register unsigned char Si, Sj;
    register unsigned long i;

    for(i=0; i<l; i++)
    {
        rc4_i = (rc4_i+1) & 0xff;
        Si = S[rc4_i];
        rc4_j = (rc4_j+Si) & 0xff;
        Sj = S[rc4_j];
        S[rc4_i] = Sj;
        S[rc4_j] = Si;

        pt[i] = S[(Si + Sj) & 0xff];
    }
}