Main Page   Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

dsCypher.h

Go to the documentation of this file.
00001 
00040 #ifndef dsCypher_h
00041 #define dsCypher_h
00042  
00043 #ifdef HAVE_CONFIG_H
00044 # include <config.h>
00045 #endif
00046 
00047 #include <string.h>
00048 
00049 #include <iostream>
00050 
00051 #ifdef PalmOS
00052     typedef  UInt32 dsCypher_word32_t;  
00053     typedef  UInt16 dsCypher_word16_t;  
00054     typedef  UInt8  dsCypher_byte_t;    
00055 #else
00056     typedef unsigned long  dsCypher_word32_t;
00057     typedef unsigned short dsCypher_word16_t; 
00058     typedef unsigned char  dsCypher_byte_t;
00059 #endif
00060 
00061 #ifdef PalmOS
00062 # define dsCypher_SECTION   __attribute__ ((section ("Crypto")))
00063 #else
00064 # define dsCypher_SECTION  
00065 #endif
00066 
00067 
00068 class dsCryptoBase
00069 {
00070 protected:
00071 
00078     void memSet (dsCypher_byte_t *ptr,  dsCypher_byte_t pattern, dsCypher_word32_t size );
00079     void memCopy(dsCypher_byte_t *dest, const dsCypher_byte_t *src,   dsCypher_word32_t size );
00080 
00085     dsCypher_word32_t n2l(const dsCypher_byte_t *c);
00086     dsCypher_word32_t n2le(const dsCypher_byte_t *c);
00087 
00088     void l2n(dsCypher_word32_t l, dsCypher_byte_t *c );
00089     void l2ne(dsCypher_word32_t l, dsCypher_byte_t *c );
00090 
00091     void n_n2l (dsCypher_word32_t *dest, const dsCypher_byte_t   *src, dsCypher_word32_t srcLen);
00092     void n_n2le(dsCypher_word32_t *dest, const dsCypher_byte_t   *src, dsCypher_word32_t srcLen);
00093     void n_l2n (dsCypher_byte_t   *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen);
00094     void n_l2ne(dsCypher_byte_t   *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen);
00095     void n_xor (dsCypher_word32_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t size); 
00096 
00097 
00098     dsCypher_word32_t rotl(dsCypher_word32_t x, dsCypher_word32_t n);
00099     dsCypher_word32_t rotr(dsCypher_word32_t x, dsCypher_word32_t n);
00100 
00101 
00102 #ifdef WITH_TEST_VECTORS
00103 public:
00104     virtual const dsCypher_byte_t * testData();
00105     virtual const dsCypher_word32_t testDataLen();
00106     virtual const char *testAlgName();
00107 #endif
00108 
00109 };
00110 
00111 class dsCryptoHash : public dsCryptoBase
00112 {
00113 
00114 public:
00118     virtual void cryptoHash(dsCypher_byte_t *p_digest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen) = 0;
00119     virtual const dsCypher_word32_t digestSize() = 0;
00120 
00121 #ifdef WITH_TEST_VECTORS
00122     virtual const dsCypher_byte_t * testExpectedResult();
00123 #endif
00124 
00125 };
00126 
00127 
00128 class dsCypher : public dsCryptoBase
00129 {
00130 protected:
00131     dsCypher_word32_t   _block_size; // sizeof algorithm block, bytes
00132 
00133 public:
00134     enum keyMode{ kmNONE = 0,  kmENCRYPT=0x2, kmDECRYPT=0x4, 
00135                   kmOFB = kmENCRYPT, kmBOTH=kmENCRYPT | kmDECRYPT};
00136     
00137     keyMode _active_key_mode; 
00138 
00139 
00146     virtual void setKey(const dsCypher_byte_t *p_key, dsCypher_word32_t p_keyLen, keyMode km) = 0;
00147             bool ready(){ return _active_key_mode != kmNONE;}
00148 
00149     dsCypher();
00150 
00151 
00152 #ifdef WITH_TEST_VECTORS
00153     enum cmMODES{ cmNONE, cmECB, cmCBC, cmOFB };
00154 
00155     static const dsCypher_byte_t ivec[16];
00156 
00157     virtual const dsCypher_byte_t * testKey();
00158     virtual const dsCypher_word32_t testKeyLen();
00159     virtual const dsCypher_byte_t * testExpectedResult( cmMODES p_mode );
00160     virtual const dsCypher_word32_t testExpectedResultLen(cmMODES p_mode);
00161 #endif
00162 };
00163 
00164 
00165 
00166 class dsBlockCypher : public dsCypher
00167 {
00168 public:
00169     
00173     virtual void encryptBlock(const dsCypher_word32_t *inBlock, dsCypher_word32_t *outBlock) = 0;
00174     virtual void decryptBlock(const dsCypher_word32_t *inBlock, dsCypher_word32_t *outBlock) = 0;
00175 
00179     virtual void ecbEncrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen);
00180     virtual void ecbDecrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen);
00181 
00185     virtual void cbcEncrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen, const dsCypher_byte_t * iv );
00186     virtual void cbcDecrypt(dsCypher_byte_t *p_dest, const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen, const dsCypher_byte_t * iv );
00187 
00191     virtual void ofbXOR(dsCypher_byte_t *p_dest,  const dsCypher_byte_t *p_src, dsCypher_word32_t p_srcLen, const dsCypher_byte_t * iv );
00192     
00194     virtual void ofbXOR(std::ostream& p_dest, std::istream& p_src, const dsCypher_byte_t *ivec);
00195 };
00196 
00197 
00198 
00199 
00200 
00201 /*================ Inlines ==================================================*/
00202 inline  dsCypher::dsCypher()
00203 {
00204     _active_key_mode = kmNONE;
00205 }
00206 
00207 inline void dsCryptoBase::memSet(dsCypher_byte_t *ptr,  dsCypher_byte_t pattern, dsCypher_word32_t size )
00208 {
00209 #ifdef PalmOS /* PalmOS has broken memset */
00210     for (dsCypher_word32_t i = 0; i <  size; ++i)
00211     {
00212         ptr[i] = pattern;
00213     }
00214 #else
00215     memset((void *)ptr,pattern,size);
00216 #endif
00217 }
00218 
00219 
00220 inline void dsCryptoBase::memCopy(dsCypher_byte_t *dest, const dsCypher_byte_t *src, dsCypher_word32_t size )
00221 {
00222 #ifdef PalmOS
00223     MemMove( (void *)dest,(void *)src,size);
00224 #else
00225     memmove( (void *)dest,(void *)src,size);
00226 #endif
00227 }
00228 
00229 inline dsCypher_word32_t dsCryptoBase::n2l(const dsCypher_byte_t *c)
00230 {
00231     dsCypher_word32_t l  =( (dsCypher_word32_t) c[0]) << 24L;
00232               l |=( (dsCypher_word32_t) c[1]) << 16L; 
00233               l |=( (dsCypher_word32_t) c[2]) << 8L; 
00234               l |=( (dsCypher_word32_t) c[3]);
00235 
00236     return l;
00237 }
00238 
00239 inline dsCypher_word32_t dsCryptoBase::n2le(const dsCypher_byte_t *c)
00240 {
00241     dsCypher_word32_t l  =( (dsCypher_word32_t) c[3]) << 24L;
00242               l |=( (dsCypher_word32_t) c[2]) << 16L; 
00243               l |=( (dsCypher_word32_t) c[1]) << 8L; 
00244               l |=( (dsCypher_word32_t) c[0]);
00245 
00246     return l;
00247 }
00248 
00249 
00250 inline void dsCryptoBase::l2n(dsCypher_word32_t l, dsCypher_byte_t *c)  
00251 {
00252     c[0] = (dsCypher_byte_t)( (l >>24L) & 0xff);
00253     c[1] = (dsCypher_byte_t)( (l >>16L) & 0xff);
00254     c[2] = (dsCypher_byte_t)( (l >> 8L) & 0xff);
00255     c[3] = (dsCypher_byte_t)( (l      ) & 0xff);
00256 }
00257 
00258 
00259 inline void dsCryptoBase::l2ne(dsCypher_word32_t l, dsCypher_byte_t *c)  
00260 {
00261     c[3] = (dsCypher_byte_t)( (l >>24L) & 0xff);
00262     c[2] = (dsCypher_byte_t)( (l >>16L) & 0xff);
00263     c[1] = (dsCypher_byte_t)( (l >> 8L) & 0xff);
00264     c[0] = (dsCypher_byte_t)( (l      ) & 0xff);
00265 }
00266 
00267 /*  Decodes input (dsCypher_byte_t) into output (dsCypher_word32_t). 
00268     Assumes len is a multiple of 4.
00269  */
00270 inline void dsCryptoBase::n_n2le(dsCypher_word32_t *dest, const dsCypher_byte_t* src, dsCypher_word32_t srcLen)
00271 {
00272     for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
00273         dest[i] = n2le(src+j);
00274 }
00275 
00276 
00277 inline void dsCryptoBase::n_n2l(dsCypher_word32_t *dest, const dsCypher_byte_t* src, dsCypher_word32_t srcLen)
00278 {
00279     for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
00280         dest[i] = n2l(src+j);
00281 }
00282 
00283 
00284 /*  Encodes input (dsCypher_word32_t) into output (dsCypher_byte_t). Assumes len is
00285     a multiple of 4.
00286  */
00287 inline void dsCryptoBase::n_l2ne(dsCypher_byte_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen)
00288 {
00289     for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
00290         l2ne(src[i],dest+j);
00291 }
00292 
00293 inline void dsCryptoBase::n_l2n(dsCypher_byte_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t srcLen)
00294 {
00295     for (dsCypher_word32_t i = 0, j = 0; j < srcLen; i++, j += 4)
00296             l2n(src[i],dest+j);
00297 }
00298 
00299 inline void dsCryptoBase::n_xor(dsCypher_word32_t *dest, const dsCypher_word32_t *src, dsCypher_word32_t p_size) 
00300 {
00301     for (dsCypher_word32_t i = 0; i < p_size; ++i)
00302         dest[i] ^= src[i];
00303 }
00304 
00305 inline  dsCypher_word32_t dsCryptoBase::rotl(dsCypher_word32_t x, dsCypher_word32_t n)
00306 {
00307     return (x << n) | (x >> (32 - n));
00308 }
00309 
00310 inline  dsCypher_word32_t dsCryptoBase::rotr(dsCypher_word32_t x, dsCypher_word32_t n)
00311 {
00312     return (x >> n) | (x << (32 - n));
00313 }
00314 
00315 
00316 #endif

Generated on Mon May 16 18:26:57 2005 for libdms4 by doxygen1.3-rc2