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

# dkcArcfour.h

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

`#include "dkcOSIndependent.h"`

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

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

ソースコードを見る。

## 構成
struct | dkc_Arcfour_State
| arcfour state (RC4互換のアルゴリズム [詳細]
struct | dkc_Arcfour2byte_State
| Arcfourを2バイトに拡張したもの 暗号強度、安全性等は不明　使用は控えた方が良いかと･･･ [詳細]
## マクロ定義
#define | dkcArcfourByte(s) dkcArcfourProcess(s)
#define | dkcArcfourDecrypt(p, dest, destsize, src, srcsize) dkcArcfourEncrypt(p,dest,destsize,src,srcsize)
#define | dkcArcfourDecryptNoDest(p, dest_and_src, dest_and_srcsize) dkcArcfourEncryptNoDest(p,dest_and_src,dest_and_srcsize)
#define | dkcArcfour2ByteDecrypt(p, dest, destsize, src, srcsize) dkcArcfour2ByteEncrypt(p,dest,destsize,src,srcsize)
#define | dkcArcfour2ByteDecryptNoDest(p, dest_and_src, dest_and_srcsize) dkcArcfour2ByteEncryptNoDest(p,dest_and_src,dest_and_srcsize)
## 型定義
typedef dkc_Arcfour_State | DKC_ARCFOUR_STATE
| arcfour state (RC4互換のアルゴリズム
typedef dkc_Arcfour2byte_State | DKC_ARCFOUR2BYTE_STATE
| Arcfourを2バイトに拡張したもの 暗号強度、安全性等は不明　使用は控えた方が良いかと･･･
## 関数
DKC_EXTERN DKC_ARCFOUR_STATE *WINAPI | dkcAllocArcfour (const unsigned char *key, size_t keylen)
DKC_EXTERN int WINAPI | dkcFreeArcfour (DKC_ARCFOUR_STATE **p)
DKC_EXTERN unsigned char WINAPI | dkcArcfourProcess (DKC_ARCFOUR_STATE *p)
DKC_EXTERN int WINAPI | dkcArcfourEncrypt (DKC_ARCFOUR_STATE *p, unsigned char *dest, size_t destsize, const unsigned char *src, size_t srcsize)
DKC_EXTERN void WINAPI | dkcArcfourEncryptNoDest (DKC_ARCFOUR_STATE *p, unsigned char *dest_and_src, size_t dest_and_srcsize)
DKC_EXTERN DKC_ARCFOUR2BYTE_STATE *WINAPI | dkcAllocArcfour2Byte (const unsigned char *key, size_t keylen)
DKC_EXTERN int WINAPI | dkcFreeArcfour2Byte (DKC_ARCFOUR2BYTE_STATE **p)
DKC_EXTERN unsigned short WINAPI | dkcArcfour2ByteProcess (DKC_ARCFOUR2BYTE_STATE *p)
DKC_EXTERN int WINAPI | dkcArcfour2ByteEncrypt (DKC_ARCFOUR2BYTE_STATE *p, unsigned char *dest, size_t destsize, const unsigned char *src, size_t srcsize)
DKC_EXTERN int WINAPI | dkcArcfour2ByteEncryptNoDest (DKC_ARCFOUR2BYTE_STATE *p, unsigned char *dest_and_src, size_t dest_and_srcsize)

## 説明

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

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

## マクロ定義

#define dkcArcfour2ByteDecrypt | ( | p,
|  | dest,
|  | destsize,
|  | src,
|  | srcsize |  | ) | dkcArcfour2ByteEncrypt(p,dest,destsize,src,srcsize)

| dkcArcfour.h の 93 行で定義されています。

#define dkcArcfour2ByteDecryptNoDest | ( | p,
|  | dest_and_src,
|  | dest_and_srcsize |  | ) | dkcArcfour2ByteEncryptNoDest(p,dest_and_src,dest_and_srcsize)

| dkcArcfour.h の 96 行で定義されています。

#define dkcArcfourByte | ( | s |  | ) | dkcArcfourProcess(s)

| dkcArcfour.h の 43 行で定義されています。

#define dkcArcfourDecrypt | ( | p,
|  | dest,
|  | destsize,
|  | src,
|  | srcsize |  | ) | dkcArcfourEncrypt(p,dest,destsize,src,srcsize)

| dkcArcfour.h の 59 行で定義されています。

#define dkcArcfourDecryptNoDest | ( | p,
|  | dest_and_src,
|  | dest_and_srcsize |  | ) | dkcArcfourEncryptNoDest(p,dest_and_src,dest_and_srcsize)

| dkcArcfour.h の 62 行で定義されています。

## 型定義

typedef struct dkc_Arcfour2byte_State DKC_ARCFOUR2BYTE_STATE

| Arcfourを2バイトに拡張したもの 暗号強度、安全性等は不明　使用は控えた方が良いかと･･･

typedef struct dkc_Arcfour_State DKC_ARCFOUR_STATE

| arcfour state (RC4互換のアルゴリズム

## 関数

DKC_EXTERN DKC_ARCFOUR_STATE* WINAPI dkcAllocArcfour | ( | const unsigned char * | key,
|  | size_t | keylen
| ) |

  | 引数:
  | key[in] | keyへのポインタ
  | keylen[in] | keyのサイズ
戻り値: DKC_ARCFOUR_STATE 構造体へのポインタ 覚え書き: 使い終わったらdkcFreeArcfourを使いましょう。 dkcArcfour.c の 13 行で定義されています。 参照先 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_EXTERN DKC_ARCFOUR2BYTE_STATE* WINAPI dkcAllocArcfour2Byte | ( | const unsigned char * | key,
|  | size_t | keylen
| ) |

| dkcArcfour.c の 167 行で定義されています。 参照先 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 }

DKC_EXTERN int WINAPI dkcArcfour2ByteEncrypt | ( | DKC_ARCFOUR2BYTE_STATE * | p,
|  | unsigned char * | dest,
|  | size_t | destsize,
|  | const unsigned char * | src,
|  | size_t | srcsize
| ) |

| dkcArcfour.c の 285 行で定義されています。 参照先 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 }

DKC_EXTERN int WINAPI dkcArcfour2ByteEncryptNoDest | ( | DKC_ARCFOUR2BYTE_STATE * | p,
|  | unsigned char * | dest_and_src,
|  | size_t | dest_and_srcsize
| ) |

| dkcArcfour.c の 311 行で定義されています。 参照先 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_EXTERN unsigned short WINAPI dkcArcfour2ByteProcess | ( | DKC_ARCFOUR2BYTE_STATE * | p | ) |

| dkcArcfour.c の 216 行で定義されています。 参照先 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 }

DKC_EXTERN 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.c の 130 行で定義されています。 参照先 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 }

DKC_EXTERN void WINAPI dkcArcfourEncryptNoDest | ( | DKC_ARCFOUR_STATE * | p,
|  | unsigned char * | dest_and_src,
|  | size_t | dest_and_srcsize
| ) |

| dkcArcfour.c の 149 行で定義されています。 参照先 dkcArcfourEncrypt_Base().
    00151 {
    00152     dkcArcfourEncrypt_Base(p,dest_and_src,dest_and_src,dest_and_srcsize);
    00153 }

DKC_EXTERN unsigned char WINAPI dkcArcfourProcess | ( | DKC_ARCFOUR_STATE * | p | ) |

  | 引数:
  | p[in][out] | dkcAllocArcfour()で確保した領域へのポインタ
戻り値: XORすべき値 dkcArcfour.c の 64 行で定義されています。 参照先 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 }

DKC_EXTERN int WINAPI dkcFreeArcfour | ( | DKC_ARCFOUR_STATE ** | p | ) |

  | 引数:
  | dkcAllocArcfourで確保した領域へのポインタへのポインタ |
戻り値: edk_SUCCEEDEDで成功 dkcArcfour.c の 155 行で定義されています。 参照先 dkcFree(), と NULL.
    00155                                                 {
    00156     if(NULL==p){
    00157         return edk_FAILED;
    00158     }
    00159     return dkcFree((void **)p);
    00160 }

DKC_EXTERN int WINAPI dkcFreeArcfour2Byte | ( | DKC_ARCFOUR2BYTE_STATE ** | p | ) |

| dkcArcfour.c の 324 行で定義されています。 参照先 dkcFree(), と NULL.
    00324                                                           {
    00325     if(NULL==p){
    00326         return edk_FAILED;
    00327     }
    00328     return dkcFree((void **)p);
    00329 }