メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcArcfour.c

説明を見る。
00001 
00007 #define  DKUTIL_C_ARCFOUR_C
00008 #include "dkcArcfour.h"
00009 #include "dkcStdio.h"
00010 
00011 
00012 
00013 DKC_ARCFOUR_STATE *WINAPI dkcAllocArcfour(
00014     const unsigned char *key,size_t keylen)
00015 {
00016 
00017     int i,j;
00018     //unsigned char temp;
00019     unsigned char *sb1,sb2[256];
00020     DKC_ARCFOUR_STATE *p;
00021     if(NULL==key || 0==keylen){
00022         return NULL;
00023     }
00024 
00025     memset(sb2,0,sizeof(sb2));
00026     //allocate state struct
00027     p = (DKC_ARCFOUR_STATE *)dkcAllocate(sizeof(DKC_ARCFOUR_STATE));
00028     if(NULL==p){
00029         return NULL;
00030     }
00031     sb1 = p->msbox;
00032     
00033     //initialize
00034     for(i=0;i<256;i++){
00035         sb1[i] = (unsigned char)i;
00036         //嗅ぎ回られないように(なんか、意味あるのか?ないナァ?
00037         //p->msbox2[i] = key [i % keylen];
00038     }
00039     j=i=0;
00040     
00041     for(;j<256;j++){
00042         sb2[j] = key [j % keylen];
00043     }
00044 
00045 
00046     for(i=0;i<256;i++){
00047         //j = (j + sb1 [i] + sb2 [i]) % 256;
00048         j = (j + sb1[i] + sb2[i]) & 0xff;
00049         
00050         
00051         //swap
00052         SWAP_TEMP(register uint8, sb1 [i],sb1 [j]);
00053         /*temp = sb1 [i];
00054         sb1 [i] = sb1 [j];
00055         sb1 [j] = temp;*/
00056         /*sb1[i] = sb1[j] - sb1[i] ;
00057     sb1[j] -= sb1[i] ;
00058     sb1[i] += sb1[j] ;*/
00059     //SWAP_NUM(sb1[i],sb1[j]);
00060     }
00061     return p;
00062 }
00063 
00064 DKC_INLINE unsigned char WINAPI dkcArcfourProcess(DKC_ARCFOUR_STATE *p){
00065   //unsigned char i,j,temp;
00066     unsigned char i,j;
00067   unsigned char *sb1 = p->msbox;
00068   
00069   //calc
00070   i = (unsigned char )(p->mi+1);// % 256;
00071   j = (unsigned char )(p->mj + sb1[i]);// % 256;
00072   
00073      //swap
00074     SWAP_FAST8( sb1 [i],sb1 [j]);
00075   /*temp = sb1 [i];
00076   sb1 [i] = sb1 [j];
00077   sb1 [j] = temp;
00078     */
00079   //SWAP_NUM(sb1[i],sb1[j]);
00080   //refresh
00081   p->mi = i;
00082   p->mj = j;
00083   //calc
00084   i = (unsigned char )(sb1 [i] + sb1 [j]);// % 256;
00085   j = (unsigned char )sb1[i];
00086   return j;
00087 }
00088 
00089 static DKC_INLINE void dkcArcfourEncrypt_Base(DKC_ARCFOUR_STATE *p,
00090     unsigned char *dest,unsigned const char *src,size_t srcsize)
00091 {
00092 
00093     size_t cc;
00094   unsigned char i,j;
00095   unsigned char *sb1 = p->msbox;
00096     //unsigned char temp;
00097   
00098      //calc
00099     i = (unsigned char )(p->mi);
00100     j = (unsigned char )(p->mj);
00101 
00102     for(cc = 0;cc < srcsize;cc++){
00103              //calc
00104         i = (unsigned char )(i+1);
00105         j = (unsigned char )(j + sb1[i]);
00106   
00107          //swap
00108         
00109         SWAP_FAST8(sb1 [i],sb1 [j]);
00110         /*temp = sb1 [i];
00111         sb1 [i] = sb1 [j];
00112         sb1 [j] = temp;
00113         */
00114 
00115         //SWAP_NUM_EX(sb1[i],sb1[j],unsigned char);
00116 
00117         //calc
00118         dest[cc] = (unsigned char )
00119             (src[cc] ^ (unsigned char )sb1[
00120                 (unsigned char )(sb1 [i] + sb1 [j]) 
00121             ] 
00122         );
00123     }
00124     //refresh
00125     p->mi = i;
00126     p->mj = j;
00127 
00128 }
00129 
00130 int WINAPI dkcArcfourEncrypt(DKC_ARCFOUR_STATE *p,
00131     unsigned char *dest,size_t destsize,
00132     const unsigned char *src,size_t srcsize)
00133 {
00134     //size_t i=0;
00135     if(destsize < srcsize){
00136         return edk_BufferOverFlow;
00137     }
00138     dkcArcfourEncrypt_Base(p,dest,src,srcsize);
00139 
00140     /*for(i = 0;i < srcsize;i++){
00141         dest[i] = (unsigned char )(src[i] ^ dkcArcfourByte(p) );
00142     }*/
00143 
00144     return edk_SUCCEEDED;
00145 }
00146 
00147 
00148 
00149 void WINAPI dkcArcfourEncryptNoDest(DKC_ARCFOUR_STATE *p,
00150     unsigned char *dest_and_src,size_t dest_and_srcsize)
00151 {
00152     dkcArcfourEncrypt_Base(p,dest_and_src,dest_and_src,dest_and_srcsize);
00153 }
00154 
00155 int WINAPI dkcFreeArcfour(DKC_ARCFOUR_STATE **p){
00156     if(NULL==p){
00157         return edk_FAILED;
00158     }
00159     return dkcFree((void **)p);
00160 }
00161 
00162 
00163 
00164 //**********************************************************
00165 //2byteバージョン
00166 
00167 DKC_ARCFOUR2BYTE_STATE *WINAPI dkcAllocArcfour2Byte(
00168     const unsigned char *key,size_t keylen)
00169 {
00170 
00171     int i,j;
00172     //unsigned short temp;
00173     unsigned short *sb1,sb2[USHRT_MAX];
00174     DKC_ARCFOUR2BYTE_STATE *p;
00175     if(NULL==key || 0==keylen){
00176         return NULL;
00177     }
00178     
00179     memset(sb2,0,sizeof(sb2));
00180     //allocate state struct
00181     p = (DKC_ARCFOUR2BYTE_STATE *)dkcAllocate(sizeof(DKC_ARCFOUR2BYTE_STATE));
00182     if(NULL==p){
00183         return NULL;
00184     }
00185     sb1 = p->msbox;
00186     
00187     //initialize
00188     for(i=0;i<USHRT_MAX;i++){
00189         sb1[i] = (unsigned short)i;
00190         //嗅ぎ回られないように(なんか、意味あるのか?ないナァ?
00191         //p->msbox2[i] = key [i % keylen];
00192     }
00193     j=i=0;
00194     
00195     for(;j<USHRT_MAX;j++){
00196         sb2[j] = key [j % keylen];
00197     }
00198 
00199 
00200     for(i=0;i<USHRT_MAX;i++){
00201         //j = (j + sb1 [i] + sb2 [i]) % 256;
00202         j = (j + sb1[i] + sb2[i]) & 0xff;
00203         
00204         SWAP_TEMP(register uint16,sb1 [i],sb1 [j]);
00205         /*temp = sb1 [i];
00206         sb1 [i] = sb1 [j];
00207         sb1 [j] = temp;*/
00208         /*sb1[i] = sb1[j] - sb1[i] ;
00209     sb1[j] -= sb1[i] ;
00210     sb1[i] += sb1[j] ;*/
00211     //SWAP_NUM(sb1[i],sb1[j]);
00212     }
00213     return p;
00214 }
00215 
00216 DKC_INLINE unsigned short WINAPI dkcArcfour2ByteProcess(DKC_ARCFOUR2BYTE_STATE *p){
00217   //unsigned short i,j,temp;
00218     unsigned short i,j;
00219   unsigned short *sb1 = p->msbox;
00220   
00221   //calc
00222   i = (unsigned short )(p->mi+1);// % 256;
00223   j = (unsigned short )(p->mj + sb1[i]);// % 256;
00224   
00225      //swap
00226   SWAP_FAST16(sb1[i],sb1[j]);
00227     /*temp = sb1 [i];
00228   sb1 [i] = sb1 [j];
00229   sb1 [j] = temp;
00230     */
00231   //SWAP_NUM(sb1[i],sb1[j]);
00232   
00233     //refresh
00234   p->mi = i;
00235   p->mj = j;
00236   //calc
00237   i = (unsigned short )(sb1 [i] + sb1 [j]);// % 256;
00238   j = (unsigned short )sb1[i];
00239   return j;
00240 }
00241 
00245 static DKC_INLINE void dkcArcfour2ByteEncrypt_Base(DKC_ARCFOUR2BYTE_STATE *p,
00246     unsigned short *dest,unsigned const short *src,size_t srcsize)
00247 {
00248 
00249     size_t cc;
00250   unsigned short i,j;
00251   unsigned short *sb1 = p->msbox;
00252     //unsigned short temp;
00253   
00254      //calc
00255     i = (unsigned short )(p->mi);
00256     j = (unsigned short )(p->mj);
00257 
00258     for(cc = 0;cc < srcsize;cc++){
00259              //calc
00260         i = (unsigned short )(i+1);
00261         j = (unsigned short )(j + sb1[i]);
00262   
00263          //swap
00264         SWAP_FAST16(sb1[i],sb1[j]);
00265         /*temp = sb1 [i];
00266         sb1 [i] = sb1 [j];
00267         sb1 [j] = temp;
00268         */
00269 
00270         //SWAP_NUM_EX(sb1[i],sb1[j],unsigned char);
00271 
00272         //calc
00273         dest[cc] = (unsigned short )
00274             (src[cc] ^ (unsigned short )sb1[
00275                 (unsigned short )(sb1 [i] + sb1 [j]) 
00276             ] 
00277         );
00278     }
00279     //refresh
00280     p->mi = i;
00281     p->mj = j;
00282 
00283 }
00284 
00285 int WINAPI dkcArcfour2ByteEncrypt(DKC_ARCFOUR2BYTE_STATE *p,
00286     unsigned char *dest,size_t destsize,
00287     const unsigned char *src,size_t srcsize)
00288 {
00289     //size_t i=0;
00290     if(destsize < srcsize){
00291         return edk_BufferOverFlow;
00292     }
00293     if(srcsize % 2 != 0){//2の倍数じゃないとねぇ
00294         return edk_ArgumentException;
00295     }
00296 
00297     dkcArcfour2ByteEncrypt_Base(p,
00298         (unsigned short *)dest,(unsigned short *)src,
00299         srcsize / 2
00300     );
00301 
00302     /*for(i = 0;i < srcsize;i++){
00303         dest[i] = (unsigned char )(src[i] ^ dkcArcfourByte(p) );
00304     }*/
00305 
00306     return edk_SUCCEEDED;
00307 }
00308 
00309 
00310 
00311 int WINAPI dkcArcfour2ByteEncryptNoDest(DKC_ARCFOUR2BYTE_STATE *p,
00312     unsigned char *dest_and_src,size_t dest_and_srcsize)
00313 {
00314     if(dest_and_srcsize % 2 != 0){//2の倍数じゃないとねぇ
00315         return edk_ArgumentException;
00316     }
00317     dkcArcfour2ByteEncrypt_Base(p,
00318         (unsigned short *)dest_and_src,(unsigned short *)dest_and_src,
00319         dest_and_srcsize / 2
00320     );
00321     return edk_SUCCEEDED;
00322 }
00323 
00324 int WINAPI dkcFreeArcfour2Byte(DKC_ARCFOUR2BYTE_STATE **p){
00325     if(NULL==p){
00326         return edk_FAILED;
00327     }
00328     return dkcFree((void **)p);
00329 }
00330 
00331 
00332 
00333 

dkutil_cに対してMon Jan 16 00:39:44 2006に生成されました。  doxygen 1.4.4