rc4.cpp

RSA C++源代码DEMO,附加DESMD5等众多算法

/*************************************************************************
**                                                                      **
**  RC4.cxx                                                             **
**                                                                      **
**  RIVEST CIPHER FOUR (RC4) RANDOM NUMBER GENERATOR AND STREAM CIPHER  **
**                                                                      **
**  Copyright (c)1996 Markku-Juhani O. Saarinen <[e-mail]>      **
**                                                                      **
*************************************************************************/

#include "rc4.h"

#include <string.h>
#include <time.h>

TRC4::TRC4()
{
    static struct {
        unsigned long       counter;
        clock_t             clock;
#ifdef _OS_LINUX_
        struct timeval      tv;
        struct timezone     tz;
        struct sysinfo      info; 
#endif
#ifdef _OS_DOS_
		struct tm *         new_time;
		time_t              long_time;
		struct tm			tmbuf;
#endif
    } randseed;

    // init

    randseed.counter++;
	randseed.clock = clock();

#ifdef _OS_LINUX_
    gettimeofday(&randseed.tv, &randseed.tz);
	sysinfo(&randseed.info);
#endif
#ifdef _OS_DOS_
	time(&randseed.long_time);
	randseed.new_time = localtime(&randseed.long_time);
	memcpy((char *)&(randseed.tmbuf),(char *)(&randseed.new_time),
		sizeof(struct tm));
#endif

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

    // clear
    
    vbzero((void *) &randseed, sizeof(randseed) );
}

// konstruktori annetulla avaimella

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

// destruktori

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

// create init randseed

void TRC4::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;
}

// equal operation

TRC4& TRC4::operator= (TRC4& 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;
}

// crypt/decrypt block

void TRC4::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];
    }
}

void TRC4::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];
    }
}

extern "C" {

void  RC4(char *key,short kl, char *data,short dl )
{
    TRC4 rc4;

    rc4.init((unsigned char *)key,kl);
    rc4.crypt((unsigned char *)data,dl);
}

}