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

dkcArcfour.c

RC4互換アルゴリズム Arcfour stream cipher algorithm [詳細]

#include "dkcArcfour.h"
#include "dkcStdio.h"

dkcArcfour.cのインクルード依存関係図

ソースコードを見る。

マクロ定義

#define DKUTIL_C_ARCFOUR_C

関数

DKC_ARCFOUR_STATE *WINAPI dkcAllocArcfour (const unsigned char *key, size_t keylen)
DKC_INLINE unsigned char WINAPI dkcArcfourProcess (DKC_ARCFOUR_STATE *p)
static DKC_INLINE void dkcArcfourEncrypt_Base (DKC_ARCFOUR_STATE *p, unsigned char *dest, unsigned const char *src, size_t srcsize)
int WINAPI dkcArcfourEncrypt (DKC_ARCFOUR_STATE *p, unsigned char *dest, size_t destsize, const unsigned char *src, size_t srcsize)
void WINAPI dkcArcfourEncryptNoDest (DKC_ARCFOUR_STATE *p, unsigned char *dest_and_src, size_t dest_and_srcsize)
int WINAPI dkcFreeArcfour (DKC_ARCFOUR_STATE **p)
DKC_ARCFOUR2BYTE_STATE *WINAPI dkcAllocArcfour2Byte (const unsigned char *key, size_t keylen)
DKC_INLINE unsigned short
WINAPI 
dkcArcfour2ByteProcess (DKC_ARCFOUR2BYTE_STATE *p)
static DKC_INLINE void dkcArcfour2ByteEncrypt_Base (DKC_ARCFOUR2BYTE_STATE *p, unsigned short *dest, unsigned const short *src, size_t srcsize)
int WINAPI dkcArcfour2ByteEncrypt (DKC_ARCFOUR2BYTE_STATE *p, unsigned char *dest, size_t destsize, const unsigned char *src, size_t srcsize)
int WINAPI dkcArcfour2ByteEncryptNoDest (DKC_ARCFOUR2BYTE_STATE *p, unsigned char *dest_and_src, size_t dest_and_srcsize)
int WINAPI dkcFreeArcfour2Byte (DKC_ARCFOUR2BYTE_STATE **p)


説明

RC4互換アルゴリズム Arcfour stream cipher algorithm

作者:
d金魚

dkcArcfour.c で定義されています。


マクロ定義

#define DKUTIL_C_ARCFOUR_C
 

dkcArcfour.c7 行で定義されています。


関数

DKC_ARCFOUR_STATE* WINAPI dkcAllocArcfour const unsigned char *  key,
size_t  keylen
 

引数:
key[in] keyへのポインタ
keylen[in] keyのサイズ
戻り値:
DKC_ARCFOUR_STATE 構造体へのポインタ
覚え書き:
使い終わったらdkcFreeArcfourを使いましょう。

dkcArcfour.c13 行で定義されています。

参照先 dkcAllocate(), dkc_Arcfour_State::msbox, NULL, と uint8.

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 }

DKC_ARCFOUR2BYTE_STATE* WINAPI dkcAllocArcfour2Byte const unsigned char *  key,
size_t  keylen
 

dkcArcfour.c167 行で定義されています。

参照先 dkcAllocate(), dkc_Arcfour2byte_State::msbox, NULL, と uint16.

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 }

int WINAPI dkcArcfour2ByteEncrypt DKC_ARCFOUR2BYTE_STATE p,
unsigned char *  dest,
size_t  destsize,
const unsigned char *  src,
size_t  srcsize
 

dkcArcfour.c285 行で定義されています。

参照先 dkcArcfour2ByteEncrypt_Base().

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 }

static DKC_INLINE void dkcArcfour2ByteEncrypt_Base DKC_ARCFOUR2BYTE_STATE p,
unsigned short *  dest,
unsigned const short *  src,
size_t  srcsize
[static]
 

引数:
srcsize[in] バイト単位のサイズではなく、unsigned short単位の数

dkcArcfour.c245 行で定義されています。

参照先 dkc_Arcfour2byte_State::mi, dkc_Arcfour2byte_State::mj, と dkc_Arcfour2byte_State::msbox.

参照元 dkcArcfour2ByteEncrypt(), と dkcArcfour2ByteEncryptNoDest().

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 }

int WINAPI dkcArcfour2ByteEncryptNoDest DKC_ARCFOUR2BYTE_STATE p,
unsigned char *  dest_and_src,
size_t  dest_and_srcsize
 

dkcArcfour.c311 行で定義されています。

参照先 dkcArcfour2ByteEncrypt_Base().

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 }

DKC_INLINE unsigned short WINAPI dkcArcfour2ByteProcess DKC_ARCFOUR2BYTE_STATE p  ) 
 

dkcArcfour.c216 行で定義されています。

参照先 dkc_Arcfour2byte_State::mi, dkc_Arcfour2byte_State::mj, と dkc_Arcfour2byte_State::msbox.

00216                                                                                   {
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 }

int WINAPI dkcArcfourEncrypt DKC_ARCFOUR_STATE p,
unsigned char *  dest,
size_t  destsize,
const unsigned char *  src,
size_t  srcsize
 

引数:
p[in] dkcAllocArcfour()で確保した領域へのポインタ
dest[in] 出力バッファへのポインタ
destsize[in] destのサイズ
src[in] 入力バッファへのポインタ
srcsize[in] srcのサイズ
戻り値:
edk_SUCCEEDED で成功

dkcArcfour.c130 行で定義されています。

参照先 dkcArcfourEncrypt_Base().

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 }

static DKC_INLINE void dkcArcfourEncrypt_Base DKC_ARCFOUR_STATE p,
unsigned char *  dest,
unsigned const char *  src,
size_t  srcsize
[static]
 

dkcArcfour.c89 行で定義されています。

参照先 dkc_Arcfour_State::mi, dkc_Arcfour_State::mj, と dkc_Arcfour_State::msbox.

参照元 dkcArcfourEncrypt(), と dkcArcfourEncryptNoDest().

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 }

void WINAPI dkcArcfourEncryptNoDest DKC_ARCFOUR_STATE p,
unsigned char *  dest_and_src,
size_t  dest_and_srcsize
 

dkcArcfour.c149 行で定義されています。

参照先 dkcArcfourEncrypt_Base().

00151 {
00152     dkcArcfourEncrypt_Base(p,dest_and_src,dest_and_src,dest_and_srcsize);
00153 }

DKC_INLINE unsigned char WINAPI dkcArcfourProcess DKC_ARCFOUR_STATE p  ) 
 

引数:
p[in][out] dkcAllocArcfour()で確保した領域へのポインタ
戻り値:
XORすべき値

dkcArcfour.c64 行で定義されています。

参照先 dkc_Arcfour_State::mi, dkc_Arcfour_State::mj, と dkc_Arcfour_State::msbox.

00064                                                                        {
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 }

int WINAPI dkcFreeArcfour DKC_ARCFOUR_STATE **  p  ) 
 

引数:
dkcAllocArcfourで確保した領域へのポインタへのポインタ 
戻り値:
edk_SUCCEEDEDで成功

dkcArcfour.c155 行で定義されています。

参照先 dkcFree(), と NULL.

00155                                                 {
00156     if(NULL==p){
00157         return edk_FAILED;
00158     }
00159     return dkcFree((void **)p);
00160 }

int WINAPI dkcFreeArcfour2Byte DKC_ARCFOUR2BYTE_STATE **  p  ) 
 

dkcArcfour.c324 行で定義されています。

参照先 dkcFree(), と NULL.

00324                                                           {
00325     if(NULL==p){
00326         return edk_FAILED;
00327     }
00328     return dkcFree((void **)p);
00329 }


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