---

dsCypher.h

Go to the documentation of this file.

#ifndef dsCypher_h
#define dsCypher_h
 
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <string.h>

#include <iostream>

#ifdef PalmOS
    typedef  UInt32 dsCypher_word32_t;  
    typedef  UInt16 dsCypher_word16_t;  
    typedef  UInt8  dsCypher_byte_t;    
#else
    typedef unsigned long  dsCypher_word32_t;
    typedef unsigned short dsCypher_word16_t; 
    typedef unsigned char  dsCypher_byte_t;
#endif

#ifdef PalmOS
# define dsCypher_SECTION   __attribute__ ((section ("Crypto")))
#else
# define dsCypher_SECTION  
#endif


class dsCryptoBase
{
protected:

    void memSet (dsCypher_byte_t *ptr,  dsCypher_byte_t pattern, dsCypher_word32_t size );
    void memCopy(dsCypher_byte_t *dest, const dsCypher_byte_t *src,   dsCypher_word32_t size );

    dsCypher_word32_t n2l(const dsCypher_byte_t *c);
    dsCypher_word32_t n2le(const dsCypher_byte_t *c);

    void l2n(dsCypher_word32_t l, dsCypher_byte_t *c );
    void l2ne(dsCypher_word32_t l, dsCypher_byte_t *c );

    void n_n2l (dsCypher_word32_t *dest, const dsCypher_byte_t   *src, dsCypher_word32_t srcLen);
    void n_n2le(dsCypher_word32_t *dest, const dsCypher_byte_t   *src, dsCypher_word32_t srcLen);
    void n_l2n (dsCypher_byte_t   *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen);
    void n_l2ne(dsCypher_byte_t   *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen);
    void n_xor (dsCypher_word32_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t size); 


    dsCypher_word32_t rotl(dsCypher_word32_t x, dsCypher_word32_t n);
    dsCypher_word32_t rotr(dsCypher_word32_t x, dsCypher_word32_t n);


#ifdef WITH_TEST_VECTORS
public:
    virtual const dsCypher_byte_t * testData();
    virtual const dsCypher_word32_t testDataLen();
    virtual const char *testAlgName();
#endif

};

class dsCryptoHash : public dsCryptoBase
{

public:
    virtual void cryptoHash(dsCypher_byte_t *p_digest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen) = 0;
    virtual const dsCypher_word32_t digestSize() = 0;

#ifdef WITH_TEST_VECTORS
    virtual const dsCypher_byte_t * testExpectedResult();
#endif

};


class dsCypher : public dsCryptoBase
{
protected:
    dsCypher_word32_t   _block_size; // sizeof algorithm block, bytes

public:
    enum keyMode{ kmNONE = 0,  kmENCRYPT=0x2, kmDECRYPT=0x4, 
                  kmOFB = kmENCRYPT, kmBOTH=kmENCRYPT | kmDECRYPT};
    
    keyMode _active_key_mode; 


    virtual void setKey(const dsCypher_byte_t *p_key, dsCypher_word32_t p_keyLen, keyMode km) = 0;
            bool ready(){ return _active_key_mode != kmNONE;}

    dsCypher();


#ifdef WITH_TEST_VECTORS
    enum cmMODES{ cmNONE, cmECB, cmCBC, cmOFB };

    static const dsCypher_byte_t ivec[16];

    virtual const dsCypher_byte_t * testKey();
    virtual const dsCypher_word32_t testKeyLen();
    virtual const dsCypher_byte_t * testExpectedResult( cmMODES p_mode );
    virtual const dsCypher_word32_t testExpectedResultLen(cmMODES p_mode);
#endif
};



class dsBlockCypher : public dsCypher
{
public:
    
    virtual void encryptBlock(const dsCypher_word32_t *inBlock, dsCypher_word32_t *outBlock) = 0;
    virtual void decryptBlock(const dsCypher_word32_t *inBlock, dsCypher_word32_t *outBlock) = 0;

    virtual void ecbEncrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen);
    virtual void ecbDecrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen);

    virtual void cbcEncrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen, const dsCypher_byte_t * iv );
    virtual void cbcDecrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen, const dsCypher_byte_t * iv );

    virtual void ofbXOR(dsCypher_byte_t *p_dest,  const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen, const dsCypher_byte_t * iv );
    
    virtual void ofbXOR(std::ostream& p_dest, std::istream& p_src, const dsCypher_byte_t *ivec);
};





/*================ Inlines ==================================================*/
inline  dsCypher::dsCypher()
{
    _active_key_mode = kmNONE;
}

inline void dsCryptoBase::memSet(dsCypher_byte_t *ptr,  dsCypher_byte_t pattern, dsCypher_word32_t size )
{
#ifdef PalmOS /* PalmOS has broken memset */
    for (dsCypher_word32_t i = 0; i <  size; ++i)
    {
        ptr[i] = pattern;
    }
#else
    memset((void *)ptr,pattern,size);
#endif
}


inline void dsCryptoBase::memCopy(dsCypher_byte_t *dest, const dsCypher_byte_t *src, dsCypher_word32_t size )
{
#ifdef PalmOS
    MemMove( (void *)dest,(void *)src,size);
#else
    memmove( (void *)dest,(void *)src,size);
#endif
}

inline dsCypher_word32_t dsCryptoBase::n2l(const dsCypher_byte_t *c)
{
    dsCypher_word32_t l  =( (dsCypher_word32_t) c[0]) << 24L;
              l |=( (dsCypher_word32_t) c[1]) << 16L; 
              l |=( (dsCypher_word32_t) c[2]) << 8L; 
              l |=( (dsCypher_word32_t) c[3]);

    return l;
}

inline dsCypher_word32_t dsCryptoBase::n2le(const dsCypher_byte_t *c)
{
    dsCypher_word32_t l  =( (dsCypher_word32_t) c[3]) << 24L;
              l |=( (dsCypher_word32_t) c[2]) << 16L; 
              l |=( (dsCypher_word32_t) c[1]) << 8L; 
              l |=( (dsCypher_word32_t) c[0]);

    return l;
}


inline void dsCryptoBase::l2n(dsCypher_word32_t l, dsCypher_byte_t *c)  
{
    c[0] = (dsCypher_byte_t)( (l >>24L) & 0xff);
    c[1] = (dsCypher_byte_t)( (l >>16L) & 0xff);
    c[2] = (dsCypher_byte_t)( (l >> 8L) & 0xff);
    c[3] = (dsCypher_byte_t)( (l      ) & 0xff);
}


inline void dsCryptoBase::l2ne(dsCypher_word32_t l, dsCypher_byte_t *c)  
{
    c[3] = (dsCypher_byte_t)( (l >>24L) & 0xff);
    c[2] = (dsCypher_byte_t)( (l >>16L) & 0xff);
    c[1] = (dsCypher_byte_t)( (l >> 8L) & 0xff);
    c[0] = (dsCypher_byte_t)( (l      ) & 0xff);
}

/*  Decodes input (dsCypher_byte_t) into output (dsCypher_word32_t). 
    Assumes len is a multiple of 4.
 */
inline void dsCryptoBase::n_n2le(dsCypher_word32_t *dest, const dsCypher_byte_t* src, dsCypher_word32_t srcLen)
{
    for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
        dest[i] = n2le(src+j);
}


inline void dsCryptoBase::n_n2l(dsCypher_word32_t *dest, const dsCypher_byte_t* src, dsCypher_word32_t srcLen)
{
    for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
        dest[i] = n2l(src+j);
}


/*  Encodes input (dsCypher_word32_t) into output (dsCypher_byte_t). Assumes len is
    a multiple of 4.
 */
inline void dsCryptoBase::n_l2ne(dsCypher_byte_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen)
{
    for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
        l2ne(src[i],dest+j);
}

inline void dsCryptoBase::n_l2n(dsCypher_byte_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen)
{
    for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
            l2n(src[i],dest+j);
}

inline void dsCryptoBase::n_xor(dsCypher_word32_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t p_size) 
{
    for (dsCypher_word32_t i = 0; i < p_size; ++i)
        dest[i] ^= src[i];
}

inline  dsCypher_word32_t dsCryptoBase::rotl(dsCypher_word32_t x, dsCypher_word32_t n)
{
    return (x << n) | (x >> (32 - n));
}

inline  dsCypher_word32_t dsCryptoBase::rotr(dsCypher_word32_t x, dsCypher_word32_t n)
{
    return (x >> n) | (x << (32 - n));
}


#endif

---