sapphire.h

各种加密算法的源代码

#ifndef SAPPHIRE_H
#define SAPPHIRE_H

#include "cryptlib.h"
#include "misc.h"

class SapphireBase
{
public:
    enum {KEYLENGTH=16};    // default key length

protected:
    SapphireBase();
    SapphireBase(const byte *userKey, unsigned int keyLength);
    ~SapphireBase();

    inline void ShuffleCards()
    {
        ratchet += cards[rotor++];
        byte swaptemp = cards[last_cipher];
        cards[last_cipher] = cards[ratchet];
        cards[ratchet] = cards[last_plain];
        cards[last_plain] = cards[rotor];
        cards[rotor] = swaptemp;
        avalanche += cards[swaptemp];
    }

    // These variables comprise the state of the state machine.

    byte *const cards;              // A permutation of 0-255.
    byte rotor,                     // Index that rotates smoothly
         ratchet,                   // Index that moves erratically
         avalanche,                 // Index heavily data dependent
         last_plain,                // Last plain text byte
         last_cipher;               // Last cipher text byte

private:
    byte keyrand(int limit, const byte *user_key,
                          byte keysize,
                          byte *rsum,
                          unsigned *keypos);
};

class SapphireEncryption : public StreamCipher, protected SapphireBase
{
public:
    SapphireEncryption(const byte *userKey, unsigned int keyLength=KEYLENGTH)
        : SapphireBase(userKey, keyLength) {}

    inline byte ProcessByte(byte b)
    {
        ShuffleCards();
        last_cipher = b^cards[(cards[ratchet] + cards[rotor]) & 0xFF] ^
                      cards[cards[(cards[last_plain] +
                                   cards[last_cipher] +
                                   cards[avalanche])&0xFF]];
        last_plain = b;
        return last_cipher;
    }

    void ProcessString(byte *outString, const byte *inString, unsigned int length);
    void ProcessString(byte *inoutString, unsigned int length);

protected:
    SapphireEncryption() {}     // for SapphireHash
};

class SapphireDecryption : public StreamCipher, private SapphireBase
{
public:
    SapphireDecryption(const byte *userKey, unsigned int keyLength=KEYLENGTH)
        : SapphireBase(userKey, keyLength) {}

    inline byte ProcessByte(byte b)
    {
        ShuffleCards();
        last_plain = b^cards[(cards[ratchet] + cards[rotor]) & 0xFF] ^
                       cards[cards[(cards[last_plain] +
                                    cards[last_cipher] +
                                    cards[avalanche])&0xFF]];
        last_cipher = b;
        return last_plain;
    }

    void ProcessString(byte *outString, const byte *inString, unsigned int length);
    void ProcessString(byte *inoutString, unsigned int length);
};

class SapphireRNG : public RandomNumberGenerator, private SapphireEncryption
{
public:
    SapphireRNG(const byte *seed, unsigned int seedLength)
        : SapphireEncryption(seed, seedLength) {}

    inline byte GetByte() {return SapphireEncryption::ProcessByte(0);}
};

class SapphireHash : public HashModule, private SapphireEncryption
{
public:
    SapphireHash(unsigned int hashLength=20);
    void Update(const byte *input, unsigned int length);
    void Final(byte *hash) {Final(hash, hashLength);}
    void Final(byte *hash, unsigned int overrideHashLength);
    int DigestSize() const {return hashLength;}

private:
    const unsigned int hashLength;
};

#endif